@pie-players/pie-section-player 0.2.12 → 0.2.13

package/dist/player-preload-CQVG0Bih.js

@@ -0,0 +1,705 @@
+var H = Object.defineProperty;
+var M = (t, e, r) => e in t ? H(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var p = (t, e, r) => M(t, typeof e != "symbol" ? e + "" : e, r);
+const O = /* @__PURE__ */ new Set([
+  "annotation-xml",
+  "color-profile",
+  "font-face",
+  "font-face-src",
+  "font-face-uri",
+  "font-face-format",
+  "font-face-name",
+  "missing-glyph"
+]), F = /^[a-z][a-z0-9._-]*-[a-z0-9._-]*$/, R = (t, e = "custom element tag") => {
+  if (!t || typeof t != "string")
+    throw new Error(`Invalid ${e}: expected a non-empty string`);
+  const r = t.trim();
+  if (!r)
+    throw new Error(`Invalid ${e}: tag is empty`);
+  if (r !== r.toLowerCase())
+    throw new Error(`Invalid ${e} "${r}": custom element names must be lowercase`);
+  if (!r.includes("-"))
+    throw new Error(`Invalid ${e} "${r}": custom element names must include a hyphen`);
+  if (O.has(r))
+    throw new Error(`Invalid ${e} "${r}": this name is reserved by the HTML spec`);
+  if (!F.test(r))
+    throw new Error(`Invalid ${e} "${r}": allowed characters are lowercase letters, numbers, ".", "_" and "-"`);
+  return r;
+}, j = { BASE_URL: "/", DEV: !1, MODE: "production", PROD: !0, SSR: !1 }, B = "https://proxy.pie-api.com", x = `${B}/bundles/`;
+function D(t) {
+  try {
+    const e = j?.[t];
+    if (typeof e == "string" && e.length > 0)
+      return e;
+  } catch {
+  }
+}
+typeof window < "u" && window.PIE_BUILDER_ORIGIN_URL || D("PUBLIC_BUILDER_ORIGIN_URL");
+typeof window < "u" && window.PIE_BUILDER_BUNDLE_URL || D("PUBLIC_BUILDER_BUNDLE_URL");
+function T(t) {
+  const e = {};
+  return t.forEach((r) => {
+    const n = r.config?.elements || {};
+    Object.entries(n).forEach(([o, i]) => {
+      if (!e[o])
+        e[o] = i;
+      else if (e[o] !== i)
+        throw new Error(`Element version conflict: ${o} requires both ${e[o]} and ${i}. All items in a section must use the same version of each element.`);
+    });
+  }), e;
+}
+function N(t, e) {
+  const r = `[${t}]`;
+  return {
+    // Only debug method checks debugEnabledFn - it's checked dynamically on every call
+    debug: (n, ...o) => {
+      e() && console.debug(r, n, ...o);
+    },
+    // info, warn, error always log (not gated by debug flag)
+    info: (n, ...o) => console.info(r, n, ...o),
+    warn: (n, ...o) => console.warn(r, n, ...o),
+    error: (n, ...o) => console.error(r, n, ...o)
+  };
+}
+class G {
+  constructor() {
+    p(this, "currentRenderer", null);
+  }
+  /**
+   * Set the active math renderer
+   *
+   * This will update the window globals that PIE elements expect:
+   * - window["@pie-lib/math-rendering"]
+   * - window["_dll_pie_lib__math_rendering"]
+   *
+   * @param renderer - The renderer to use
+   *
+   * @example
+   * ```typescript
+   * import { createKatexRenderer } from '@pie-players/math-renderer-katex';
+   * import { mathRendererProvider } from '@pie-players/math-renderer-core';
+   *
+   * const renderer = await createKatexRenderer();
+   * mathRendererProvider.setRenderer(renderer);
+   * ```
+   */
+  setRenderer(e) {
+    this.currentRenderer = e, this.updateWindowGlobals();
+  }
+  /**
+   * Get the current renderer
+   *
+   * @returns The active renderer, or null if none set
+   */
+  getRenderer() {
+    return this.currentRenderer;
+  }
+  /**
+   * Check if a renderer has been initialized
+   *
+   * @returns true if a renderer is set
+   */
+  isInitialized() {
+    return this.currentRenderer !== null;
+  }
+  /**
+   * Update window globals for PIE element compatibility
+   *
+   * PIE elements expect to find math rendering on these two globals:
+   * - window["@pie-lib/math-rendering"] - Standard key
+   * - window["_dll_pie_lib__math_rendering"] - SystemJS/DLL key for IIFE bundles
+   *
+   * @private
+   */
+  updateWindowGlobals() {
+    if (typeof window > "u")
+      return;
+    const e = "@pie-lib/math-rendering", r = "_dll_pie_lib__math_rendering";
+    this.currentRenderer && (window[e] = this.currentRenderer, window[r] = this.currentRenderer);
+  }
+}
+const I = new G();
+async function W(t = {}) {
+  const { _dll_pie_lib__math_rendering: e } = await import("./index-C1goqVqV.js");
+  return e;
+}
+async function k(t) {
+  if (!(typeof window > "u") && !I.isInitialized())
+    try {
+      const e = t ?? await W();
+      I.setRenderer(e), console.log("[MathRendering] ✅ Math rendering module initialized (both globals set)");
+    } catch (e) {
+      throw console.error("[MathRendering] ❌ Failed to initialize math rendering:", e), e;
+    }
+}
+var E;
+(function(t) {
+  t.player = "player.js", t.clientPlayer = "client-player.js", t.editor = "editor.js";
+})(E || (E = {}));
+var b;
+(function(t) {
+  t.loading = "loading", t.loaded = "loaded";
+})(b || (b = {}));
+function C(t) {
+  return typeof t == "function" && "prototype" in t && t.prototype instanceof HTMLElement;
+}
+function V(t) {
+  return t && typeof t.PIE_REGISTRY == "object";
+}
+const $ = () => {
+  let t;
+  return V(window) ? t = window.PIE_REGISTRY : (t = {}, window.PIE_REGISTRY = t), t;
+};
+let u;
+const h = {
+  delivery: {
+    subpath: "",
+    tagSuffix: ""
+  },
+  author: {
+    subpath: "/author",
+    tagSuffix: "-config",
+    fallback: "delivery"
+    // Fall back to delivery if author doesn't exist
+  },
+  print: {
+    subpath: "/print",
+    tagSuffix: "-print",
+    fallback: "delivery"
+  }
+  // Custom views can follow patterns like:
+  // 'delivery-mobile': { subpath: '/delivery-mobile', tagSuffix: '', fallback: 'delivery' }
+  // 'delivery-a11y': { subpath: '/delivery-a11y', tagSuffix: '', fallback: 'delivery' }
+  // 'delivery-simple': { subpath: '/delivery-simple', tagSuffix: '', fallback: 'delivery' }
+};
+class z {
+  constructor(e) {
+    p(this, "cdnBaseUrl");
+    p(this, "importMapInjected", !1);
+    this.cdnBaseUrl = e.cdnBaseUrl, u = N("esm-loader", e.debugEnabled || (() => !1));
+  }
+  extractPackageName(e) {
+    const r = e.split("@");
+    return r.length >= 3 ? `@${r[1]}` : r[0];
+  }
+  generateImportMap(e, r) {
+    const n = {}, o = r.viewConfig || h[r.view] || h.delivery;
+    for (const [i, a] of Object.entries(e)) {
+      const l = this.extractPackageName(a);
+      if (n[l] = this.resolvePackageUrl(a), o.subpath && (n[`${l}${o.subpath}`] = this.resolveSubpathUrl(a, o.subpath)), r.loadControllers && (n[`${l}/controller`] = this.resolveControllerUrl(a)), o.fallback) {
+        const m = h[o.fallback];
+        m?.subpath && (n[`${l}${m.subpath}`] = this.resolveSubpathUrl(a, m.subpath));
+      }
+    }
+    return { imports: n };
+  }
+  isJsDelivrNpm() {
+    return this.cdnBaseUrl.includes("cdn.jsdelivr.net/npm");
+  }
+  resolvePackageUrl(e) {
+    return this.isJsDelivrNpm() ? `${this.cdnBaseUrl}/${e}/+esm` : `${this.cdnBaseUrl}/${e}`;
+  }
+  resolveControllerUrl(e) {
+    return this.isJsDelivrNpm() ? `${this.cdnBaseUrl}/${e}/controller/+esm` : `${this.cdnBaseUrl}/${e}/controller`;
+  }
+  resolveSubpathUrl(e, r) {
+    const n = r.startsWith("/") ? r.slice(1) : r;
+    return this.isJsDelivrNpm() ? `${this.cdnBaseUrl}/${e}/${n}/+esm` : `${this.cdnBaseUrl}/${e}/${n}`;
+  }
+  injectImportMap(e, r) {
+    const n = r.createElement("script");
+    n.type = "importmap", n.textContent = JSON.stringify(e, null, 2), r.head.appendChild(n);
+  }
+  async loadElement(e, r, n) {
+    const o = $(), i = n.viewConfig || h[n.view] || h.delivery;
+    try {
+      const a = this.extractPackageName(r), l = R(`${e}${i.tagSuffix}`, `element tag for ${a}`);
+      u.debug(`Loading element ${l} from ${a} (${r})`), u.debug(`View: ${n.view}, subpath: ${i.subpath}`);
+      const m = i.subpath ? `${a}${i.subpath}` : a;
+      let d, c;
+      try {
+        d = await import(
+          /* @vite-ignore */
+          m
+        ), u.debug(`Module loaded for ${l}:`, d), u.debug("Module exports:", Object.keys(d)), n.view === "author" ? c = d.default || d.Configure || d.Element : n.view === "print" ? c = d.default || d.Print || d.Element : c = d.default || d.Element;
+      } catch (g) {
+        if (i.fallback) {
+          u.warn(`Failed to load ${m}, trying fallback: ${i.fallback}`);
+          const y = h[i.fallback];
+          let f;
+          y.subpath ? f = `${a}${y.subpath}` : f = a, d = await import(
+            /* @vite-ignore */
+            f
+          ), c = d.default || d.Element, u.debug(`Loaded fallback view for ${l}`);
+        } else
+          throw g;
+      }
+      if (!c)
+        throw new Error(`No suitable element class found in ${m} for view ${n.view}`);
+      let w = null;
+      if (n.loadControllers)
+        try {
+          const g = await import(
+            /* @vite-ignore */
+            `${a}/controller`
+          );
+          u.debug(`Controller module loaded for ${l}:`, g), w = g.default || g, w ? u.debug(`Controller registered for ${l}`) : u.warn(`No controller export found for ${l}`);
+        } catch (g) {
+          u.warn(`Failed to load controller for ${l}:`, g);
+        }
+      o[l] = {
+        package: r,
+        status: b.loading,
+        tagName: l,
+        element: c,
+        controller: w,
+        config: null,
+        bundleType: "esm"
+        // Mark as ESM-loaded
+      }, customElements.get(l) ? (u.debug(`Element ${l} already registered`), o[l] = {
+        ...o[l],
+        status: b.loaded
+      }) : C(c) ? (customElements.define(l, class extends c {
+      }), u.debug(`Registered custom element: ${l}`), o[l] = {
+        ...o[l],
+        status: b.loaded
+      }) : u.warn("No Element export found in module");
+    } catch (a) {
+      throw u.error(`Failed to load element ${e}:`, a), a;
+    }
+  }
+  getController(e) {
+    return $()[e]?.controller || null;
+  }
+  async elementsHaveLoaded(e) {
+    const r = e.map((n) => (u.debug(`Waiting for ${n.tag} to be defined`), customElements.whenDefined(n.tag)));
+    return await Promise.all(r), { elements: e, val: !0 };
+  }
+  /**
+   * Load PIE elements with specified view/variant
+   *
+   * @param contentConfig - Item config with elements
+   * @param doc - Document to inject import maps into
+   * @param options - Loading options (view, controllers, etc.)
+   *
+   * @example
+   * // Load delivery view with controllers
+   * await loader.load(config, document, { view: 'delivery', loadControllers: true });
+   *
+   * @example
+   * // Load author view (configuration UI)
+   * await loader.load(config, document, { view: 'author', loadControllers: false });
+   *
+   * @example
+   * // Load custom mobile-optimized view with fallback
+   * await loader.load(config, document, {
+   *   view: 'delivery-mobile',
+   *   viewConfig: { subpath: '/delivery-mobile', tagSuffix: '', fallback: 'delivery' },
+   *   loadControllers: true
+   * });
+   */
+  async load(e, r, n) {
+    if (u.debug("load() called with options:", n), u.debug("contentConfig:", e), !e?.elements) {
+      u.warn("No elements in config");
+      return;
+    }
+    const o = n.viewConfig || h[n.view] || h.delivery;
+    if (await k(), this.importMapInjected)
+      u.debug("Import map already injected, skipping");
+    else {
+      u.debug("Generating import map for view:", n.view);
+      const l = this.generateImportMap(e.elements, n);
+      u.debug("Import map:", l), this.injectImportMap(l, r), this.importMapInjected = !0, u.debug("Import map injected");
+    }
+    const i = Object.keys(e.elements);
+    u.debug("Loading elements:", i), await Promise.all(i.map((l) => this.loadElement(l, e.elements[l], n))), u.debug("All elements loaded"), u.debug("Waiting for custom elements to be defined");
+    const a = i.map((l) => R(`${l}${o.tagSuffix}`, `element tag for view "${n.view}"`));
+    await Promise.all(a.map((l) => customElements.whenDefined(l))), u.debug("All custom elements defined");
+  }
+}
+class J {
+  constructor(e) {
+    p(this, "loader");
+    this.loader = new z({
+      cdnBaseUrl: e.esmCdnUrl,
+      debugEnabled: e.debugEnabled
+    });
+  }
+  /**
+   * Load elements directly from an element map
+   *
+   * @param elements - Map of element tag names to package versions
+   * @param options - Loading options
+   */
+  async loadElements(e, r) {
+    await this.loader.load({ elements: e }, document, {
+      view: r?.view || "delivery",
+      loadControllers: r?.needsControllers ?? !0
+    });
+  }
+  /**
+   * Extract and load elements from items
+   *
+   * Automatically aggregates unique elements from all items and loads them once.
+   *
+   * @param items - Array of items to extract elements from
+   * @param options - Loading options
+   * @throws Error if element version conflicts are detected
+   */
+  async loadFromItems(e, r) {
+    const n = T(e);
+    await this.loadElements(n, r);
+  }
+}
+const Y = (t) => {
+  if (!t)
+    throw new Error("Parameter is required: input");
+  const e = t.charAt(0) === "@" ? t.match(/^(@[^/]+\/[^/@]+)(?:\/([^@]+))?(?:@([\s\S]+))?/) : t.match(/^([^/@]+)(?:\/([^@]+))?(?:@([\s\S]+))?/);
+  if (!e)
+    throw new Error(`[parse-package-name] "${t}" is not a valid string`);
+  return {
+    name: e[1],
+    path: e[2] || "",
+    version: e[3] || ""
+  };
+}, q = (t) => t.split("+").map((e) => Y(e).name).join("+");
+let s;
+const K = "https://proxy.pie-api.com/bundles/";
+typeof window < "u" && !window.pieHelpers && (window.pieHelpers = {
+  loadingScripts: {},
+  loadingPromises: {}
+});
+class Q {
+  constructor(e) {
+    p(this, "config");
+    this.config = e, s = N("iife-loader", e.debugEnabled || (() => !1));
+  }
+  /**
+   * Get the bundle URL based on config elements
+   */
+  getBundleUrl(e, r, n) {
+    const o = Object.keys(e || {}).sort().join(",");
+    if (n?.url) {
+      const d = n.url.includes("?") ? "&" : "?", c = o ? `${n.url}${d}elements=${encodeURIComponent(o)}` : n.url;
+      return s.debug("Using explicit bundle URL from config:", c), c;
+    }
+    const i = Object.values(e).join("+");
+    let a = this.config.bundleHost || K;
+    a = a.trim(), a = a.replace(/\/+$/, "") + "/";
+    const l = `${a}${encodeURI(i)}/${r}`, m = o ? `${l}?elements=${encodeURIComponent(o)}` : l;
+    return s.debug("Using bundle host URL:", m), m;
+  }
+  /**
+   * Load an IIFE bundle from the specified URL
+   */
+  async loadBundleScript(e, r) {
+    return new Promise((n, o) => {
+      const i = r.createElement("script");
+      i.src = e, i.defer = !0, i.setAttribute("data-pie-bundle", "true"), i.onload = () => {
+        s.debug("Bundle loaded successfully from:", e), n();
+      }, i.onerror = () => {
+        const a = `Failed to load IIFE bundle from: ${e}`;
+        s.error(a), o(new Error(a));
+      }, r.head.appendChild(i);
+    });
+  }
+  whenDefinedWithTimeout(e) {
+    const r = this.config.whenDefinedTimeoutMs ?? 5e3;
+    return Promise.race([
+      customElements.whenDefined(e).then(() => {
+      }),
+      new Promise((n, o) => setTimeout(() => o(new Error(`Timeout waiting for ${e}`)), r))
+    ]);
+  }
+  createEmptyConfigure() {
+    return class extends HTMLElement {
+      constructor() {
+        super(...arguments);
+        p(this, "_model");
+        p(this, "_configuration");
+      }
+      set model(n) {
+        this._model = n;
+      }
+      get model() {
+        return this._model;
+      }
+      set configuration(n) {
+        this._configuration = n;
+      }
+      get configuration() {
+        return this._configuration;
+      }
+    };
+  }
+  /**
+   * Register elements from the loaded IIFE bundle into the PIE registry
+   */
+  async registerElementsFromBundle(e, r, n) {
+    const o = $();
+    if (!window.pie || !window.pie.default)
+      throw new Error("window.pie not found - IIFE bundle did not load correctly");
+    const i = window.pie.default;
+    s.debug("Found window.pie.default with packages:", Object.keys(i)), s.debug("Elements to register:", e), s.debug("Bundle type:", n);
+    const a = [], l = n === E.editor;
+    for (const [m, d] of Object.entries(e))
+      try {
+        const c = q(d);
+        s.debug(`Registering element ${m} from package ${c} (full: ${d})`);
+        const w = i[c];
+        if (!w)
+          throw new Error(`Package "${c}" not found in IIFE bundle. Available: ${Object.keys(i).join(", ")}`);
+        const g = l ? w.Configure || this.createEmptyConfigure() : w.Element, y = r ? w.controller : null, f = R(l ? `${m}-config` : m, `element tag for ${c}`);
+        if (!g) {
+          const v = l ? "Configure" : "Element";
+          throw new Error(`No ${v} class found in package ${c}`);
+        }
+        if (o[f] = {
+          package: d,
+          status: b.loading,
+          tagName: f,
+          element: g,
+          controller: y,
+          config: w.config || null,
+          bundleType: n || "iife"
+          // Mark bundle type
+        }, customElements.get(f))
+          s.debug(`Element ${f} already registered`), o[f] = {
+            ...o[f],
+            status: b.loaded
+          };
+        else if (C(g)) {
+          customElements.define(f, class extends g {
+          }), s.debug(`Registered custom element: ${f}`);
+          const v = this.whenDefinedWithTimeout(f).then(() => {
+            o[f] = {
+              ...o[f],
+              status: b.loaded
+            }, s.debug(`Element ${f} fully loaded`);
+          }).catch((A) => {
+            s.error(`Failed to define element ${f}:`, A);
+          });
+          a.push(v);
+        } else
+          s.warn(`Element class for ${c} is not a valid custom element constructor`);
+      } catch (c) {
+        throw s.error(`Failed to register element ${m}:`, c), c;
+      }
+    await Promise.all(a), s.debug("All elements registered and defined");
+  }
+  /**
+   * Load PIE elements from IIFE bundle
+   *
+   * @param contentConfig - Item config with elements
+   * @param doc - Document to inject script into
+   * @param bundleType - Type of bundle (BundleType.player, BundleType.clientPlayer, or BundleType.editor)
+   * @param needsControllers - Whether controllers are needed
+   */
+  async load(e, r, n, o) {
+    if (s.debug("load() called"), s.debug("Bundle type:", n), s.debug("Needs controllers:", o), s.debug("Content config:", e), !e?.elements) {
+      s.warn("No elements in config");
+      return;
+    }
+    await k();
+    const i = this.getBundleUrl(e.elements, n, e.bundle), a = r.querySelector(`script[src="${i}"]`), l = Array.from(r.querySelectorAll('script[data-pie-bundle="true"]')).find((d) => d.getAttribute("src") !== i);
+    if (l && (s.debug("Removing previously loaded bundle:", l.getAttribute("src")), l.remove(), window.pie && delete window.pie), a && window.pie && window.pie.default) {
+      s.debug("Exact bundle already loaded, registering elements"), await this.registerElementsFromBundle(e.elements, o, n), s.debug("✅ Elements registered from existing bundle");
+      return;
+    }
+    if (window.pieHelpers?.loadingPromises?.[i]) {
+      s.debug("Bundle is already loading, waiting for existing load:", i), await window.pieHelpers.loadingPromises[i], s.debug("Existing bundle load completed, registering elements"), await this.registerElementsFromBundle(e.elements, o, n), s.debug("✅ Elements registered from already-loading bundle");
+      return;
+    }
+    window.pieHelpers && (window.pieHelpers.loadingScripts[i] = !0);
+    const m = (async () => {
+      try {
+        s.debug("Loading IIFE bundle from:", i);
+        try {
+          await this.loadBundleScript(i, r);
+        } catch (d) {
+          if (this.config.reFetchBundle) {
+            const c = i + (i.includes("?") ? "&" : "?") + `t=${Date.now()}`;
+            s.warn("[IifePieLoader] Initial bundle load failed, retrying with cache bust:", c), await this.loadBundleScript(c, r);
+          } else
+            throw d;
+        }
+        s.debug("Registering elements from loaded bundle"), await this.registerElementsFromBundle(e.elements, o, n), s.debug("✅ IIFE bundle loaded and elements registered");
+      } catch (d) {
+        throw s.error("Failed to load IIFE bundle:", d), window.pieHelpers && (delete window.pieHelpers.loadingPromises[i], delete window.pieHelpers.loadingScripts[i]), d;
+      } finally {
+        window.pieHelpers?.loadingPromises?.[i] && delete window.pieHelpers.loadingPromises[i];
+      }
+    })();
+    window.pieHelpers && (window.pieHelpers.loadingPromises[i] = m), await m;
+  }
+  /**
+   * Get controller for a specific element tag
+   */
+  getController(e) {
+    return $()[e]?.controller || null;
+  }
+  /**
+   * Wait for elements to be fully loaded
+   */
+  async elementsHaveLoaded(e) {
+    const r = e.map((n) => (s.debug(`Waiting for ${n.tag} to be defined`), this.whenDefinedWithTimeout(n.tag)));
+    return await Promise.all(r), { elements: e, val: !0 };
+  }
+}
+class X {
+  constructor(e) {
+    p(this, "loader");
+    this.loader = new Q({
+      bundleHost: e.bundleHost,
+      debugEnabled: e.debugEnabled
+    });
+  }
+  /**
+   * Load elements directly from an element map
+   *
+   * @param elements - Map of element tag names to package versions
+   * @param options - Loading options
+   */
+  async loadElements(e, r) {
+    await this.loader.load({ elements: e }, document, r?.bundleType || E.clientPlayer, r?.needsControllers ?? !0);
+  }
+  /**
+   * Extract and load elements from items
+   *
+   * Automatically aggregates unique elements from all items and loads them once.
+   *
+   * @param items - Array of items to extract elements from
+   * @param options - Loading options
+   * @throws Error if element version conflicts are detected
+   */
+  async loadFromItems(e, r) {
+    const n = T(e);
+    await this.loadElements(n, r);
+  }
+}
+var U;
+(function(t) {
+  t.SAVE = "save", t.MODEL = "model", t.SCORE = "score", t.MANUAL_SCORE = "manual-score";
+})(U || (U = {}));
+var _;
+(function(t) {
+  t.AUTO = "auto", t.MANUAL = "manual";
+})(_ || (_ = {}));
+var L;
+(function(t) {
+  t.GATHER = "gather", t.VIEW = "view", t.EVALUATE = "evaluate";
+})(L || (L = {}));
+var P;
+(function(t) {
+  t.PENDING = "pending", t.IN_PROGRESS = "in_progress", t.COMPLETED = "completed", t.FAILED = "failed";
+})(P || (P = {}));
+var S;
+(function(t) {
+  t[t.ROOT = 0] = "ROOT", t[t.SUBJECT = 1] = "SUBJECT", t[t.LEVEL = 2] = "LEVEL", t[t.STANDARD = 3] = "STANDARD";
+})(S || (S = {}));
+E.player;
+const Z = 15e3;
+function ie(t) {
+  return t.map((e, r) => {
+    const n = e?.entity || {}, o = typeof n.id == "string" && n.id || `renderable-${r}`, i = typeof n.version == "string" && n.version || (typeof n.version == "number" ? String(n.version) : "") || (typeof n.config?.version == "string" ? n.config.version : "");
+    return `${o}:${i}`;
+  }).join("|");
+}
+function ee(t) {
+  return t?.mode === "author" ? "author" : "delivery";
+}
+function te(t) {
+  return [
+    t.strategy,
+    t.loaderView,
+    t.strategy === "esm" ? t.esmCdnUrl : t.bundleHost,
+    t.renderablesSignature
+  ].join("|");
+}
+async function re(t) {
+  if (t.renderables.length === 0 || t.strategy === "preloaded")
+    return;
+  let e = null;
+  if (t.strategy === "esm")
+    e = new J({
+      esmCdnUrl: t.esmCdnUrl,
+      debugEnabled: () => !1
+    });
+  else {
+    if (!t.bundleHost)
+      throw new Error("Missing iife bundleHost");
+    e = new X({
+      bundleHost: t.bundleHost,
+      debugEnabled: () => !1
+    });
+  }
+  const r = window.setTimeout(
+    () => t.onTimeout(),
+    t.timeoutMs || Z
+  );
+  try {
+    await e.loadFromItems(t.renderables, {
+      view: t.loaderView,
+      needsControllers: !0
+    });
+  } finally {
+    window.clearTimeout(r);
+  }
+}
+function le(t) {
+  const e = String(
+    t.resolvedPlayerProps?.loaderOptions?.esmCdnUrl || "https://esm.sh"
+  ), r = String(
+    t.resolvedPlayerProps?.loaderOptions?.bundleHost || t.iifeBundleHost || ""
+  ).trim(), n = ee(t.resolvedPlayerEnv), o = te({
+    strategy: t.strategy,
+    loaderView: n,
+    esmCdnUrl: e,
+    bundleHost: r,
+    renderablesSignature: t.renderablesSignature
+  }), i = t.getState();
+  if (o === i.lastPreloadSignature)
+    return;
+  if (t.setState({ lastPreloadSignature: o }), t.renderables.length === 0) {
+    t.setState({ elementsLoaded: !0 });
+    return;
+  }
+  const a = i.preloadRunToken + 1;
+  if (t.setState({
+    preloadRunToken: a,
+    elementsLoaded: !1
+  }), t.strategy === "preloaded") {
+    t.setState({ elementsLoaded: !0 });
+    return;
+  }
+  if (t.strategy !== "esm" && !r) {
+    console.warn(
+      `[${t.componentTag}] Missing iifeBundleHost for element preloading; rendering without preload.`
+    ), t.setState({ elementsLoaded: !0 });
+    return;
+  }
+  re({
+    strategy: t.strategy,
+    renderables: t.renderables,
+    loaderView: n,
+    esmCdnUrl: e,
+    bundleHost: r,
+    onTimeout: () => {
+      a === t.getState().preloadRunToken && (console.warn(
+        `[${t.componentTag}] Element preloading timed out; continuing render without preload.`
+      ), t.setState({ elementsLoaded: !0 }));
+    }
+  }).then(() => {
+    a === t.getState().preloadRunToken && t.setState({ elementsLoaded: !0 });
+  }).catch((l) => {
+    console.error(`[${t.componentTag}] Failed to preload PIE elements:`, l), a === t.getState().preloadRunToken && t.setState({ elementsLoaded: !0 });
+  });
+}
+export {
+  ee as a,
+  te as b,
+  ie as g,
+  le as o,
+  re as p,
+  R as v
+};

package/dist/utils/player-preload.d.ts

@@ -0,0 +1,2 @@
+export { buildPreloadSignature, getLoaderView, getRenderablesSignature, orchestratePlayerElementPreload, preloadPlayerElements, type PlayerPreloadState, } from '../components/shared/player-preload.js';
+//# sourceMappingURL=player-preload.d.ts.map