@shoppexio/storefront-react 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,2801 @@
+import {
+  ACCOUNT_ARTIFACT_CAPABILITIES,
+  ACCOUNT_PATH,
+  ACCOUNT_PATH_ALIAS,
+  ACCOUNT_STOREFRONT_ROUTES,
+  ACCOUNT_TABS,
+  DEFAULT_ACCOUNT_TAB,
+  IMPLEMENTED_ACCOUNT_TABS,
+  SERVING_CONTEXT_HINT,
+  accountOrderHref,
+  accountTabHref,
+  accountTabLabelKey,
+  canonicalAccountPath,
+  getBuyerCurrency,
+  getShoppex,
+  isAccountTab,
+  isImplementedAccountTab,
+  parseAccountPath,
+  resolveAccountView
+} from "./chunk-D6XKDVAV.js";
+
+// src/account-route-messages.ts
+var ACCOUNT_ROUTE_MESSAGE_KEYS = [
+  "account.checkingSession",
+  "common.notLoaded",
+  "common.genericError",
+  "common.retry"
+];
+var ACCOUNT_ROUTE_MESSAGES = {
+  ar: ["\u062C\u0627\u0631\u064D \u0627\u0644\u062A\u062D\u0642\u0642 \u0645\u0646 \u062C\u0644\u0633\u062A\u0643", "\u062A\u0639\u0630\u0651\u0631 \u062A\u062D\u0645\u064A\u0644 \u0647\u0630\u0627", "\u062A\u0639\u0630\u0651\u0631 \u062A\u062D\u0645\u064A\u0644 \u0647\u0630\u0627. \u064A\u064F\u0631\u062C\u0649 \u0627\u0644\u0645\u062D\u0627\u0648\u0644\u0629 \u0628\u0639\u062F \u0642\u0644\u064A\u0644.", "\u0623\u0639\u062F \u0627\u0644\u0645\u062D\u0627\u0648\u0644\u0629"],
+  de: ["Deine Sitzung wird gepr\xFCft", "Das wurde nicht geladen", "Das konnte nicht geladen werden. Bitte versuche es gleich noch einmal.", "Erneut versuchen"],
+  en: ["Checking your session", "This did not load", "This could not be loaded. Please try again in a moment.", "Try again"],
+  es: ["Comprobando tu sesi\xF3n", "Esto no se carg\xF3", "No se pudo cargar. Int\xE9ntalo de nuevo en un momento.", "Int\xE9ntalo de nuevo"],
+  fi: ["Tarkistetaan istuntoasi", "T\xE4m\xE4 ei latautunut", "T\xE4t\xE4 ei voitu ladata. Yrit\xE4 hetken kuluttua uudelleen.", "Yrit\xE4 uudelleen"],
+  fr: ["V\xE9rification de votre session", "Le chargement a \xE9chou\xE9", "Le chargement a \xE9chou\xE9. R\xE9essayez dans un instant.", "R\xE9essayer"],
+  hi: ["\u0906\u092A\u0915\u093E \u0938\u0924\u094D\u0930 \u091C\u093E\u0901\u091A\u093E \u091C\u093E \u0930\u0939\u093E \u0939\u0948", "\u092F\u0939 \u0932\u094B\u0921 \u0928\u0939\u0940\u0902 \u0939\u0941\u0906", "\u092F\u0939 \u0932\u094B\u0921 \u0928\u0939\u0940\u0902 \u0939\u094B \u0938\u0915\u093E\u0964 \u0915\u0943\u092A\u092F\u093E \u0925\u094B\u0921\u093C\u0940 \u0926\u0947\u0930 \u092C\u093E\u0926 \u092B\u093F\u0930 \u0915\u094B\u0936\u093F\u0936 \u0915\u0930\u0947\u0902\u0964", "\u092B\u093F\u0930 \u0915\u094B\u0936\u093F\u0936 \u0915\u0930\u0947\u0902"],
+  it: ["Verifica della tua sessione", "Caricamento non riuscito", "Non \xE8 stato possibile caricare questo contenuto. Riprova tra poco.", "Riprova"],
+  lt: ["Tikriname j\u016Bs\u0173 seans\u0105", "\u0160is turinys ne\u012Fsik\u0117l\u0117", "Nepavyko to \u012Fkelti. Po akimirkos bandykite dar kart\u0105.", "Bandykite dar kart\u0105"],
+  nl: ["Je sessie wordt gecontroleerd", "Dit is niet geladen", "Dit kon niet worden geladen. Probeer het zo meteen opnieuw.", "Probeer opnieuw"],
+  pl: ["Sprawdzamy Twoj\u0105 sesj\u0119", "To si\u0119 nie wczyta\u0142o", "Nie uda\u0142o si\u0119 tego wczyta\u0107. Spr\xF3buj ponownie za chwil\u0119.", "Spr\xF3buj ponownie"],
+  pt: ["A verificar a tua sess\xE3o", "Isto n\xE3o carregou", "N\xE3o foi poss\xEDvel carregar isto. Tenta de novo daqui a pouco.", "Tentar de novo"],
+  ru: ["\u041F\u0440\u043E\u0432\u0435\u0440\u044F\u0435\u043C \u0432\u0430\u0448\u0443 \u0441\u0435\u0441\u0441\u0438\u044E", "\u042D\u0442\u043E \u043D\u0435 \u0437\u0430\u0433\u0440\u0443\u0437\u0438\u043B\u043E\u0441\u044C", "\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u0437\u0430\u0433\u0440\u0443\u0437\u0438\u0442\u044C \u044D\u0442\u043E. \u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u0435 \u043F\u043E\u043F\u044B\u0442\u043A\u0443 \u0447\u0435\u0440\u0435\u0437 \u043C\u0438\u043D\u0443\u0442\u0443.", "\u041F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u044C"],
+  tr: ["Oturumunuz kontrol ediliyor", "Bu y\xFCklenemedi", "Bu y\xFCklenemedi. L\xFCtfen birazdan tekrar deneyin.", "Tekrar deneyin"],
+  uk: ["\u041F\u0435\u0440\u0435\u0432\u0456\u0440\u044F\u0454\u043C\u043E \u0432\u0430\u0448\u0443 \u0441\u0435\u0441\u0456\u044E", "\u0426\u0435 \u043D\u0435 \u0437\u0430\u0432\u0430\u043D\u0442\u0430\u0436\u0438\u043B\u043E\u0441\u044F", "\u041D\u0435 \u0432\u0434\u0430\u043B\u043E\u0441\u044F \u0437\u0430\u0432\u0430\u043D\u0442\u0430\u0436\u0438\u0442\u0438. \u0421\u043F\u0440\u043E\u0431\u0443\u0439\u0442\u0435 \u0449\u0435 \u0440\u0430\u0437 \u0437\u0430 \u0445\u0432\u0438\u043B\u0438\u043D\u0443.", "\u0421\u043F\u0440\u043E\u0431\u0443\u0432\u0430\u0442\u0438 \u0449\u0435 \u0440\u0430\u0437"],
+  zh: ["\u6B63\u5728\u68C0\u67E5\u767B\u5F55\u72B6\u6001", "\u6B64\u5185\u5BB9\u672A\u52A0\u8F7D", "\u65E0\u6CD5\u52A0\u8F7D\u6B64\u5185\u5BB9\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", "\u91CD\u8BD5"]
+};
+function resolveAccountRouteLocale(lang) {
+  const base = (lang ?? "").trim().toLowerCase().split(/[-_]/)[0] ?? "";
+  return base in ACCOUNT_ROUTE_MESSAGES ? base : "en";
+}
+function accountRouteMessage(key, lang) {
+  const activeLang = lang === void 0 && typeof document !== "undefined" ? document.documentElement.getAttribute("lang") : lang;
+  const messageIndex = ACCOUNT_ROUTE_MESSAGE_KEYS.indexOf(key);
+  return ACCOUNT_ROUTE_MESSAGES[resolveAccountRouteLocale(activeLang)][messageIndex];
+}
+
+// src/cart.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+
+// src/parse.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireUnknownRecord(value, context) {
+  if (!isRecord(value)) {
+    throw new Error(`Invalid Shoppex ${context}: expected an object.`);
+  }
+  return value;
+}
+function requireRecord(record, key) {
+  return requireUnknownRecord(record[key], key);
+}
+function requireArray(record, key) {
+  const value = record[key];
+  if (!Array.isArray(value)) {
+    throw new Error(`Invalid Shoppex config: ${key} must be an array.`);
+  }
+  return value;
+}
+function requireString(record, key, context) {
+  const value = record[key];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Invalid Shoppex ${context}: ${key} must be a non-empty string.`);
+  }
+  return value;
+}
+function requireStringFromKeys(record, keys, context) {
+  for (const key of keys) {
+    const value = optionalString(record[key]);
+    if (value) return value;
+  }
+  throw new Error(`Invalid Shoppex ${context}: ${keys.join(" or ")} must be a non-empty string.`);
+}
+function requireNumber(record, key, context) {
+  const value = record[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Invalid Shoppex ${context}: ${key} must be a finite number.`);
+  }
+  return value;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function firstOptionalString(record, keys) {
+  for (const key of keys) {
+    const value = optionalString(record[key]);
+    if (value) return value;
+  }
+  return null;
+}
+function optionalStringWithDefault(value, fallback, context) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  if (typeof value !== "string") {
+    throw new Error(`Invalid Shoppex ${context}: expected a string.`);
+  }
+  return value.trim() || fallback;
+}
+function requireBoolean(value, context) {
+  if (typeof value === "boolean") return value;
+  if (value === 0 || value === 1) return value === 1;
+  throw new Error(`Invalid Shoppex ${context}: expected a boolean.`);
+}
+function optionalBoolean(value, fallback, context) {
+  if (value === void 0 || value === null) return fallback;
+  if (typeof value === "boolean") return value;
+  if (value === 0 || value === 1) return value === 1;
+  throw new Error(`Invalid Shoppex ${context}: expected a boolean.`);
+}
+function parseFiniteNumber(value, context) {
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Invalid Shoppex ${context}: expected a finite number.`);
+  }
+  return parsed;
+}
+function parseEnum(value, allowed, fallback, context) {
+  if (value === void 0 || value === null || value === "") return fallback;
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new Error(`Invalid Shoppex ${context}: expected one of ${allowed.join(", ")}.`);
+  }
+  return value;
+}
+
+// src/product-badges.ts
+var MAX_PRODUCT_BADGES = 4;
+var MAX_PRODUCT_BADGE_LABEL_LENGTH = 24;
+var PRODUCT_BADGE_ICON_NAMES = [
+  "sparkles",
+  "flame",
+  "star",
+  "zap",
+  "tag",
+  "percent",
+  "trending-up",
+  "megaphone",
+  "party-popper",
+  "crown",
+  "gem",
+  "trophy",
+  "award",
+  "medal",
+  "badge-check",
+  "thumbs-up",
+  "heart",
+  "shield",
+  "shield-check",
+  "lock",
+  "handshake",
+  "rocket",
+  "truck",
+  "clock",
+  "timer",
+  "infinity",
+  "refresh-ccw",
+  "download",
+  "package",
+  "send",
+  "headphones",
+  "message-circle",
+  "life-buoy",
+  "users",
+  "gamepad-2",
+  "monitor",
+  "smartphone",
+  "key",
+  "file-text",
+  "book-open",
+  "music",
+  "video",
+  "image",
+  "palette",
+  "code",
+  "wrench",
+  "wallet",
+  "credit-card",
+  "globe",
+  "gift",
+  "bot"
+];
+var HEX_SHORT = /^#[0-9a-f]{3}$/i;
+var HEX_LONG = /^#[0-9a-f]{6}$/i;
+function normalizeBadgeColor(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  const candidate = trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
+  if (HEX_LONG.test(candidate)) return candidate.toLowerCase();
+  if (HEX_SHORT.test(candidate)) {
+    const [, r, g, b] = candidate.toLowerCase();
+    return `#${r}${r}${g}${g}${b}${b}`;
+  }
+  return null;
+}
+function channelLuminance(value) {
+  const channel = value / 255;
+  return channel <= 0.04045 ? channel / 12.92 : ((channel + 0.055) / 1.055) ** 2.4;
+}
+function relativeLuminance(hex) {
+  const r = Number.parseInt(hex.slice(1, 3), 16);
+  const g = Number.parseInt(hex.slice(3, 5), 16);
+  const b = Number.parseInt(hex.slice(5, 7), 16);
+  return 0.2126 * channelLuminance(r) + 0.7152 * channelLuminance(g) + 0.0722 * channelLuminance(b);
+}
+var BADGE_DARK_FOREGROUND = "#0b0b0f";
+var BADGE_LIGHT_FOREGROUND = "#ffffff";
+function resolveBadgeForeground(backgroundColor) {
+  if (backgroundColor === null) return null;
+  const background = relativeLuminance(backgroundColor);
+  const contrastWithWhite = 1.05 / (background + 0.05);
+  const contrastWithBlack = (background + 0.05) / (relativeLuminance(BADGE_DARK_FOREGROUND) + 0.05);
+  return contrastWithWhite >= contrastWithBlack ? BADGE_LIGHT_FOREGROUND : BADGE_DARK_FOREGROUND;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readVisibility(value) {
+  if (typeof value === "boolean") return value;
+  if (value === 1 || value === "1" || value === "true") return true;
+  if (value === 0 || value === "0" || value === "false") return false;
+  return true;
+}
+function readField(entry, snake, camel) {
+  return entry[snake] !== void 0 ? entry[snake] : entry[camel];
+}
+function parseProductBadges(value) {
+  if (!Array.isArray(value)) return [];
+  const badges = [];
+  for (const raw of value) {
+    if (badges.length >= MAX_PRODUCT_BADGES) break;
+    if (!isRecord2(raw)) continue;
+    const rawLabel = raw.label;
+    if (typeof rawLabel !== "string") continue;
+    const label = rawLabel.trim().slice(0, MAX_PRODUCT_BADGE_LABEL_LENGTH);
+    if (label.length === 0) continue;
+    const rawIcon = raw.icon;
+    const icon = typeof rawIcon === "string" && PRODUCT_BADGE_ICON_NAMES.includes(rawIcon) ? rawIcon : null;
+    const backgroundColor = normalizeBadgeColor(
+      readField(raw, "background_color", "backgroundColor")
+    );
+    badges.push({
+      label,
+      icon,
+      backgroundColor,
+      foregroundColor: resolveBadgeForeground(backgroundColor),
+      showOnProductCard: readVisibility(readField(raw, "show_on_product_card", "showOnProductCard")),
+      showOnProductPage: readVisibility(readField(raw, "show_on_product_page", "showOnProductPage"))
+    });
+  }
+  return badges;
+}
+function badgesForCard(badges) {
+  return badges.filter((badge) => badge.showOnProductCard);
+}
+function badgesForProductPage(badges) {
+  return badges.filter((badge) => badge.showOnProductPage);
+}
+
+// src/video-embed.ts
+var ALLOWED_VIDEO_EMBED_HOSTS = /* @__PURE__ */ new Set([
+  "www.youtube-nocookie.com",
+  "www.youtube.com",
+  "player.vimeo.com",
+  "streamable.com"
+]);
+function isAllowedVideoEmbedSrc(src) {
+  if (!src.startsWith("https://")) return false;
+  const host = src.slice("https://".length).split("/")[0].split("?")[0].split("#")[0];
+  return ALLOWED_VIDEO_EMBED_HOSTS.has(host);
+}
+var YOUTUBE_VIDEO_ID = /^[\w-]{11}$/;
+var STREAMABLE_CODE = /^[a-zA-Z0-9]+$/;
+var VIMEO_ID = /^\d+$/;
+var VIMEO_HASH = /^[a-zA-Z0-9]+$/;
+function toUrl(input) {
+  try {
+    return input.startsWith("http://") || input.startsWith("https://") ? new URL(input) : new URL(`https://${input}`);
+  } catch {
+    return null;
+  }
+}
+function parseYouTubeVideoId(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  if (YOUTUBE_VIDEO_ID.test(trimmed)) return trimmed;
+  const url = toUrl(trimmed);
+  if (!url) return null;
+  const host = url.hostname.replace(/^www\./, "");
+  if (host === "youtu.be") {
+    const candidate = url.pathname.split("/").filter(Boolean)[0] ?? "";
+    return YOUTUBE_VIDEO_ID.test(candidate) ? candidate : null;
+  }
+  if (host !== "youtube.com" && host !== "m.youtube.com" && host !== "music.youtube.com") {
+    return null;
+  }
+  const watchId = url.searchParams.get("v");
+  if (watchId && YOUTUBE_VIDEO_ID.test(watchId)) return watchId;
+  for (const pattern of [/^\/embed\/([\w-]{11})/, /^\/shorts\/([\w-]{11})/, /^\/live\/([\w-]{11})/]) {
+    const match = url.pathname.match(pattern);
+    if (match?.[1] && YOUTUBE_VIDEO_ID.test(match[1])) return match[1];
+  }
+  return null;
+}
+function parseStreamableCode(url) {
+  const segments = url.pathname.split("/").filter(Boolean);
+  const code = segments[0] === "e" ? segments[1] : segments[0];
+  return code && STREAMABLE_CODE.test(code) ? code : null;
+}
+function parseVimeo(url) {
+  const segments = url.pathname.split("/").filter(Boolean);
+  for (let index = segments.length - 1; index >= 0; index -= 1) {
+    const segment = segments[index];
+    if (!VIMEO_ID.test(segment)) continue;
+    const queryHash = url.searchParams.get("h")?.trim();
+    const pathHash = segments[index + 1];
+    const hash = queryHash && VIMEO_HASH.test(queryHash) ? queryHash : pathHash && VIMEO_HASH.test(pathHash) ? pathHash : void 0;
+    return hash ? { id: segment, hash } : { id: segment };
+  }
+  return null;
+}
+function resolveProductVideoEmbedSrc(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const url = toUrl(trimmed);
+  let src = null;
+  if (url) {
+    const host = url.hostname.replace(/^www\./, "");
+    if (host === "streamable.com") {
+      const code = parseStreamableCode(url);
+      src = code ? `https://streamable.com/e/${code}` : null;
+    } else if (host === "vimeo.com" || host === "player.vimeo.com") {
+      const parsed = parseVimeo(url);
+      src = parsed ? parsed.hash ? `https://player.vimeo.com/video/${parsed.id}?h=${parsed.hash}` : `https://player.vimeo.com/video/${parsed.id}` : null;
+    }
+  }
+  if (src === null) {
+    const youtubeId = parseYouTubeVideoId(trimmed);
+    src = youtubeId ? `https://www.youtube-nocookie.com/embed/${youtubeId}` : null;
+  }
+  return src !== null && isAllowedVideoEmbedSrc(src) ? src : null;
+}
+
+// src/storefront-data.ts
+var PRODUCT_TYPES = ["PRODUCT", "SUBSCRIPTION", "INFO_CARD", "SERIALS", "PHYSICAL"];
+function resolveDeliveryPromise(product) {
+  if (product.productType === "PHYSICAL") return { kind: "shipped" };
+  if (product.deliveryTimeCount !== null) {
+    return { kind: "timed", count: product.deliveryTimeCount, unit: product.deliveryTimeUnit };
+  }
+  return { kind: "instant" };
+}
+var SUBSCRIPTION_INTERVAL_UNITS = ["DAY", "WEEK", "MONTH", "YEAR"];
+var SUBSCRIPTION_INTERVAL_NOUNS = {
+  DAY: "day",
+  WEEK: "week",
+  MONTH: "month",
+  YEAR: "year"
+};
+function formatSubscriptionCadence(subscription) {
+  const unit = subscription.intervalUnit;
+  if (unit === null) return "";
+  const noun = SUBSCRIPTION_INTERVAL_NOUNS[unit];
+  return subscription.intervalCount === 1 ? `per ${noun}` : `every ${subscription.intervalCount} ${noun}s`;
+}
+function formatSubscriptionTrial(subscription) {
+  const days = subscription.trialDays;
+  return days > 0 ? `${days}-day free trial` : "";
+}
+function parseSubscription(product, productType) {
+  if (productType !== "SUBSCRIPTION") return null;
+  const rawUnit = typeof product.recurring_interval === "string" ? product.recurring_interval.toUpperCase() : "";
+  const unit = SUBSCRIPTION_INTERVAL_UNITS.find((entry) => entry === rawUnit) ?? null;
+  const count = normalizePositiveDays(product.recurring_interval_count) ?? 1;
+  return {
+    intervalUnit: unit,
+    intervalCount: count,
+    trialDays: normalizePositiveDays(product.trial_period) ?? 0
+  };
+}
+function hasInjectedStorefrontData() {
+  return window.__SHOPPEX_INITIAL__ !== void 0;
+}
+function getAuthoredContent() {
+  return window.__SHOPPEX_INITIAL__?.store?.builder_settings?.theme?.content;
+}
+function getProducts() {
+  const initialData = window.__SHOPPEX_INITIAL__;
+  if (initialData === void 0 || initialData.products === void 0) {
+    return [];
+  }
+  if (!Array.isArray(initialData.products)) {
+    throw new Error("Invalid Shoppex initial data: products must be an array.");
+  }
+  return initialData.products.map(parseProduct);
+}
+function getProductGroups() {
+  const groups = window.__SHOPPEX_INITIAL__?.groups;
+  if (groups === void 0) return [];
+  if (!Array.isArray(groups)) {
+    throw new Error("Invalid Shoppex initial data: groups must be an array.");
+  }
+  return groups.map((value, index) => {
+    const context = `group at index ${index}`;
+    const group = requireUnknownRecord(value, context);
+    const productIds = Array.isArray(group.product_uniqids) ? group.product_uniqids.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+    return {
+      id: requireString(group, "uniqid", context),
+      title: requireString(group, "title", context),
+      description: optionalString(group.description),
+      imageUrl: firstOptionalString(group, ["cdn_image_url", "image_url"]),
+      categoryId: optionalString(group.category_id),
+      productIds,
+      productsCount: normalizeOptionalNonNegativeNumber(group.products_count) ?? productIds.length,
+      sortPriority: normalizeOptionalNonNegativeNumber(group.sort_priority) ?? 0
+    };
+  });
+}
+function getStorefrontCategories() {
+  const categories = window.__SHOPPEX_INITIAL__?.categories;
+  if (categories === void 0) return [];
+  if (!Array.isArray(categories)) {
+    throw new Error("Invalid Shoppex initial data: categories must be an array.");
+  }
+  return categories.map((value, index) => {
+    const context = `category at index ${index}`;
+    const category = requireUnknownRecord(value, context);
+    const id = requireString(category, "uniqid", context);
+    return {
+      id,
+      slug: optionalString(category.slug) ?? id,
+      title: requireString(category, "title", context),
+      // Same pair of keys the group records use — `transformStorefrontCategory`
+      // emits the CDN URL, and the older spelling is what a cached payload has.
+      imageUrl: firstOptionalString(category, ["cdn_image_url", "image_url"]),
+      productsCount: normalizeOptionalNonNegativeNumber(category.products_count) ?? 0,
+      groupsCount: normalizeOptionalNonNegativeNumber(category.groups_count) ?? 0
+    };
+  });
+}
+function getStorefrontListing() {
+  const items = window.__SHOPPEX_INITIAL__?.items;
+  if (items === void 0) return [];
+  if (!Array.isArray(items)) {
+    throw new Error("Invalid Shoppex initial data: items must be an array.");
+  }
+  return items.map((value, index) => {
+    const context = `listing item at index ${index}`;
+    const item = requireUnknownRecord(value, context);
+    return {
+      type: item.item_type === "GROUP" ? "group" : "product",
+      id: requireString(item, "uniqid", context),
+      sortPriority: normalizeOptionalNonNegativeNumber(item.sort_priority) ?? index
+    };
+  });
+}
+var SOCIAL_NETWORKS = [
+  "discord",
+  "telegram",
+  "youtube",
+  "twitter",
+  "instagram",
+  "tiktok",
+  "facebook",
+  "reddit",
+  "email"
+];
+function getStorefrontShop(productCount) {
+  const store = window.__SHOPPEX_INITIAL__?.store;
+  if (!store) {
+    throw new Error("Invalid Shoppex initial data: store is required.");
+  }
+  const social = isRecord(store.social) ? store.social : {};
+  const feedback = isRecord(store.feedback) ? store.feedback : {};
+  const ratingRaw = Number(store.average_score ?? store.rating);
+  const rating = Number.isFinite(ratingRaw) && ratingRaw > 0 ? ratingRaw : null;
+  const termsHtml = store.tos_enabled === true ? optionalString(store.terms_of_service) : null;
+  return {
+    name: requireString(store, "name", "store"),
+    logoUrl: firstOptionalString(store, ["logo", "avatar"]),
+    avatarUrl: firstOptionalString(store, ["avatar", "logo"]),
+    socialLinks: SOCIAL_NETWORKS.flatMap((network) => {
+      const value = optionalString(social[network]);
+      if (!value) return [];
+      const href = network === "email" && !value.includes(":") ? `mailto:${value}` : value;
+      return [{ network, href }];
+    }),
+    termsHtml,
+    hasPublishedTerms: termsHtml !== null,
+    rewardProgram: parseRewardProgram(store.reward_program_summary),
+    resellerProgram: parseResellerProgram(store.reseller_program_summary),
+    stats: {
+      productsSold: normalizeOptionalNonNegativeNumber(store.products_sold_count) ?? 0,
+      customers: normalizeOptionalNonNegativeNumber(store.customers_count ?? store.buyers_count) ?? 0,
+      reviewCount: normalizeOptionalNonNegativeNumber(feedback.total) ?? 0,
+      averageRating: rating,
+      productCount
+    }
+  };
+}
+function parseRewardProgram(value) {
+  if (!isRecord(value) || value.enabled !== true) return null;
+  const headline = optionalString(value.headline);
+  if (!headline || !Array.isArray(value.items)) return null;
+  const items = [];
+  for (const entry of value.items) {
+    if (!isRecord(entry)) continue;
+    const triggerType = firstOptionalString(entry, ["trigger_type", "triggerType"]);
+    const actionType = firstOptionalString(entry, ["action_type", "actionType"]);
+    const label = optionalString(entry.label);
+    if (!triggerType || !actionType || !label) continue;
+    items.push({ triggerType, actionType, label });
+  }
+  return items.length > 0 ? { headline, items } : null;
+}
+var RESELLER_ENROLLMENT_MODES = ["OPEN", "APPLICATION"];
+function parseResellerProgram(value) {
+  if (!isRecord(value)) return null;
+  const mode = optionalString(value.enrollment_mode);
+  return mode !== null && RESELLER_ENROLLMENT_MODES.includes(mode) ? { enrollmentMode: mode } : null;
+}
+var CURRENCY_CODE = /^[A-Z]{3}$/;
+function parseCurrencyList(value, leading) {
+  const entries = Array.isArray(value) ? value : [];
+  const codes = [...leading, ...entries].map((entry) => typeof entry === "string" ? entry.trim().toUpperCase() : "").filter((entry) => CURRENCY_CODE.test(entry));
+  return [...new Set(codes)];
+}
+var STOREFRONT_SORT_KEYS = ["featured", "newest", "price-asc", "price-desc"];
+function parseStorefrontSortKey(value) {
+  const raw = optionalString(value);
+  if (!raw) return "featured";
+  if (STOREFRONT_SORT_KEYS.includes(raw)) return raw;
+  switch (raw.toUpperCase()) {
+    case "NEWEST":
+      return "newest";
+    case "PRICE":
+    case "PRICE_ASC":
+      return "price-asc";
+    case "PRICE_DESC":
+      return "price-desc";
+    default:
+      return "featured";
+  }
+}
+function getStorefrontSettings() {
+  const store = window.__SHOPPEX_INITIAL__?.store;
+  if (!store) {
+    throw new Error("Invalid Shoppex initial data: store is required.");
+  }
+  const activeCurrency = (optionalString(store.currency) ?? "").toUpperCase();
+  const defaultCurrency = (optionalString(store.default_currency) ?? activeCurrency).toUpperCase();
+  return {
+    availableCurrencies: parseCurrencyList(store.available_currencies, [
+      activeCurrency,
+      defaultCurrency
+    ]),
+    defaultCurrency,
+    activeCurrency,
+    availableGateways: (Array.isArray(store.available_gateways) ? store.available_gateways : []).filter((entry) => typeof entry === "string" && entry.trim() !== ""),
+    cartEnabled: optionalBoolean(store.cart_enabled, true, "store.cart_enabled"),
+    hideOutOfStock: optionalBoolean(store.hide_out_of_stock, false, "store.hide_out_of_stock"),
+    hideStockCounter: optionalBoolean(store.hide_stock_counter, false, "store.hide_stock_counter"),
+    searchEnabled: optionalBoolean(store.search_enabled, true, "store.search_enabled"),
+    sortEnabled: optionalBoolean(store.sort_enabled, true, "store.sort_enabled"),
+    // The three presentation switches, at the defaults their columns carry.
+    centerGroupTitles: optionalBoolean(
+      store.center_group_titles,
+      false,
+      "store.center_group_titles"
+    ),
+    descriptionSkipDefaultImage: optionalBoolean(
+      store.description_skip_default_image,
+      false,
+      "store.description_skip_default_image"
+    ),
+    descriptionImage: optionalBoolean(store.description_image, true, "store.description_image"),
+    defaultSort: parseStorefrontSortKey(store.default_sort),
+    // Both contact switches are MERCHANT settings the serializer always emits.
+    // Defaulting them meant a shop that had turned the form off still showed
+    // one, and a shop that required an invoice number never asked for it — the
+    // visitor only found out from the backend's refusal. A payload without them
+    // is broken, so it fails here instead.
+    contactFormEnabled: requireBoolean(store.contact_form_enabled, "store.contact_form_enabled"),
+    requireInvoiceForContact: requireBoolean(
+      store.require_invoice_for_contact,
+      "store.require_invoice_for_contact"
+    )
+  };
+}
+function getStorefrontAddons() {
+  const addons = window.__SHOPPEX_INITIAL__?.addons;
+  if (addons === void 0) return [];
+  if (!isRecord(addons) || !Array.isArray(addons.items)) {
+    throw new Error("Invalid Shoppex initial data: addons.items must be an array.");
+  }
+  return [...addons.items].sort((a, b) => a.sort_order - b.sort_order);
+}
+function resolveDisplayStock(product) {
+  if (product.productType === "SERIALS" || product.priceVariants.length === 0) {
+    return product.stock;
+  }
+  if (product.priceVariants.some((variant) => variant.stock === null)) return null;
+  return product.priceVariants.reduce((total, variant) => total + Math.max(variant.stock ?? 0, 0), 0);
+}
+function isProductSoldOut(product) {
+  return resolveDisplayStock(product) === 0;
+}
+function resolveVariantStock(product, variant) {
+  const useProductStock = product.priceVariants.length > 0 && (product.stock ?? 0) !== 0 && product.priceVariants.every((entry) => (entry.stock ?? 0) === 0);
+  if (useProductStock || variant.stock === null) return product.stock;
+  return variant.stock;
+}
+function isSelectionSoldOut(product, variant) {
+  if (variant === null) {
+    if (isProductSoldOut(product)) return true;
+    if (product.priceVariants.length > 0) return false;
+  } else if (resolveVariantStock(product, variant) === 0) {
+    return true;
+  }
+  const { min, max } = resolveQuantityBounds(product, variant);
+  return max !== null && min > max;
+}
+function resolveHideStockCounter(product, settings) {
+  return product.hideStockCounter ?? settings.hideStockCounter;
+}
+function resolveQuantityBounds(product, variant) {
+  const min = variant?.quantityMin ?? product.quantityMin;
+  const configuredMax = variant?.quantityMax ?? product.quantityMax;
+  const stockMax = variant === null ? resolveDisplayStock(product) : resolveVariantStock(product, variant);
+  const max = configuredMax === null ? stockMax : stockMax === null ? configuredMax : Math.min(configuredMax, stockMax);
+  return { min, max };
+}
+function parseProduct(value, index) {
+  const context = `product at index ${index}`;
+  const product = requireUnknownRecord(value, context);
+  const id = requireString(product, "uniqid", context);
+  const productId = optionalString(product.id) ?? id;
+  const discountPercent = product.pay_what_you_want === true ? 0 : normalizeDiscountPercent(product.price_discount);
+  const applyDiscount = (amount) => discountPercent > 0 ? roundCurrency(amount * (1 - discountPercent / 100)) : amount;
+  const rawVariants = parsePriceVariants(product.price_variants, context);
+  const priceVariants = rawVariants.map((variant) => ({
+    ...variant,
+    baseUnitPrice: variant.price,
+    price: applyDiscount(variant.price)
+  }));
+  const basePrice = parseFiniteNumber(product.price_display ?? product.price, `${context}.price`);
+  const undiscountedPrice = rawVariants.length ? Math.min(...rawVariants.map((variant) => variant.price)) : basePrice;
+  const price = applyDiscount(undiscountedPrice);
+  const quantityMin = normalizeMinimum(product.quantity_min, 1, `${context}.quantity_min`);
+  const rating = deriveProductRating(product.feedback);
+  const productType = parseProductType(product.type);
+  return {
+    id,
+    productId,
+    productType,
+    name: requireString(product, "title", context),
+    price,
+    currency: requireString(product, "currency", context),
+    description: optionalString(product.description),
+    slug: optionalString(product.slug),
+    imageUrl: resolveProductImage(product),
+    imageUrls: parseProductImageUrls(product.images),
+    stock: applyOrderable(
+      normalizeStock(product.stock, `${context}.stock`),
+      product.orderable,
+      product.supplier_backed
+    ),
+    lowStockThreshold: normalizeLowStockThreshold(
+      normalizeOptionalNonNegativeNumber(product.quantity_warning)
+    ),
+    hideStockCounter: typeof product.hide_stock_counter === "boolean" ? product.hide_stock_counter : null,
+    volumeDiscounts: parseVolumeDiscounts(product.volume_discounts),
+    payWhatYouWant: product.pay_what_you_want === true,
+    discountPercent,
+    baseUnitPrice: undiscountedPrice,
+    basePrice,
+    priceVariants,
+    quantityMin,
+    quantityMax: normalizeMaximum(product.quantity_max, quantityMin, `${context}.quantity_max`),
+    soldCount: normalizeOptionalNonNegativeNumber(product.sold_count) ?? 0,
+    bestseller: product.bestseller === true,
+    badges: parseProductBadges(product.badges),
+    sortPriority: normalizeOptionalNonNegativeNumber(product.sort_priority) ?? 0,
+    createdAt: optionalString(product.created_at),
+    categories: parseCategories(product.categories),
+    bundles: parseBundles(product.bundles),
+    automaticDeals: parseAutomaticDeals(product.automatic_deals),
+    videoEmbedSrc: resolveProductVideoEmbedSrc(product.video_link),
+    addons: parseAddons(product.addons),
+    customFields: parseCustomFields(product.custom_fields, context),
+    // Strict on purpose: the serializer always emits `on_hold`, so an absent
+    // flag is the only tolerated shape (false) and a present non-boolean is a
+    // changed contract, not a paused product. Guessing here sells a product the
+    // merchant paused.
+    onHold: optionalBoolean(product.on_hold, false, `${context}.on_hold`),
+    compareAtPrice: price < undiscountedPrice ? undiscountedPrice : null,
+    rating: rating?.average ?? null,
+    ratingCount: rating?.count ?? 0,
+    ratingTally: rating?.tally ?? null,
+    highlights: parseHighlights(product.product_highlights),
+    metadata: parseMetadata(product.metadata),
+    descriptionTabs: parseContentTabs(product.description_tabs),
+    faqs: parseFaqs(product.faqs),
+    license: parseProductLicense(product),
+    licensingEnabled: product.licensing_enabled === true || product.licensing_enabled === 1,
+    deliveryTimeCount: normalizePositiveDays(product.delivery_time),
+    deliveryTimeUnit: normalizeDeliveryTimeUnit(product.delivery_time_unit),
+    subscription: parseSubscription(product, productType)
+  };
+}
+function readLicensePeriodDays(value) {
+  if (typeof value !== "number" && typeof value !== "string") return null;
+  const days = Number(value);
+  return Number.isInteger(days) && days > 0 ? days : null;
+}
+function readLicenseMode(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim().toUpperCase() : null;
+}
+function licenseStatementFromMode(mode, record) {
+  if (mode === "LIFETIME") return { kind: "lifetime" };
+  if (mode !== "PERIOD") return { kind: "unresolved" };
+  const days = readLicensePeriodDays(record.license_period_days);
+  return days === null ? { kind: "unresolved" } : { kind: "period", days };
+}
+function parseProductLicense(record) {
+  const mode = readLicenseMode(record.license_mode);
+  if (mode !== null) return licenseStatementFromMode(mode, record);
+  const legacy = record.license_period;
+  if (typeof legacy === "string" && legacy.trim().toUpperCase() === "LIFETIME") return { kind: "lifetime" };
+  if (legacy === 0 || typeof legacy === "string" && legacy.trim() === "0") return { kind: "lifetime" };
+  const days = readLicensePeriodDays(legacy);
+  return days === null ? { kind: "unresolved" } : { kind: "period", days };
+}
+function parseVariantLicense(record) {
+  const mode = readLicenseMode(record.license_mode);
+  if (mode === "INHERIT") return { kind: "inherit" };
+  if (mode !== null) return licenseStatementFromMode(mode, record);
+  const legacy = record.license_period;
+  if (legacy === null || legacy === void 0) return { kind: "inherit" };
+  if (legacy === 0 || typeof legacy === "string" && legacy.trim() === "0") return { kind: "lifetime" };
+  const days = readLicensePeriodDays(legacy);
+  return days === null ? { kind: "unresolved" } : { kind: "period", days };
+}
+function resolveLicenseTerm(product, variant) {
+  if (!product.licensingEnabled) return null;
+  const stated = variant ? variant.license : { kind: "inherit" };
+  if (stated.kind === "lifetime" || stated.kind === "period") return stated;
+  if (stated.kind === "unresolved") return null;
+  const inherited = product.license;
+  return inherited.kind === "lifetime" || inherited.kind === "period" ? inherited : null;
+}
+function formatLicenseTerm(term) {
+  return term.kind === "lifetime" ? "Lifetime" : `${term.days} ${term.days === 1 ? "day" : "days"}`;
+}
+function parsePriceVariants(value, productContext) {
+  if (value === null || value === void 0) return [];
+  const source = Array.isArray(value) ? value : isRecord(value) && Array.isArray(value.price_variants) ? value.price_variants : null;
+  if (!source) {
+    throw new Error(`Invalid Shoppex ${productContext}.price_variants: expected an array.`);
+  }
+  return source.map((entry, index) => {
+    const context = `${productContext}.price_variants.${index}`;
+    const variant = requireUnknownRecord(entry, context);
+    const quantityMin = normalizeOptionalMinimum(variant.quantity_min, context);
+    const unitPrice = parseFiniteNumber(
+      variant.price_display ?? variant.price,
+      `${context}.price`
+    );
+    return {
+      id: requireString(variant, "id", context),
+      label: requireStringFromKeys(variant, ["label", "title"], context),
+      license: parseVariantLicense(variant),
+      price: unitPrice,
+      baseUnitPrice: unitPrice,
+      stock: applyOrderable(
+        normalizeStock(variant.stock, `${context}.stock`),
+        variant.orderable,
+        variant.supplier_backed
+      ),
+      quantityMin,
+      quantityMax: normalizeMaximum(variant.quantity_max, quantityMin ?? 1, `${context}.quantity_max`),
+      imageUrl: optionalString(variant.image_url),
+      isFeatured: variant.is_featured === true || variant.isFeatured === true
+    };
+  });
+}
+function parseCategories(value) {
+  if (!Array.isArray(value)) return [];
+  const categories = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) continue;
+    const id = optionalString(entry.uniqid ?? entry.id);
+    const title = optionalString(entry.title);
+    if (!id || !title || categories.some((category) => category.id === id)) continue;
+    categories.push({ id, title });
+  }
+  return categories;
+}
+function parseProductType(value) {
+  const normalized = typeof value === "string" ? value.trim().toUpperCase() : "";
+  return PRODUCT_TYPES.includes(normalized) ? normalized : "PRODUCT";
+}
+function parseBundles(value) {
+  if (!Array.isArray(value)) return [];
+  const bundles = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) continue;
+    const rawItems = Array.isArray(entry.products) ? entry.products : [];
+    const items = [];
+    for (const rawItem of rawItems) {
+      if (!isRecord(rawItem)) continue;
+      const id = typeof rawItem.uniqid === "string" ? rawItem.uniqid.trim() : "";
+      const title = typeof rawItem.title === "string" ? rawItem.title.trim() : "";
+      if (!id || !title) continue;
+      const unitPrice = Number(rawItem.unit_price);
+      items.push({
+        id,
+        title,
+        variantId: typeof rawItem.default_variant_id === "string" && rawItem.default_variant_id ? rawItem.default_variant_id : "default",
+        unitPrice: Number.isFinite(unitPrice) && unitPrice >= 0 ? unitPrice : 0,
+        imageUrl: optionalString(rawItem.image_url),
+        variantTitle: optionalString(rawItem.variant_title)
+      });
+    }
+    if (items.length < 2) continue;
+    const amount = Number(entry.discount_amount);
+    bundles.push({
+      id: typeof entry.uniqid === "string" && entry.uniqid ? entry.uniqid : String(entry.id ?? ""),
+      title: typeof entry.title === "string" && entry.title.trim() ? entry.title.trim() : "Bundle offer",
+      discountType: entry.discount_type === "FIXED" ? "FIXED" : "PERCENTAGE",
+      discountAmount: Number.isFinite(amount) && amount > 0 ? amount : 0,
+      items
+    });
+  }
+  return bundles;
+}
+function parseAddons(value) {
+  if (!Array.isArray(value)) return [];
+  const addons = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) continue;
+    const id = optionalString(entry.id);
+    const title = optionalString(entry.title ?? entry.name);
+    if (!id || !title || addons.some((addon) => addon.id === id)) continue;
+    const price = Number(entry.price);
+    addons.push({
+      id,
+      title,
+      price: Number.isFinite(price) && price > 0 ? price : 0,
+      required: entry.required === true
+    });
+  }
+  return addons;
+}
+function parseProductImageUrls(value) {
+  if (!Array.isArray(value)) return [];
+  const urls = [];
+  for (const entry of value) {
+    const url = typeof entry === "string" ? optionalString(entry) : isRecord(entry) ? optionalString(entry.url) : null;
+    if (url && !urls.includes(url)) urls.push(url);
+  }
+  return urls;
+}
+function parseMetadata(value) {
+  if (!isRecord(value)) return {};
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") result[key] = entry;
+  }
+  return result;
+}
+function parseHighlights(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map(
+    (entry) => typeof entry === "string" ? entry.trim() : isRecord(entry) ? optionalString(entry.text ?? entry.title ?? entry.label) : null
+  ).filter((entry) => Boolean(entry));
+}
+function parseContentTabs(value) {
+  if (!Array.isArray(value)) return [];
+  const tabs = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) continue;
+    const title = optionalString(entry.title);
+    const html = optionalString(entry.content ?? entry.html ?? entry.contentHtml);
+    if (title && html) tabs.push({ title, html });
+  }
+  return tabs;
+}
+function parseCustomFields(value, context) {
+  const source = readCustomFieldList(value, context);
+  const fields = [];
+  for (const entry of source) {
+    if (!isRecord(entry)) continue;
+    const name = optionalString(entry.name);
+    if (!name) continue;
+    const rawType = typeof entry.type === "string" ? entry.type.trim().toLowerCase() : "";
+    const type = rawType || "text";
+    if (type === "hidden") continue;
+    const defaultValue = firstOptionalString(entry, ["default_value", "default", "value"]);
+    fields.push({
+      name,
+      type,
+      // The dashboard has stored this flag as a boolean, a number and a string
+      // over time; the SDK accepts all three, and reading only one of them
+      // would turn a required field into an optional one — which is exactly the
+      // failure that lets a product reach checkout without its values.
+      required: entry.required === true || entry.required === 1 || entry.required === "1" || entry.required === "true",
+      defaultValue: defaultValue ?? "",
+      placeholder: typeof entry.placeholder === "string" ? entry.placeholder : "",
+      regex: optionalString(entry.regex)
+    });
+  }
+  return fields;
+}
+function readCustomFieldList(value, context) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === "string") {
+    const text = value.trim();
+    if (!text) return [];
+    try {
+      return readCustomFieldList(JSON.parse(text), context);
+    } catch {
+      throw new Error(`Invalid Shoppex ${context}.custom_fields: expected valid JSON.`);
+    }
+  }
+  if (isRecord(value)) {
+    const fields = value.custom_fields ?? value.customFields;
+    return Array.isArray(fields) ? fields : [];
+  }
+  return [];
+}
+function parseAutomaticDeals(value) {
+  if (!Array.isArray(value)) return [];
+  const deals = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) continue;
+    const requiredQuantity = Number(entry.required_quantity);
+    const discountedQuantity = Number(entry.discounted_quantity);
+    if (!Number.isInteger(requiredQuantity) || requiredQuantity < 1 || !Number.isInteger(discountedQuantity) || discountedQuantity < 1) {
+      continue;
+    }
+    const isFree = optionalString(entry.discount_type)?.toUpperCase() === "FREE";
+    const discountValue = Number(entry.discount_value);
+    if (!isFree && !(Number.isFinite(discountValue) && discountValue > 0)) continue;
+    const cap = Number(entry.max_applications_per_cart);
+    deals.push({
+      id: optionalString(entry.uniqid) ?? `deal-${deals.length}`,
+      title: optionalString(entry.title) ?? "",
+      requiredQuantity,
+      discountedQuantity,
+      discountType: isFree ? "FREE" : "PERCENTAGE",
+      discountValue: isFree ? 0 : discountValue,
+      maxApplicationsPerCart: Number.isInteger(cap) && cap > 0 ? cap : null,
+      endsAt: optionalString(entry.ends_at)
+    });
+  }
+  return deals;
+}
+function parseFaqs(value) {
+  if (!Array.isArray(value)) return [];
+  const faqs = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) continue;
+    const question = optionalString(entry.question);
+    const answer = optionalString(entry.answer);
+    if (question && answer) faqs.push({ question, answer });
+  }
+  return faqs;
+}
+function parseVolumeDiscounts(value) {
+  const source = Array.isArray(value) ? value : isRecord(value) && Array.isArray(value.volume_discounts) ? value.volume_discounts : [];
+  const rules = [];
+  for (const entry of source) {
+    if (!isRecord(entry)) continue;
+    const quantity = Number(entry.quantity ?? entry.min_quantity);
+    const amount = Number(entry.value ?? entry.discount ?? entry.amount);
+    const typeRaw = String(entry.type ?? entry.discount_type ?? "").toUpperCase();
+    const type = typeRaw.includes("PERCENT") ? "PERCENTAGE" : typeRaw.includes("FIX") || typeRaw.includes("AMOUNT") ? "FIXED" : null;
+    if (!Number.isFinite(quantity) || quantity < 1 || !Number.isFinite(amount) || amount <= 0 || !type) {
+      continue;
+    }
+    rules.push({ quantity: Math.floor(quantity), type, value: amount });
+  }
+  return rules.sort((a, b) => a.quantity - b.quantity);
+}
+function toCents(value) {
+  return Math.round(Number((value * 100).toPrecision(15)));
+}
+function roundCurrency(value) {
+  return toCents(value) / 100;
+}
+function calculateDisplayLineTotal(baseUnitPrice, quantity, discountPercent, rules) {
+  const subtotalCents = toCents(baseUnitPrice) * quantity;
+  const afterPercentCents = discountPercent > 0 ? subtotalCents * (1 - discountPercent / 100) : subtotalCents;
+  return applyVolumeDiscountCents(afterPercentCents, quantity, rules) / 100;
+}
+function applyVolumeDiscountCents(subtotalCents, quantity, rules) {
+  let matched = null;
+  for (const rule of rules) {
+    if (quantity >= rule.quantity) matched = rule;
+  }
+  if (!matched) return Math.max(0, Math.round(subtotalCents));
+  const discountCents = matched.type === "PERCENTAGE" ? subtotalCents * Math.min(Math.max(matched.value, 0), 100) / 100 : toCents(matched.value);
+  return Math.max(0, Math.round(subtotalCents - Math.min(discountCents, subtotalCents)));
+}
+function deriveProductRating(value) {
+  if (!isRecord(value)) return null;
+  const total = Number(value.total);
+  if (!Number.isFinite(total) || total <= 0) return null;
+  const positive = Number(value.positive) || 0;
+  const neutral = Number(value.neutral) || 0;
+  const negative = Number(value.negative) || 0;
+  const counted = positive + neutral + negative;
+  if (counted <= 0) return null;
+  const average = (positive * 5 + neutral * 3 + negative * 1) / counted;
+  return { average: Math.round(average * 10) / 10, count: counted, tally: { positive, neutral, negative } };
+}
+function resolveProductImage(product) {
+  const direct = firstOptionalString(product, [
+    "image_url",
+    "imageUrl",
+    "cdn_image_url",
+    "detail_image_url",
+    "thumbnail_url",
+    "thumbnailUrl"
+  ]);
+  if (direct) return direct;
+  if (!Array.isArray(product.images)) return null;
+  for (const image of product.images) {
+    if (!isRecord(image)) continue;
+    const url = optionalString(image.url);
+    if (url) return url;
+  }
+  return null;
+}
+function normalizeStock(value, context) {
+  if (value === null || value === void 0 || value === "") return null;
+  const stock = parseFiniteNumber(value, context);
+  return stock < 0 ? null : Math.floor(stock);
+}
+function applyOrderable(stock, orderable, supplierBacked) {
+  if (orderable !== true) return stock;
+  if (supplierBacked === true) return null;
+  return stock === 0 ? null : stock;
+}
+function normalizeOptionalNonNegativeNumber(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : null;
+}
+function normalizeMinimum(value, fallback, context) {
+  if (value === null || value === void 0 || value === "") return fallback;
+  const minimum = Math.floor(parseFiniteNumber(value, context));
+  if (minimum < 1) {
+    throw new Error(`Invalid Shoppex ${context}: expected a positive integer.`);
+  }
+  return minimum;
+}
+function normalizeOptionalMinimum(value, context) {
+  if (value === null || value === void 0 || value === "") return null;
+  return normalizeMinimum(value, 1, `${context}.quantity_min`);
+}
+function normalizeMaximum(value, minimum, context) {
+  if (value === null || value === void 0 || value === "") return null;
+  const maximum = Math.floor(parseFiniteNumber(value, context));
+  if (maximum < 0) return null;
+  if (maximum < minimum) {
+    throw new Error(`Invalid Shoppex ${context}: maximum cannot be below minimum.`);
+  }
+  return maximum;
+}
+function normalizeLowStockThreshold(value) {
+  return value !== null && value > 0 ? value : null;
+}
+function normalizeDiscountPercent(value) {
+  if (value === null || value === void 0 || value === "") return 0;
+  const percent = Number(value);
+  if (!Number.isFinite(percent) || percent <= 0) return 0;
+  return Math.min(percent, 100);
+}
+function normalizePositiveDays(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : null;
+}
+var DELIVERY_TIME_UNITS = ["minutes", "hours", "days"];
+function normalizeDeliveryTimeUnit(value) {
+  return DELIVERY_TIME_UNITS.includes(value) ? value : "days";
+}
+function formatDeliveryTime(count, unit) {
+  return `${count} ${count === 1 ? unit.slice(0, -1) : unit}`;
+}
+
+// src/checkout-fields.ts
+var NO_FIELDS = { resolved: true, groups: [], hasRequired: false };
+function resolveCheckoutFields(lines) {
+  if (lines.length === 0) return NO_FIELDS;
+  const products = getProducts();
+  const groups = [];
+  const unresolvedProductIds = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const productId = line.product_id;
+    if (seen.has(productId)) continue;
+    seen.add(productId);
+    const product = products.find((candidate) => candidate.id === productId);
+    if (product === void 0) {
+      unresolvedProductIds.push(productId);
+      continue;
+    }
+    if (product.customFields.length === 0) continue;
+    groups.push({ productId, productName: product.name, fields: product.customFields });
+  }
+  if (unresolvedProductIds.length > 0) return { resolved: false, unresolvedProductIds };
+  return {
+    resolved: true,
+    groups,
+    hasRequired: groups.some((group) => group.fields.some((field) => field.required))
+  };
+}
+function checkoutNeedsDetails(fields) {
+  return !fields.resolved || fields.hasRequired;
+}
+function buildInitialCheckoutFieldValues(groups, lines) {
+  const values = {};
+  for (const group of groups) {
+    const stored = lines.find((line) => line.product_id === group.productId)?.custom_fields ?? {};
+    const entries = {};
+    for (const field of group.fields) {
+      const value = stored[field.name];
+      entries[field.name] = typeof value === "string" && value !== "" ? value : field.defaultValue;
+    }
+    values[group.productId] = entries;
+  }
+  return values;
+}
+function isCheckboxValueChecked(value) {
+  const normalized = value?.trim().toLowerCase() ?? "";
+  return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
+}
+function validateCheckoutFieldValue(field, value) {
+  if (field.type === "checkbox") {
+    return field.required && !isCheckboxValueChecked(value) ? `${field.name} is required.` : null;
+  }
+  const normalized = value.trim();
+  if (field.required && !normalized) return `${field.name} is required.`;
+  if (field.regex && normalized) {
+    let pattern;
+    try {
+      pattern = new RegExp(field.regex);
+    } catch {
+      return null;
+    }
+    if (!pattern.test(normalized)) return `${field.name} has an invalid format.`;
+  }
+  return null;
+}
+function validateCheckoutFields(groups, values) {
+  const errors = {};
+  for (const group of groups) {
+    for (const field of group.fields) {
+      const message = validateCheckoutFieldValue(
+        field,
+        values[group.productId]?.[field.name] ?? ""
+      );
+      if (message) errors[checkoutFieldKey(group.productId, field.name)] = message;
+    }
+  }
+  return errors;
+}
+function checkoutFieldKey(productId, fieldName) {
+  return `${productId}.${fieldName}`;
+}
+function buildCustomFieldPayload(fields, values) {
+  const payload = {};
+  for (const field of fields) {
+    const raw = values?.[field.name] ?? field.defaultValue;
+    if (field.type === "checkbox") {
+      if (isCheckboxValueChecked(raw)) payload[field.name] = "true";
+      continue;
+    }
+    const normalized = raw.trim();
+    if (normalized) payload[field.name] = normalized;
+  }
+  return payload;
+}
+function missingRequiredCheckoutValues(groups, lines) {
+  const messages = [];
+  for (const group of groups) {
+    const required = group.fields.filter((field) => field.required);
+    if (required.length === 0) continue;
+    for (const line of lines) {
+      if (line.product_id !== group.productId) continue;
+      for (const field of required) {
+        const message = validateCheckoutFieldValue(field, line.custom_fields?.[field.name] ?? "");
+        if (message && !messages.includes(message)) messages.push(message);
+      }
+    }
+  }
+  return messages;
+}
+function checkoutFieldWriteRepriced(before, after) {
+  const shape = (lines) => lines.map((line) => `${line.product_id} ${line.variant_id} ${line.quantity}`).sort().join("");
+  return shape(before) !== shape(after);
+}
+
+// src/cart-quote-bounds.ts
+function readOptionalCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null;
+  return Math.floor(value);
+}
+function parseCartQuoteLines(raw) {
+  if (!Array.isArray(raw)) return [];
+  const parsed = [];
+  for (const entry of raw) {
+    const row = entry && typeof entry === "object" ? entry : {};
+    const productId = typeof row.product_id === "string" ? row.product_id : "";
+    if (!productId) continue;
+    parsed.push({
+      productId,
+      variantId: typeof row.variant_id === "string" && row.variant_id ? row.variant_id : "default",
+      quantity: typeof row.quantity === "number" && Number.isFinite(row.quantity) ? row.quantity : 0,
+      minQuantity: readOptionalCount(row.min_quantity),
+      maxQuantity: readOptionalCount(row.max_quantity),
+      // Fail closed on a malformed row: only an explicit `true` is sellable. A
+      // row this runtime could not read must not re-enable a refused line.
+      sellable: row.sellable === true
+    });
+  }
+  return parsed;
+}
+function matchesOption(line, quoted) {
+  const variantId = line.variant_id ? line.variant_id : "default";
+  return line.product_id === quoted.productId && variantId === quoted.variantId;
+}
+function matchesQuotedLine(line, quoted) {
+  if (!matchesOption(line, quoted)) return false;
+  const quantity = Number.isFinite(line.quantity) ? Math.floor(line.quantity) : null;
+  return quantity !== null && quantity === quoted.quantity;
+}
+function resolveCartBoundsHeals(lines, quoted) {
+  const heals = [];
+  for (const line of lines) {
+    const lineId = typeof line.line_id === "string" ? line.line_id : "";
+    if (!lineId) continue;
+    const match = quoted.find((entry) => matchesQuotedLine(line, entry));
+    if (!match) continue;
+    const nextMin = match.minQuantity !== null && match.minQuantity > 1 ? match.minQuantity : null;
+    const nextMax = match.maxQuantity;
+    const storedMin = readOptionalCount(line.min_quantity);
+    const storedMax = readOptionalCount(line.max_quantity);
+    const currentMin = storedMin !== null && storedMin > 1 ? storedMin : null;
+    if (currentMin === nextMin && storedMax === nextMax) continue;
+    heals.push({ lineId, minQuantity: nextMin, maxQuantity: nextMax });
+  }
+  return heals;
+}
+function resolveUnsellableLineIds(lines, quoted) {
+  const ids = [];
+  for (const line of lines) {
+    const lineId = typeof line.line_id === "string" ? line.line_id : "";
+    if (!lineId) continue;
+    const match = quoted.find((entry) => matchesOption(line, entry));
+    if (match && !match.sellable) ids.push(lineId);
+  }
+  return ids;
+}
+
+// src/checkout-error-state.ts
+var QUOTE_UNAVAILABLE_CHECKOUT_ERROR = "Cart pricing is unavailable, so this order cannot be priced yet. Try again in a moment.";
+function clearRecoveredQuoteCheckoutError(error) {
+  return error === QUOTE_UNAVAILABLE_CHECKOUT_ERROR ? null : error;
+}
+
+// src/sanitize-html.ts
+import DOMPurify from "dompurify";
+var HEX_COLOR = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var TEXT_ALIGN = /^(left|right|center|justify)$/;
+var CDN_IMAGE_SRC = /^https:\/\/imagedelivery\.net\/[^/]+\/[^/]+\/[^/?#]+(?:\?.*)?$/i;
+function filterStyle(style) {
+  const allowed = [];
+  for (const declaration of style.split(";")) {
+    const [rawProperty, rawValue] = declaration.split(":");
+    if (!rawProperty || !rawValue) continue;
+    const property = rawProperty.trim().toLowerCase();
+    const value = rawValue.trim();
+    if ((property === "color" || property === "background-color") && HEX_COLOR.test(value)) {
+      allowed.push(`${property}: ${value}`);
+      continue;
+    }
+    if (property === "text-align" && TEXT_ALIGN.test(value.toLowerCase())) {
+      allowed.push(`${property}: ${value.toLowerCase()}`);
+    }
+  }
+  return allowed.join("; ");
+}
+var ALLOWED_TAGS = [
+  "h1",
+  "h2",
+  "h3",
+  "p",
+  "br",
+  "hr",
+  "ul",
+  "ol",
+  "li",
+  "details",
+  "summary",
+  "strong",
+  "em",
+  "u",
+  "s",
+  "del",
+  "code",
+  "pre",
+  "blockquote",
+  "a",
+  "mark",
+  "span",
+  "img",
+  "table",
+  "thead",
+  "tbody",
+  "tr",
+  "th",
+  "td"
+];
+var ALLOWED_ATTR = [
+  "href",
+  "target",
+  "rel",
+  "class",
+  "style",
+  "data-color",
+  "data-type",
+  "colspan",
+  "rowspan",
+  "src",
+  "alt",
+  "title",
+  "width",
+  "height",
+  "loading",
+  "open"
+];
+function sanitizeMerchantHtml(value) {
+  if (typeof value !== "string" || !value) return "";
+  const hook = (node, data) => {
+    if (data.attrName === "data-color") {
+      if (typeof data.attrValue !== "string" || !HEX_COLOR.test(data.attrValue)) {
+        data.keepAttr = false;
+      }
+      return;
+    }
+    if (data.attrName === "src") {
+      const isImage = typeof node === "object" && node !== null && "tagName" in node && String(node.tagName).toUpperCase() === "IMG";
+      if (isImage && (typeof data.attrValue !== "string" || !CDN_IMAGE_SRC.test(data.attrValue))) {
+        data.keepAttr = false;
+      }
+      return;
+    }
+    if (data.attrName !== "style" || typeof data.attrValue !== "string") return;
+    const filtered = filterStyle(data.attrValue);
+    if (!filtered) {
+      data.keepAttr = false;
+      return;
+    }
+    data.attrValue = filtered;
+  };
+  DOMPurify.addHook("uponSanitizeAttribute", hook);
+  try {
+    return DOMPurify.sanitize(value, { ALLOWED_TAGS, ALLOWED_ATTR });
+  } finally {
+    DOMPurify.removeHook("uponSanitizeAttribute", hook);
+  }
+}
+var BLOCK_BOUNDARY_SELECTOR = "address,article,aside,blockquote,br,dd,div,dl,dt,figcaption,figure,footer,h1,h2,h3,h4,h5,h6,header,hr,li,main,nav,ol,p,pre,section,table,tbody,td,tfoot,th,thead,tr,ul";
+function flattenMerchantHtmlToText(value) {
+  const sanitized = sanitizeMerchantHtml(value);
+  if (!sanitized) return "";
+  const container = document.createElement("div");
+  container.innerHTML = sanitized;
+  for (const element of container.querySelectorAll(BLOCK_BOUNDARY_SELECTOR)) {
+    element.insertAdjacentText("beforebegin", " ");
+    element.insertAdjacentText("afterend", " ");
+  }
+  return (container.textContent ?? "").replace(/\s+/g, " ").trim();
+}
+function stripMerchantHtmlImages(html) {
+  return html.replace(/<img\b[^>]*>/gi, "").trim();
+}
+function isBlankMerchantHtml(html) {
+  if (!html) return true;
+  const container = document.createElement("div");
+  container.innerHTML = html;
+  return (container.textContent ?? "").trim().length === 0 && container.querySelector("img, hr, table") === null;
+}
+
+// src/catalog.ts
+function formatMoney(amount, currency) {
+  const code = currency && currency !== "AUTO" ? currency : "USD";
+  let format;
+  try {
+    format = new Intl.NumberFormat("en-US", { style: "currency", currency: code });
+  } catch {
+    const fixed = amount.toFixed(2);
+    return `${code} ${fixed.endsWith(".00") ? fixed.slice(0, -3) : fixed}`;
+  }
+  const decimals = format.resolvedOptions().maximumFractionDigits ?? 2;
+  if (decimals === 0 || !Number.isInteger(Number(amount.toFixed(decimals)))) return format.format(amount);
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: code,
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 0
+  }).format(Math.round(amount));
+}
+function formatCompactCount(value) {
+  if (value >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
+  if (value >= 1e3) return `${(value / 1e3).toFixed(value >= 1e4 ? 0 : 1)}k`;
+  return value.toLocaleString("en-US");
+}
+var DEFAULT_LOW_STOCK_THRESHOLD = 10;
+function resolveStockChip(stock, hideCounter, lowStockThreshold) {
+  if (stock === 0) return { tone: "sold_out", label: "Out of Stock" };
+  if (hideCounter || stock === null) return { tone: "in_stock", label: "In Stock" };
+  const threshold = lowStockThreshold ?? DEFAULT_LOW_STOCK_THRESHOLD;
+  return { tone: stock <= threshold ? "low_stock" : "in_stock", label: `${stock} In Stock` };
+}
+function resolveBadgeLabel(product) {
+  if (product.productType === "INFO_CARD") return "Info";
+  if (product.productType === "SUBSCRIPTION") return "Sub";
+  if (product.priceVariants.length > 1) return "Options";
+  return null;
+}
+function resolvePriceLabel(product) {
+  const variantPrices = product.priceVariants.map((variant) => variant.price);
+  const positive = variantPrices.filter((price) => price > 0);
+  const candidates = positive.length > 0 ? positive : variantPrices;
+  if (product.basePrice <= 0 && candidates.length >= 2) {
+    const min = Math.min(...candidates);
+    const max = Math.max(...candidates);
+    if (max > min) {
+      return `${formatMoney(min, product.currency)} - ${formatMoney(max, product.currency)}`;
+    }
+  }
+  return formatMoney(product.price, product.currency);
+}
+function buildProductCard(product, settings, sortPriority) {
+  const soldOut = isProductSoldOut(product);
+  const isInfoCard = product.productType === "INFO_CARD";
+  const stock = resolveDisplayStock(product);
+  const hideCounter = resolveHideStockCounter(product, settings);
+  return {
+    kind: "product",
+    key: product.id,
+    product,
+    href: `/product/${product.slug ?? product.id}`,
+    priceLabel: resolvePriceLabel(product),
+    badgeLabel: resolveBadgeLabel(product),
+    badges: badgesForCard(product.badges),
+    highlights: product.highlights.slice(0, 3),
+    // Flattened, not raw: the description is rich text and the card renders it
+    // as TEXT, so the merchant's own markup used to print as literal tags. See
+    // `flattenMerchantHtmlToText` for why plain `textContent` is not enough.
+    description: product.highlights.length > 0 ? null : flattenMerchantHtmlToText(product.description) || null,
+    rating: product.rating,
+    // A paused product's stock is beside the point — announcing "999 IN STOCK"
+    // over a card that cannot be bought states the opposite of what the action
+    // row says. Checked before stock for the same reason the document lane's
+    // `isProductOutOfStock` checks it first.
+    stockChip: isInfoCard || soldOut || product.onHold ? null : resolveStockChip(stock, hideCounter, product.lowStockThreshold),
+    soldOut,
+    onHold: product.onHold,
+    categoryIds: product.categories.map((category) => category.id),
+    sortPriority,
+    createdAt: product.createdAt,
+    price: product.price
+  };
+}
+function buildGroupCard(group, byId, sortPriority) {
+  const members = group.productIds.map((id) => byId.get(id)).filter((product) => product !== void 0);
+  const prices = members.map((product) => product.price);
+  const currency = members[0]?.currency ?? "USD";
+  const min = prices.length > 0 ? Math.min(...prices) : 0;
+  const max = prices.length > 0 ? Math.max(...prices) : 0;
+  const memberCount = Math.max(group.productsCount, members.length);
+  return {
+    kind: "group",
+    key: group.id,
+    group,
+    priceLabel: prices.length === 0 ? "" : min === max ? formatMoney(min, currency) : `${formatMoney(min, currency)} - ${formatMoney(max, currency)}`,
+    members,
+    memberCountLabel: `${memberCount} ${memberCount === 1 ? "product" : "products"}`,
+    categoryIds: [
+      .../* @__PURE__ */ new Set([
+        ...group.categoryId ? [group.categoryId] : [],
+        ...members.flatMap((product) => product.categories.map((category) => category.id))
+      ])
+    ],
+    sortPriority,
+    price: min
+  };
+}
+function findStorefrontProduct(catalog, slugOrId) {
+  return catalog.products.find((product) => product.slug === slugOrId) ?? catalog.products.find((product) => product.id === slugOrId) ?? null;
+}
+function buildStorefrontCatalog(settings) {
+  const products = getProducts();
+  const groups = getProductGroups();
+  const listing = getStorefrontListing();
+  const productsById = new Map(products.map((product) => [product.id, product]));
+  const groupsById = new Map(groups.map((group) => [group.id, group]));
+  const cards = listing.map((item, index) => {
+    if (item.type === "group") {
+      const group = groupsById.get(item.id);
+      return group ? buildGroupCard(group, productsById, item.sortPriority ?? index) : null;
+    }
+    const product = productsById.get(item.id);
+    if (!product) return null;
+    if (settings.hideOutOfStock && isProductSoldOut(product)) return null;
+    return buildProductCard(product, settings, item.sortPriority ?? index);
+  }).filter((card) => card !== null);
+  return {
+    cards,
+    categories: getStorefrontCategories(),
+    products,
+    listedProductCount: products.length
+  };
+}
+var CATALOG_SORTS = STOREFRONT_SORT_KEYS;
+var CATALOG_SORT_LABELS = {
+  featured: "Featured",
+  newest: "Newest",
+  "price-asc": "Price: Low to High",
+  "price-desc": "Price: High to Low"
+};
+function sortCatalogCards(cards, sort) {
+  if (sort === "featured") return cards;
+  const sorted = [...cards];
+  if (sort === "price-asc") return sorted.sort((a, b) => a.price - b.price);
+  if (sort === "price-desc") return sorted.sort((a, b) => b.price - a.price);
+  return sorted.sort((a, b) => {
+    const left = a.kind === "product" && a.createdAt ? Date.parse(a.createdAt) : Number.NaN;
+    const right = b.kind === "product" && b.createdAt ? Date.parse(b.createdAt) : Number.NaN;
+    if (Number.isNaN(left) && Number.isNaN(right)) return a.sortPriority - b.sortPriority;
+    if (Number.isNaN(left)) return 1;
+    if (Number.isNaN(right)) return -1;
+    return right - left;
+  });
+}
+function resolveCategorySelection(value, categories) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return null;
+  const match = categories.find((category) => category.id.toLowerCase() === normalized || category.slug.toLowerCase() === normalized || category.title.toLowerCase() === normalized);
+  return match?.id ?? null;
+}
+function filterCatalogCards(cards, categoryId) {
+  if (!categoryId) return cards;
+  return cards.filter((card) => card.categoryIds.includes(categoryId));
+}
+var CATALOG_PAGE_SIZE = 24;
+function paginateCatalogCards(cards, page) {
+  const products = cards.filter((card) => card.kind === "product");
+  const firstPage = [];
+  let productsOnFirstPage = 0;
+  for (const card of cards) {
+    if (card.kind === "group") {
+      firstPage.push(card);
+      continue;
+    }
+    if (productsOnFirstPage < CATALOG_PAGE_SIZE) {
+      firstPage.push(card);
+      productsOnFirstPage += 1;
+    }
+  }
+  const remaining = products.length - productsOnFirstPage;
+  const totalPages = remaining > 0 ? 1 + Math.ceil(remaining / CATALOG_PAGE_SIZE) : 1;
+  const resolved = Math.min(Math.max(page, 1), totalPages);
+  if (resolved === 1) return { cards: firstPage, page: 1, totalPages };
+  const offset = productsOnFirstPage + (resolved - 2) * CATALOG_PAGE_SIZE;
+  return {
+    cards: products.slice(offset, offset + CATALOG_PAGE_SIZE),
+    page: resolved,
+    totalPages
+  };
+}
+
+// src/product-detail.ts
+var RELATED_PRODUCT_LIMIT = 3;
+function resolveBuyBoxStock(stock, hideCounter, lowStockThreshold) {
+  if (stock === 0) return { tone: "sold_out", label: "Out of Stock", soldOut: true };
+  if (stock === null || hideCounter) return { tone: "in_stock", label: "Available", soldOut: false };
+  const threshold = lowStockThreshold ?? DEFAULT_LOW_STOCK_THRESHOLD;
+  if (stock <= threshold) return { tone: "low_stock", label: `Only ${stock} left`, soldOut: false };
+  return { tone: "in_stock", label: `${stock} in stock`, soldOut: false };
+}
+function buildVariants(product, settings) {
+  const hideCounter = resolveHideStockCounter(product, settings);
+  return product.priceVariants.map((variant) => {
+    const stock = resolveVariantStock(product, variant);
+    const { tone, label, soldOut } = isSelectionSoldOut(product, variant) ? { tone: "sold_out", label: "Out of Stock", soldOut: true } : resolveBuyBoxStock(stock, hideCounter, product.lowStockThreshold);
+    return {
+      variant,
+      price: variant.price,
+      compareAtPrice: variant.price < variant.baseUnitPrice ? variant.baseUnitPrice : null,
+      stockTone: tone,
+      stockLabel: label,
+      soldOut
+    };
+  });
+}
+function buildRating(product) {
+  if (product.rating === null || product.ratingTally === null || product.ratingCount === 0) return null;
+  const filled = Math.round(product.rating);
+  return {
+    stars: [1, 2, 3, 4, 5].map((slot) => slot <= filled),
+    count: product.ratingCount,
+    average: product.rating,
+    positive: product.ratingTally.positive,
+    neutral: product.ratingTally.neutral,
+    negative: product.ratingTally.negative
+  };
+}
+function buildRelated(cards, currentId) {
+  return cards.filter((card) => card.kind === "product" && card.key !== currentId).slice(0, RELATED_PRODUCT_LIMIT);
+}
+function buildProductDetail(product, settings, cards) {
+  const images = settings.descriptionSkipDefaultImage ? [] : product.imageUrls.length > 0 ? product.imageUrls : product.imageUrl ? [product.imageUrl] : [];
+  return {
+    product,
+    images,
+    rating: buildRating(product),
+    variants: buildVariants(product, settings),
+    addons: product.addons,
+    // A variant-less product can be unsellable for the same reason an option can — see
+    // `isSelectionSoldOut`, which folds the empty-range case into the product-level read.
+    soldOut: isSelectionSoldOut(product, null),
+    related: buildRelated(cards, product.id)
+  };
+}
+function calculateLinePricing(product, variant, addons, quantity, payWhatYouWantPrice) {
+  const addonsTotal = addons.reduce((sum, addon) => sum + addon.price, 0);
+  if (payWhatYouWantPrice !== void 0) {
+    const effectiveUnitPrice = payWhatYouWantPrice + addonsTotal;
+    const total2 = roundCurrency(effectiveUnitPrice * quantity);
+    return {
+      total: total2,
+      originalSubtotal: total2,
+      effectiveUnitPrice,
+      discountAmount: 0,
+      hasDiscount: false
+    };
+  }
+  const unitPrice = (variant?.baseUnitPrice ?? product.baseUnitPrice) + addonsTotal;
+  const total = calculateDisplayLineTotal(
+    unitPrice,
+    quantity,
+    product.discountPercent,
+    product.volumeDiscounts
+  );
+  const originalSubtotal = calculateDisplayLineTotal(unitPrice, quantity, 0, []);
+  return {
+    total,
+    originalSubtotal,
+    effectiveUnitPrice: quantity > 0 ? total / quantity : total,
+    discountAmount: Math.max(0, originalSubtotal - total),
+    hasDiscount: total < originalSubtotal
+  };
+}
+function resolvePayWhatYouWantMinimum(product, variant) {
+  return variant?.baseUnitPrice ?? product.baseUnitPrice;
+}
+var MAX_PAY_WHAT_YOU_WANT_PRICE = 1e9;
+function clampQuantity(product, variant, quantity) {
+  const { min, max } = resolveQuantityBounds(product, variant);
+  if (!Number.isFinite(quantity)) return min;
+  const floored = Math.floor(quantity);
+  if (floored < min) return min;
+  return max !== null && floored > max ? max : floored;
+}
+
+// src/cart.tsx
+import { jsx } from "react/jsx-runtime";
+function readCheckoutNeedsDetails() {
+  return checkoutNeedsDetails(resolveCheckoutFields(getShoppex().getCart()));
+}
+var CartContext = createContext(null);
+var SELF_REFERRAL_REFUSAL_CODE = "errors.checkout.affiliate_code_not_applicable";
+var SELF_REFERRAL_MESSAGE = "This referral code cannot be used on your own order.";
+var CHECKOUT_REFUSAL_MESSAGES = {
+  "errors.checkout.shop_does_not_ship": "This shop does not ship physical products yet."
+};
+var QUOTE_PROOF_REFUSAL_MESSAGES = {
+  "errors.checkout.quote_token_invalid": "We could not verify the price you approved. The cart has been re-priced \u2014 review the total and check out again.",
+  "errors.checkout.quote_token_expired": "The price you approved has expired. Review the updated total, then check out again.",
+  "errors.checkout.quote_token_stale": "Your cart changed after the price was approved. Review the updated total, then check out again.",
+  "errors.checkout.price_increased_since_quote": "The price of your cart went up after you approved the total. Review the updated total, then check out again."
+};
+function resolveCartMaximumWarning(quote) {
+  if (quote.cart_max_exceeded !== true) return null;
+  const maximum = Number(quote.cart_maximum_checkout);
+  return Number.isFinite(maximum) && maximum > 0 ? `This cart is over the ${formatMoney(maximum, quote.currency)} checkout limit. Remove some items to continue.` : "This cart is over this shop\u2019s checkout limit. Remove some items to continue.";
+}
+function errorMessage(error, fallback) {
+  return error instanceof Error && error.message.trim() ? error.message : fallback;
+}
+function readAcceptedCouponSource(quote) {
+  if (quote.coupon_applied !== true) return null;
+  return quote.coupon_source === "COUPON" || quote.coupon_source === "AFFILIATE" ? quote.coupon_source : null;
+}
+function normalizeAmbientAffiliate(value) {
+  return value?.trim().toLowerCase() ?? "";
+}
+function resolveSubmittedCode(sdk) {
+  const code = sdk.getCartCoupon()?.trim() ?? "";
+  if (!code) return { coupon: "" };
+  const source = sdk.getCartCouponSource();
+  if (source === "COUPON") return { coupon: code };
+  if (source === "AFFILIATE") return { coupon: "", affiliateCode: code };
+  return null;
+}
+function cartLineIdentity(input) {
+  const addons = [...input.addons ?? []].map((addon) => ({ id: addon.id, quantity: addon.quantity ?? 1 })).sort((a, b) => a.id.localeCompare(b.id));
+  const customFields = Object.fromEntries(
+    Object.entries(input.custom_fields ?? {}).filter(([, value]) => typeof value === "string").sort(([a], [b]) => a.localeCompare(b))
+  );
+  const unitPrice = input.price_data?.unit_price;
+  const namedPrice = input.pay_what_you_want_price;
+  return JSON.stringify({
+    product_id: input.product_id,
+    variant_id: input.variant_id,
+    price_variant_id: input.price_variant_id ?? null,
+    addons,
+    custom_fields: customFields,
+    unit_price: typeof unitPrice === "number" && Number.isFinite(unitPrice) ? unitPrice : null,
+    pay_what_you_want_price: typeof namedPrice === "number" && Number.isFinite(namedPrice) ? namedPrice : null
+  });
+}
+function resolveBundleMember(item) {
+  const product = getProducts().find((candidate) => candidate.id === item.id);
+  if (product === void 0) return null;
+  if (item.variantId === "default") {
+    return { product, variant: null, bounds: resolveQuantityBounds(product, null) };
+  }
+  const variant = product.priceVariants.find((candidate) => candidate.id === item.variantId);
+  if (variant === void 0) return null;
+  return { product, variant, bounds: resolveQuantityBounds(product, variant) };
+}
+function clampToLineBounds(quantity, minimum, maximum) {
+  let clamped = Math.floor(quantity);
+  if (clamped < minimum) clamped = Math.floor(minimum);
+  if (maximum !== null && clamped > maximum) clamped = Math.floor(maximum);
+  return Math.max(1, clamped);
+}
+function unwrittenAdd(serializedBefore, identity, minimum, maximum, message) {
+  const lines = getShoppex().getCart();
+  if (JSON.stringify(lines) !== serializedBefore) return null;
+  if (maximum === null) return message;
+  const ceiling = clampToLineBounds(maximum, minimum, maximum);
+  return lines.some((line) => cartLineIdentity(line) === identity && line.quantity === ceiling) ? null : message;
+}
+function writeCheckoutFieldsToCart(values) {
+  const sdk = getShoppex();
+  const fields = resolveCheckoutFields(sdk.getCart());
+  if (!fields.resolved) {
+    return "Some products in your cart are no longer available. Please review your cart.";
+  }
+  if (fields.groups.length === 0) return null;
+  const payloads = new Map(fields.groups.map((group) => [
+    group.productId,
+    buildCustomFieldPayload(group.fields, values[group.productId])
+  ]));
+  const before = sdk.getCart();
+  for (const line of before) {
+    const payload = payloads.get(line.product_id);
+    if (payload === void 0) continue;
+    if (!sdk.getCart().some((entry) => entry.line_id === line.line_id)) continue;
+    sdk.updateCartItem(line.line_id, { custom_fields: payload });
+  }
+  const after = sdk.getCart();
+  const missing = missingRequiredCheckoutValues(fields.groups, after);
+  if (missing.length > 0) {
+    return `Your details could not be saved to the cart: ${missing.join(" ")}`;
+  }
+  return checkoutFieldWriteRepriced(before, after) ? "Two lines of the same item were combined once your details were saved. Review the updated total, then check out again." : null;
+}
+function snapshotLines(lines) {
+  return lines.map((line) => ({ lineId: line.line_id, quantity: line.quantity }));
+}
+function diffBundleMemberAdd(before, after) {
+  const created = after.find((line) => !before.some((entry) => entry.lineId === line.line_id));
+  if (created !== void 0) return { lineId: created.line_id, quantity: null };
+  for (const line of after) {
+    const previous = before.find((entry) => entry.lineId === line.line_id);
+    if (previous !== void 0 && line.quantity > previous.quantity) {
+      return { lineId: line.line_id, quantity: previous.quantity };
+    }
+  }
+  return null;
+}
+function CartProvider({ children }) {
+  const [lines, setLines] = useState([]);
+  const [count, setCount] = useState(0);
+  const [quote, setQuote] = useState(null);
+  const [quoteError, setQuoteError] = useState(null);
+  const [mutationError, setMutationError] = useState(null);
+  const [couponRejected, setCouponRejected] = useState(false);
+  const [quotedAmbientAffiliate, setQuotedAmbientAffiliate] = useState(false);
+  const [cartMaxWarning, setCartMaxWarning] = useState(null);
+  const [checkoutError, setCheckoutError] = useState(null);
+  const [selfReferralBlocked, setSelfReferralBlocked] = useState(false);
+  const quotedAffiliate = useRef(null);
+  const unsellableLines = useRef([]);
+  const cartMaximumWarning = useRef(null);
+  const [busyCount, setBusyCount] = useState(0);
+  const [couponInput, setCouponInput] = useState("");
+  const [drawerOpen, setDrawerOpen] = useState(false);
+  const couponPendingEdit = useRef(false);
+  const refreshVersion = useRef(0);
+  const refreshTimer = useRef(null);
+  const refreshResolvers = useRef([]);
+  const rememberQuotedAffiliate = useCallback((code) => {
+    quotedAffiliate.current = code;
+    setQuotedAmbientAffiliate(code !== null && code !== "");
+  }, []);
+  const rememberCartMaximum = useCallback((warning) => {
+    cartMaximumWarning.current = warning;
+    setCartMaxWarning(warning);
+  }, []);
+  const settleQuotedCart = useCallback((data, quotedAmbient, version, pricedCart) => {
+    const sdk = getShoppex();
+    if (JSON.stringify(sdk.getCart()) !== pricedCart) return "stale-cart";
+    if (version !== refreshVersion.current) return "superseded";
+    const quotedLines = parseCartQuoteLines(data.lines);
+    let unsellable = null;
+    let healClamped = false;
+    if (quotedLines.length > 0) {
+      const beforeHeal = sdk.getCart();
+      for (const heal of resolveCartBoundsHeals(beforeHeal, quotedLines)) {
+        sdk.updateCartItem(heal.lineId, {
+          min_quantity: heal.minQuantity,
+          max_quantity: heal.maxQuantity
+        });
+      }
+      const healedCart = sdk.getCart();
+      healClamped = healedCart.length !== beforeHeal.length || healedCart.some((line, index) => line.quantity !== beforeHeal[index]?.quantity);
+      unsellable = resolveUnsellableLineIds(healedCart, quotedLines);
+    }
+    if (healClamped) {
+      setLines(sdk.getCart());
+      setCount(sdk.getCartItemCount());
+      setQuote(null);
+      rememberQuotedAffiliate(null);
+      rememberCartMaximum(null);
+      unsellableLines.current = unsellable ?? [];
+      return "clamped";
+    }
+    setQuote(data);
+    setQuoteError(null);
+    setCheckoutError(clearRecoveredQuoteCheckoutError);
+    rememberQuotedAffiliate(quotedAmbient);
+    rememberCartMaximum(resolveCartMaximumWarning(data));
+    if (unsellable !== null) unsellableLines.current = unsellable;
+    if (quotedLines.length > 0) setLines(sdk.getCart());
+    return "settled";
+  }, [rememberCartMaximum, rememberQuotedAffiliate]);
+  const refreshNow = useCallback(async (retriesLeft = 1) => {
+    const sdk = getShoppex();
+    const version = ++refreshVersion.current;
+    const nextLines = sdk.getCart();
+    const nextCount = sdk.getCartItemCount();
+    const pricedCart = JSON.stringify(nextLines);
+    const coupon = sdk.getCartCoupon()?.trim() ?? "";
+    const ambientAffiliate = coupon ? "" : sdk.getAffiliateCode()?.trim() ?? "";
+    if (version === refreshVersion.current) {
+      setLines(nextLines);
+      setCount(nextCount);
+      if (!couponPendingEdit.current) setCouponInput(coupon);
+    }
+    if (nextLines.length === 0) {
+      if (version === refreshVersion.current) {
+        setQuote(null);
+        setQuoteError(null);
+        setCheckoutError(clearRecoveredQuoteCheckoutError);
+        rememberQuotedAffiliate(null);
+        rememberCartMaximum(null);
+        unsellableLines.current = [];
+      }
+      return;
+    }
+    try {
+      const result = await sdk.quoteCart(coupon || void 0, getBuyerCurrency());
+      if (version !== refreshVersion.current) return;
+      if (!result.success || !result.data) {
+        setQuote(null);
+        setQuoteError(result.message?.trim() || "Cart pricing is unavailable.");
+        rememberQuotedAffiliate(null);
+        rememberCartMaximum(null);
+        unsellableLines.current = [];
+        return;
+      }
+      if (settleQuotedCart(result.data, ambientAffiliate, version, pricedCart) === "clamped" && retriesLeft > 0) {
+        await refreshNow(retriesLeft - 1);
+      }
+    } catch (error) {
+      if (version !== refreshVersion.current) return;
+      setQuote(null);
+      setQuoteError(errorMessage(error, "Cart pricing is unavailable."));
+      rememberQuotedAffiliate(null);
+      rememberCartMaximum(null);
+      unsellableLines.current = [];
+    }
+  }, [rememberCartMaximum, rememberQuotedAffiliate, settleQuotedCart]);
+  const scheduleRefresh = useCallback(() => new Promise((resolve) => {
+    refreshResolvers.current.push(resolve);
+    if (refreshTimer.current !== null) {
+      window.clearTimeout(refreshTimer.current);
+    }
+    refreshTimer.current = window.setTimeout(() => {
+      refreshTimer.current = null;
+      const resolvers = refreshResolvers.current.splice(0);
+      void refreshNow().finally(() => {
+        resolvers.forEach((finish) => finish());
+      });
+    }, 60);
+  }), [refreshNow]);
+  useEffect(() => {
+    void refreshNow();
+    return () => {
+      if (refreshTimer.current !== null) window.clearTimeout(refreshTimer.current);
+      refreshResolvers.current.splice(0).forEach((resolve) => resolve());
+    };
+  }, [refreshNow]);
+  useEffect(() => {
+    const onExternalChange = () => {
+      void scheduleRefresh();
+    };
+    window.addEventListener("storage", onExternalChange);
+    window.addEventListener("shoppex:cart-changed", onExternalChange);
+    return () => {
+      window.removeEventListener("storage", onExternalChange);
+      window.removeEventListener("shoppex:cart-changed", onExternalChange);
+    };
+  }, [scheduleRefresh]);
+  const mutate = useCallback(async (mutation, verifyWrite) => {
+    setBusyCount((value2) => value2 + 1);
+    setCheckoutError(null);
+    setMutationError(null);
+    setCouponRejected(false);
+    try {
+      const serializedBefore = verifyWrite ? JSON.stringify(getShoppex().getCart()) : "";
+      mutation();
+      const unwritten = verifyWrite?.(serializedBefore) ?? null;
+      await scheduleRefresh();
+      if (unwritten) throw new Error(unwritten);
+    } catch (error) {
+      setMutationError(errorMessage(error, "The cart could not be updated."));
+      throw error;
+    } finally {
+      setBusyCount((value2) => Math.max(0, value2 - 1));
+    }
+  }, [scheduleRefresh]);
+  const add = useCallback(async (product, variant, quantity, options) => {
+    if (product.onHold) {
+      throw new Error(`${product.name} is not on sale yet.`);
+    }
+    if (isSelectionSoldOut(product, variant)) {
+      throw new Error(
+        `${variant === null ? product.name : `${product.name} (${variant.label})`} is out of stock.`
+      );
+    }
+    const { min: minimum, max: maximum } = resolveQuantityBounds(product, variant);
+    const addons = options?.addons ?? [];
+    const payWhatYouWantPrice = options?.payWhatYouWantPrice ?? (product.payWhatYouWant ? resolvePayWhatYouWantMinimum(product, variant) : void 0);
+    const addonsUnitPrice = addons.reduce((sum, addon) => sum + addon.price, 0);
+    const unitPriceSnapshot = payWhatYouWantPrice !== void 0 ? payWhatYouWantPrice + addonsUnitPrice : calculateLinePricing(product, variant, addons, quantity).effectiveUnitPrice;
+    const variantId = variant?.id ?? "default";
+    const addOptions = {
+      ...variant ? { price_variant_id: variant.id } : {},
+      price_data: { unit_price: unitPriceSnapshot },
+      ...payWhatYouWantPrice !== void 0 ? { pay_what_you_want_price: payWhatYouWantPrice } : {},
+      // Addon ids are part of the line's identity — the SDK hashes them into
+      // `line_id`, so a line added with extras never merges with a plain one.
+      ...addons.length > 0 ? {
+        addons: addons.map((addon) => ({ id: addon.id })),
+        addon_labels: addons.map((addon) => addon.title)
+      } : {},
+      title: product.name,
+      variant_title: variant?.label,
+      image_url: variant?.imageUrl ?? product.imageUrl ?? void 0,
+      max_quantity: maximum ?? void 0,
+      min_quantity: minimum > 1 ? minimum : void 0,
+      replace_display_snapshot: true
+    };
+    const identity = cartLineIdentity({ product_id: product.id, variant_id: variantId, ...addOptions });
+    await mutate(
+      () => getShoppex().addToCart(product.id, variantId, quantity, addOptions),
+      (serializedBefore) => unwrittenAdd(
+        serializedBefore,
+        identity,
+        minimum,
+        maximum,
+        "This product could not be added to your cart."
+      )
+    );
+  }, [mutate]);
+  const addBundleMember = useCallback(async (item) => {
+    const member = resolveBundleMember(item);
+    if (member === null || member.product.onHold || isSelectionSoldOut(member.product, member.variant)) {
+      throw new Error(`${item.title} is not available and was not added to your cart.`);
+    }
+    const { bounds } = member;
+    const payWhatYouWantPrice = member.product.payWhatYouWant ? resolvePayWhatYouWantMinimum(member.product, member.variant) : void 0;
+    const addOptions = {
+      ...item.variantId !== "default" ? { price_variant_id: item.variantId } : {},
+      // The offer states each member's unit price; a line without that
+      // snapshot shows no money in the cart until the quote answers. A named
+      // price overrides it, because that is the amount the backend charges.
+      ...payWhatYouWantPrice !== void 0 ? { price_data: { unit_price: payWhatYouWantPrice }, pay_what_you_want_price: payWhatYouWantPrice } : item.unitPrice > 0 ? { price_data: { unit_price: item.unitPrice } } : {},
+      title: item.title,
+      ...item.variantTitle ? { variant_title: item.variantTitle } : {},
+      ...item.imageUrl ? { image_url: item.imageUrl } : {},
+      // The member's OWN bounds, sent for the same reason the buy box sends
+      // them: this write is a full re-snapshot, so whatever it leaves out is
+      // CLEARED off the line it merges into.
+      max_quantity: bounds.max ?? void 0,
+      min_quantity: bounds.min > 1 ? bounds.min : void 0,
+      replace_display_snapshot: true
+    };
+    const identity = cartLineIdentity({
+      product_id: item.id,
+      variant_id: item.variantId,
+      ...addOptions
+    });
+    await mutate(
+      () => getShoppex().addToCart(item.id, item.variantId, 1, addOptions),
+      (serializedBefore) => unwrittenAdd(
+        serializedBefore,
+        identity,
+        bounds.min,
+        bounds.max,
+        "This item could not be added to your cart."
+      )
+    );
+  }, [mutate]);
+  const addBundle = useCallback(async (items) => {
+    const undo = [];
+    setBusyCount((value2) => value2 + 1);
+    setCheckoutError(null);
+    setMutationError(null);
+    try {
+      for (const item of items) {
+        const before = snapshotLines(getShoppex().getCart());
+        try {
+          await addBundleMember(item);
+        } catch (error) {
+          const partial = diffBundleMemberAdd(before, getShoppex().getCart());
+          if (partial !== null) undo.push(partial);
+          const message = "This bundle could not be added to your cart.";
+          setMutationError(message);
+          for (const entry of [...undo].reverse()) {
+            try {
+              if (entry.quantity === null) getShoppex().removeFromCart(entry.lineId);
+              else getShoppex().updateCartItem(entry.lineId, { quantity: entry.quantity });
+            } catch {
+            }
+          }
+          await scheduleRefresh();
+          throw error instanceof Error ? error : new Error(message);
+        }
+        const applied = diffBundleMemberAdd(before, getShoppex().getCart());
+        if (applied !== null) undo.push(applied);
+      }
+    } finally {
+      setBusyCount((value2) => Math.max(0, value2 - 1));
+    }
+  }, [addBundleMember, scheduleRefresh]);
+  const update = useCallback(
+    async (lineId, quantity) => mutate(() => getShoppex().updateCartItem(lineId, { quantity })),
+    [mutate]
+  );
+  const remove = useCallback(
+    async (lineId) => mutate(() => getShoppex().removeFromCart(lineId)),
+    [mutate]
+  );
+  const clear = useCallback(async () => mutate(() => getShoppex().clearCart()), [mutate]);
+  const editCouponInput = useCallback((value2) => {
+    couponPendingEdit.current = true;
+    setCouponInput(value2);
+  }, []);
+  const applyCoupon = useCallback(async () => {
+    const coupon = couponInput.trim();
+    couponPendingEdit.current = false;
+    if (!coupon) {
+      await mutate(() => getShoppex().clearCartCoupon());
+      return;
+    }
+    setBusyCount((value2) => value2 + 1);
+    setCheckoutError(null);
+    setMutationError(null);
+    setCouponRejected(false);
+    try {
+      const sdk = getShoppex();
+      const storedBefore = sdk.getCartCoupon();
+      let pricedCart = JSON.stringify(sdk.getCart());
+      let result = await sdk.quoteCart(coupon, getBuyerCurrency());
+      if (sdk.getCartCoupon() !== storedBefore) return;
+      if (JSON.stringify(sdk.getCart()) !== pricedCart) {
+        pricedCart = JSON.stringify(sdk.getCart());
+        result = await sdk.quoteCart(coupon, getBuyerCurrency());
+        if (sdk.getCartCoupon() !== storedBefore) return;
+        if (JSON.stringify(sdk.getCart()) !== pricedCart) {
+          couponPendingEdit.current = true;
+          await refreshNow();
+          return;
+        }
+      }
+      if (!result.success || !result.data) {
+        setQuote(null);
+        setQuoteError(result.message?.trim() || "Cart pricing is unavailable.");
+        rememberQuotedAffiliate(null);
+        rememberCartMaximum(null);
+        return;
+      }
+      const source = readAcceptedCouponSource(result.data);
+      if (source === null) {
+        sdk.clearCartCoupon();
+        setCouponInput("");
+        setCouponRejected(true);
+        await refreshNow();
+        return;
+      }
+      sdk.setCartCoupon(coupon, source);
+      refreshVersion.current += 1;
+      const settlement = settleQuotedCart(result.data, "", refreshVersion.current, pricedCart);
+      setCouponInput(sdk.getCartCoupon() ?? coupon);
+      if (settlement === "clamped") await refreshNow();
+    } catch (error) {
+      setQuote(null);
+      setQuoteError(errorMessage(error, "Cart pricing is unavailable."));
+      rememberQuotedAffiliate(null);
+      rememberCartMaximum(null);
+    } finally {
+      setBusyCount((value2) => Math.max(0, value2 - 1));
+    }
+  }, [couponInput, mutate, refreshNow, rememberCartMaximum, rememberQuotedAffiliate, settleQuotedCart]);
+  const removeCoupon = useCallback(async () => {
+    couponPendingEdit.current = false;
+    await mutate(() => getShoppex().clearCartCoupon());
+  }, [mutate]);
+  const clearBlockedReferral = useCallback(async () => {
+    const sdk = getShoppex();
+    sdk.clearAffiliateCode();
+    if (sdk.getCartCouponSource() === "AFFILIATE") {
+      sdk.clearCartCoupon();
+      couponPendingEdit.current = false;
+      setCouponInput("");
+    }
+    setSelfReferralBlocked(false);
+    setCheckoutError(null);
+    setCouponRejected(false);
+    await refreshNow();
+  }, [refreshNow]);
+  const checkout = useCallback(async (customFieldValues) => {
+    setBusyCount((value2) => value2 + 1);
+    setCheckoutError(null);
+    setSelfReferralBlocked(false);
+    try {
+      const sdk = getShoppex();
+      if (quotedAffiliate.current === null) {
+        setCheckoutError(QUOTE_UNAVAILABLE_CHECKOUT_ERROR);
+        return;
+      }
+      if (unsellableLines.current.length > 0) {
+        setCheckoutError(
+          "Some items in your cart are not available in the quantity requested. Reduce or remove them, then check out again."
+        );
+        return;
+      }
+      if (cartMaximumWarning.current !== null) {
+        setCheckoutError(cartMaximumWarning.current);
+        return;
+      }
+      if (customFieldValues !== void 0) {
+        const failure = writeCheckoutFieldsToCart(customFieldValues);
+        if (failure !== null) {
+          setCheckoutError(failure);
+          await scheduleRefresh();
+          return;
+        }
+      }
+      const submitted = resolveSubmittedCode(sdk);
+      if (submitted === null) {
+        setCheckoutError(
+          "Your discount code could not be verified. Remove it, or apply it again, to continue."
+        );
+        return;
+      }
+      const quotedAmbient = quotedAffiliate.current;
+      const isAmbientLane = submitted.coupon === "" && submitted.affiliateCode === void 0;
+      const ambientNow = normalizeAmbientAffiliate(sdk.getAffiliateCode());
+      if (isAmbientLane && ambientNow !== normalizeAmbientAffiliate(quotedAmbient)) {
+        setCheckoutError(
+          "The referral discount on this cart changed. Review the updated total, then check out again."
+        );
+        await scheduleRefresh();
+        return;
+      }
+      const pinnedAffiliateCode = submitted.affiliateCode ?? (isAmbientLane ? normalizeAmbientAffiliate(quotedAmbient) : ambientNow);
+      const result = await sdk.checkout({
+        ...submitted,
+        affiliateCode: pinnedAffiliateCode,
+        currency: getBuyerCurrency()
+      });
+      if (!result.success) {
+        if (result.code === SELF_REFERRAL_REFUSAL_CODE) {
+          setSelfReferralBlocked(true);
+          setCheckoutError(SELF_REFERRAL_MESSAGE);
+          return;
+        }
+        const quoteProofMessage = result.code ? QUOTE_PROOF_REFUSAL_MESSAGES[result.code] : void 0;
+        if (quoteProofMessage) {
+          setCheckoutError(quoteProofMessage);
+          await scheduleRefresh();
+          return;
+        }
+        const refusalMessage = result.code ? CHECKOUT_REFUSAL_MESSAGES[result.code] : void 0;
+        setCheckoutError(refusalMessage ?? (result.message?.trim() || "Checkout could not be started."));
+        return;
+      }
+      if (!result.redirectUrl) {
+        setCheckoutError("Checkout could not be started.");
+      }
+    } catch (error) {
+      setCheckoutError(errorMessage(error, "Checkout could not be started."));
+    } finally {
+      setBusyCount((value2) => Math.max(0, value2 - 1));
+    }
+  }, [scheduleRefresh]);
+  const checkoutFields = useMemo(() => resolveCheckoutFields(lines), [lines]);
+  const value = useMemo(() => ({
+    lines,
+    count,
+    quote,
+    quoteError,
+    mutationError,
+    couponRejected,
+    quotedAmbientAffiliate,
+    cartMaxWarning,
+    requiresShipping: quote?.requires_shipping === true,
+    checkoutError,
+    selfReferralBlocked,
+    clearBlockedReferral,
+    checkoutFields,
+    checkoutNeedsDetails: checkoutNeedsDetails(checkoutFields),
+    busy: busyCount > 0,
+    couponInput,
+    setCouponInput: editCouponInput,
+    drawerOpen,
+    setDrawerOpen,
+    add,
+    addBundle,
+    update,
+    remove,
+    clear,
+    applyCoupon,
+    removeCoupon,
+    checkout
+  }), [
+    add,
+    addBundle,
+    applyCoupon,
+    busyCount,
+    cartMaxWarning,
+    checkout,
+    checkoutError,
+    checkoutFields,
+    clear,
+    clearBlockedReferral,
+    count,
+    couponInput,
+    couponRejected,
+    drawerOpen,
+    editCouponInput,
+    lines,
+    mutationError,
+    quote,
+    quoteError,
+    quotedAmbientAffiliate,
+    remove,
+    removeCoupon,
+    selfReferralBlocked,
+    update
+  ]);
+  return /* @__PURE__ */ jsx(CartContext.Provider, { value, children });
+}
+function useCart() {
+  const context = useContext(CartContext);
+  if (!context) throw new Error("useCart must be used inside CartProvider.");
+  return context;
+}
+function startCartMutation(mutation) {
+  void mutation.catch(() => void 0);
+}
+
+// src/cart-view.ts
+function positiveInteger(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(1, Math.trunc(value)) : fallback;
+}
+function snapshotUnitPrice(line) {
+  const price = line.price_data?.unit_price;
+  return typeof price === "number" && Number.isFinite(price) ? Math.max(price, 0) : null;
+}
+function lineSubtitle(line) {
+  const parts = [];
+  const variantTitle = line.variant_title?.trim();
+  if (variantTitle) parts.push(variantTitle);
+  const addons = (line.addon_labels ?? []).map((label) => label.trim()).filter(Boolean);
+  if (addons.length > 0) parts.push(addons.join(", "));
+  return parts.join(" \xB7 ");
+}
+function buildCartView(lines) {
+  const rows = lines.map((line) => {
+    const quantity = positiveInteger(line.quantity, 1);
+    const unitPrice = snapshotUnitPrice(line);
+    const minimumQuantity = positiveInteger(line.min_quantity, 1);
+    const maximumQuantity = typeof line.max_quantity === "number" && Number.isFinite(line.max_quantity) ? Math.max(1, Math.trunc(line.max_quantity)) : Number.POSITIVE_INFINITY;
+    return {
+      lineId: line.line_id,
+      // A line without a display snapshot still has to name itself; the
+      // product id is the only truthful stand-in the cart holds.
+      title: line.title?.trim() || line.product_id,
+      subtitle: lineSubtitle(line),
+      imageUrl: line.image_url?.trim() || null,
+      quantity,
+      lineTotal: roundCurrency((unitPrice ?? 0) * quantity),
+      canDecrease: quantity > minimumQuantity,
+      canIncrease: quantity < maximumQuantity,
+      minimumQuantity
+    };
+  });
+  return {
+    lines: rows,
+    subtotal: roundCurrency(rows.reduce((sum, row) => sum + row.lineTotal, 0)),
+    subtotalIsEstimate: lines.length > 0 && lines.some((line) => snapshotUnitPrice(line) === null),
+    isEmpty: rows.length === 0
+  };
+}
+function parseAmount(value) {
+  const amount = Number(value);
+  return Number.isFinite(amount) ? amount : 0;
+}
+function buildCartTotals(view, quote, fallbackCurrency) {
+  if (!quote) {
+    return {
+      subtotal: view.subtotal,
+      discounts: [],
+      aggregateDiscount: null,
+      total: view.subtotal,
+      currency: fallbackCurrency,
+      isEstimate: true
+    };
+  }
+  const discount = parseAmount(quote.discount);
+  const itemised = quote.applied_discounts ?? [];
+  return {
+    subtotal: parseAmount(quote.subtotal),
+    discounts: itemised.map((entry) => ({ label: entry.label, amount: entry.amount })),
+    // The quote states a reduction it did not break down: show it as one row
+    // rather than letting the arithmetic of the block silently not add up.
+    aggregateDiscount: itemised.length === 0 && discount > 0 ? discount : null,
+    total: parseAmount(quote.total),
+    currency: quote.currency || fallbackCurrency,
+    isEstimate: view.subtotalIsEstimate
+  };
+}
+
+// src/contact.ts
+var MESSAGE_MAX_LENGTH = 2e3;
+var MIN_SUBJECT_LENGTH = 2;
+var MAX_TITLE_LENGTH = 30;
+var DEFAULT_TICKET_TITLE = "Contact Request";
+function validateContactSubmission(values, context) {
+  if (!context.contactEnabled) return "The contact form is disabled for this store.";
+  if (!values.name.trim() || !values.email.trim() || !values.message.trim()) {
+    return "Name, email and message are required.";
+  }
+  if (context.requireInvoice && !values.invoiceId.trim()) {
+    return "An order or invoice ID is required.";
+  }
+  return null;
+}
+function requiredGlobal(name) {
+  const value = window[name];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(
+      `Shoppex bootstrap global "${name}" is missing. This storefront must be served by the Shoppex storefront (or preview) worker.`
+    );
+  }
+  return value.trim().replace(/\/+$/, "");
+}
+function buildTicketMessage(values) {
+  const name = values.name.trim();
+  const body = values.message.trim();
+  return `${name ? `Name: ${name}
+
+` : ""}${body}`.slice(0, MESSAGE_MAX_LENGTH);
+}
+async function submitContactTicket(values, context) {
+  const error = validateContactSubmission(values, context);
+  if (error) throw new Error(error);
+  const shopSlug = requiredGlobal("shopSlug");
+  const apiBaseUrl = requiredGlobal("apiBaseUrl");
+  const subject = values.subject.trim();
+  const invoiceId = values.invoiceId.trim();
+  const response = await fetch(
+    `${apiBaseUrl}/v1/storefront/shops/name/${encodeURIComponent(shopSlug)}/tickets`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Accept: "application/json" },
+      body: JSON.stringify({
+        email: values.email.trim().toLowerCase(),
+        title: subject.length >= MIN_SUBJECT_LENGTH ? subject.slice(0, MAX_TITLE_LENGTH) : DEFAULT_TICKET_TITLE,
+        message: buildTicketMessage(values),
+        ...invoiceId ? { invoice_id: invoiceId } : {}
+      })
+    }
+  );
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(payload?.message || payload?.error || "Failed to send your message.");
+  }
+  if (!payload?.data?.uniqid) {
+    throw new Error("Your message was accepted, but the store did not confirm a ticket.");
+  }
+}
+function resolveSupportChannels(links) {
+  const byNetwork = new Map(links.map((link) => [link.network, link.href]));
+  return ["discord", "telegram", "email"].flatMap((network) => {
+    const href = byNetwork.get(network);
+    if (!href) return [];
+    return [{
+      label: network === "email" ? "Email" : network === "discord" ? "Discord" : "Telegram",
+      href,
+      isMail: network === "email"
+    }];
+  });
+}
+
+// src/menus.ts
+import { useEffect as useEffect2, useMemo as useMemo2, useState as useState2 } from "react";
+function toNavLink(item) {
+  const label = typeof item.title === "string" ? item.title.trim() : "";
+  if (!label) return null;
+  const pageSlug = typeof item.page_slug === "string" ? item.page_slug.trim() : "";
+  if (pageSlug) return { label, href: `/page/${pageSlug}`, target: null };
+  const url = typeof item.url === "string" ? item.url.trim() : "";
+  if (!url) return null;
+  return { label, href: url, target: item.target ?? null };
+}
+function resolveMenuLinksForSlot(menus, slot) {
+  const menu = menus.find((entry) => entry.slot === slot);
+  if (!menu || !Array.isArray(menu.items)) return [];
+  return menu.items.flatMap((item) => {
+    const link = toNavLink(item);
+    return link ? [{ link, sortOrder: item.sort_order ?? 0 }] : [];
+  }).sort((a, b) => a.sortOrder - b.sortOrder).map((entry) => entry.link);
+}
+var menusPromise = null;
+function loadMerchantMenus() {
+  menusPromise ??= getShoppex().getMenus().then((result) => result.success && Array.isArray(result.data) ? result.data : []).catch(() => []);
+  return menusPromise;
+}
+function useNavigationLinks(slot, themeLinks, authored) {
+  const themeNavLinks = useMemo2(
+    () => themeLinks.map((link) => ({ ...link, target: null })),
+    [themeLinks]
+  );
+  const [menuLinks, setMenuLinks] = useState2(null);
+  useEffect2(() => {
+    if (authored) return void 0;
+    let active = true;
+    void loadMerchantMenus().then((menus) => {
+      if (active) setMenuLinks(resolveMenuLinksForSlot(menus, slot));
+    });
+    return () => {
+      active = false;
+    };
+  }, [authored, slot]);
+  if (!authored && menuLinks !== null && menuLinks.length > 0) {
+    return { links: menuLinks, fromTheme: false };
+  }
+  return { links: themeNavLinks, fromTheme: true };
+}
+
+// src/reviews.ts
+import { useEffect as useEffect3, useState as useState3 } from "react";
+var SHOP_REVIEW_PAGE_SIZE = 12;
+function toTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value < 1e12 ? value * 1e3 : value;
+  }
+  if (typeof value !== "string" || value.trim() === "") return 0;
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) {
+    return numeric < 1e12 ? numeric * 1e3 : numeric;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function formatDateLabel(timestamp) {
+  if (!timestamp) return "";
+  return new Date(timestamp).toLocaleDateString("en-US", {
+    day: "numeric",
+    month: "short",
+    year: "numeric"
+  });
+}
+function toStarCount(rating) {
+  if (!Number.isFinite(rating)) return 0;
+  return Math.max(0, Math.min(5, Math.round(rating)));
+}
+function toShopReviews(rows, labels) {
+  return rows.filter((row) => typeof row.rating === "number" && Number.isFinite(row.rating) && row.rating > 0).map((row, index) => {
+    const timestamp = toTimestamp(row.created_at);
+    const comment = (row.comment ?? row.message ?? "").trim();
+    const author = (row.author ?? row.customer_name ?? "").trim();
+    return {
+      id: row.id || `review:${index}`,
+      rating: row.rating,
+      starCount: toStarCount(row.rating),
+      comment: comment.length > 0 ? comment : labels.emptyComment,
+      author: author.length > 0 ? author : labels.anonymousAuthor,
+      dateLabel: formatDateLabel(timestamp),
+      timestamp,
+      productTitle: row.product_title?.trim() || null,
+      verified: row.verified === true
+    };
+  }).sort((a, b) => b.timestamp - a.timestamp);
+}
+function reviewsForProduct(reviews, productTitle) {
+  const title = productTitle.trim();
+  if (!title) return [];
+  return reviews.filter((review) => review.productTitle === title);
+}
+function averageRating(reviews) {
+  if (reviews.length === 0) return null;
+  return reviews.reduce((total, review) => total + review.rating, 0) / reviews.length;
+}
+function useShopReviews(labels) {
+  const [state, setState] = useState3({ status: "loading" });
+  const { anonymousAuthor, emptyComment } = labels;
+  useEffect3(() => {
+    let active = true;
+    getShoppex().getShopReviews().then((result) => {
+      if (!active) return;
+      if (!result.success || !result.data) {
+        setState({ status: "error" });
+        return;
+      }
+      const reviews = toShopReviews(result.data, { anonymousAuthor, emptyComment });
+      setState({ status: "ready", reviews, average: averageRating(reviews) });
+    }).catch(() => {
+      if (active) setState({ status: "error" });
+    });
+    return () => {
+      active = false;
+    };
+  }, [anonymousAuthor, emptyComment]);
+  return state;
+}
+
+// src/shop-pages.ts
+function parseFaqItems(value) {
+  if (!Array.isArray(value)) return [];
+  const items = [];
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object") continue;
+    const record = entry;
+    const question = typeof record.question === "string" ? record.question.trim() : "";
+    const answer = typeof record.answer === "string" ? record.answer.trim() : "";
+    if (question && answer) items.push({ question, answer });
+  }
+  return items;
+}
+async function renderShopPageMarkdownHtml(content) {
+  const trimmed = typeof content === "string" ? content.trim() : "";
+  if (!trimmed) return "";
+  const { marked } = await import("marked");
+  return marked.parse(trimmed, { async: false, gfm: true, breaks: true });
+}
+async function buildShopPageModel(page) {
+  const faqItems = page.template_type === "faq" ? parseFaqItems(page.settings?.faq_items) : [];
+  return {
+    title: page.name,
+    // A FAQ page never shows its body, so its markdown is never parsed and the
+    // parser is never fetched for one.
+    bodyMarkdownHtml: faqItems.length > 0 ? "" : await renderShopPageMarkdownHtml(page.content),
+    faqItems
+  };
+}
+async function loadShopPage(slug) {
+  try {
+    const result = await getShoppex().getPage(slug);
+    const page = result.success ? result.data : void 0;
+    if (!page || typeof page.name !== "string" || !page.name.trim()) {
+      return { status: "missing" };
+    }
+    return { status: "ready", page: await buildShopPageModel(page) };
+  } catch {
+    return { status: "missing" };
+  }
+}
+
+// src/storefront-context.tsx
+import { createContext as createContext2, useContext as useContext2, useEffect as useEffect4, useState as useState4 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function readStorefrontData() {
+  const settings = getStorefrontSettings();
+  const catalog = buildStorefrontCatalog(settings);
+  return { settings, shop: getStorefrontShop(catalog.listedProductCount), catalog };
+}
+var StorefrontContext = createContext2(null);
+function StorefrontProvider({ data, children }) {
+  return /* @__PURE__ */ jsx2(StorefrontContext.Provider, { value: data, children });
+}
+function useStorefront() {
+  const data = useContext2(StorefrontContext);
+  if (!data) throw new Error("useStorefront must be used inside StorefrontProvider.");
+  return data;
+}
+function useOnlineUserCount() {
+  const [count, setCount] = useState4(null);
+  useEffect4(() => {
+    let active = true;
+    getShoppex().getStorefrontOnlineUsers().then((result) => {
+      if (!active || !result.success || !result.data) return;
+      const value = result.data.count;
+      if (Number.isFinite(value) && value > 0) setCount(Math.floor(value));
+    }).catch(() => void 0);
+    return () => {
+      active = false;
+    };
+  }, []);
+  return count;
+}
+export {
+  ACCOUNT_ARTIFACT_CAPABILITIES,
+  ACCOUNT_PATH,
+  ACCOUNT_PATH_ALIAS,
+  ACCOUNT_ROUTE_MESSAGE_KEYS,
+  ACCOUNT_STOREFRONT_ROUTES,
+  ACCOUNT_TABS,
+  CATALOG_PAGE_SIZE,
+  CATALOG_SORTS,
+  CATALOG_SORT_LABELS,
+  CartProvider,
+  DEFAULT_ACCOUNT_TAB,
+  DEFAULT_LOW_STOCK_THRESHOLD,
+  DELIVERY_TIME_UNITS,
+  IMPLEMENTED_ACCOUNT_TABS,
+  MAX_PAY_WHAT_YOU_WANT_PRICE,
+  PRODUCT_BADGE_ICON_NAMES,
+  QUOTE_UNAVAILABLE_CHECKOUT_ERROR,
+  SERVING_CONTEXT_HINT,
+  SHOP_REVIEW_PAGE_SIZE,
+  STOREFRONT_SORT_KEYS,
+  StorefrontProvider,
+  accountOrderHref,
+  accountRouteMessage,
+  accountTabHref,
+  accountTabLabelKey,
+  averageRating,
+  badgesForCard,
+  badgesForProductPage,
+  buildCartTotals,
+  buildCartView,
+  buildCustomFieldPayload,
+  buildInitialCheckoutFieldValues,
+  buildProductDetail,
+  buildStorefrontCatalog,
+  calculateDisplayLineTotal,
+  calculateLinePricing,
+  canonicalAccountPath,
+  checkoutFieldKey,
+  checkoutFieldWriteRepriced,
+  checkoutNeedsDetails,
+  clampQuantity,
+  clearRecoveredQuoteCheckoutError,
+  filterCatalogCards,
+  findStorefrontProduct,
+  firstOptionalString,
+  flattenMerchantHtmlToText,
+  formatCompactCount,
+  formatDeliveryTime,
+  formatLicenseTerm,
+  formatMoney,
+  formatSubscriptionCadence,
+  formatSubscriptionTrial,
+  getAuthoredContent,
+  getBuyerCurrency,
+  getProductGroups,
+  getProducts,
+  getShoppex,
+  getStorefrontAddons,
+  getStorefrontCategories,
+  getStorefrontListing,
+  getStorefrontSettings,
+  getStorefrontShop,
+  hasInjectedStorefrontData,
+  isAccountTab,
+  isBlankMerchantHtml,
+  isCheckboxValueChecked,
+  isImplementedAccountTab,
+  isProductSoldOut,
+  isRecord,
+  isSelectionSoldOut,
+  loadShopPage,
+  missingRequiredCheckoutValues,
+  optionalBoolean,
+  optionalString,
+  optionalStringWithDefault,
+  paginateCatalogCards,
+  parseAccountPath,
+  parseCartQuoteLines,
+  parseEnum,
+  parseFiniteNumber,
+  parseProductBadges,
+  parseStorefrontSortKey,
+  readCheckoutNeedsDetails,
+  readStorefrontData,
+  requireArray,
+  requireBoolean,
+  requireNumber,
+  requireRecord,
+  requireString,
+  requireStringFromKeys,
+  requireUnknownRecord,
+  resolveAccountView,
+  resolveBadgeForeground,
+  resolveCartBoundsHeals,
+  resolveCategorySelection,
+  resolveCheckoutFields,
+  resolveDeliveryPromise,
+  resolveDisplayStock,
+  resolveHideStockCounter,
+  resolveLicenseTerm,
+  resolveMenuLinksForSlot,
+  resolvePayWhatYouWantMinimum,
+  resolveProductVideoEmbedSrc,
+  resolveQuantityBounds,
+  resolveSupportChannels,
+  resolveUnsellableLineIds,
+  resolveVariantStock,
+  reviewsForProduct,
+  roundCurrency,
+  sanitizeMerchantHtml,
+  sortCatalogCards,
+  startCartMutation,
+  stripMerchantHtmlImages,
+  submitContactTicket,
+  toShopReviews,
+  toStarCount,
+  useCart,
+  useNavigationLinks,
+  useOnlineUserCount,
+  useShopReviews,
+  useStorefront,
+  validateCheckoutFieldValue,
+  validateCheckoutFields,
+  validateContactSubmission
+};
+//# sourceMappingURL=index.js.map