payload-live-preview 1.0.0

package/dist/index.js

@@ -0,0 +1,4040 @@
+// package.json
+var package_default = {
+  version: "1.0.0"};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+// src/core/cache.ts
+var FIELD_ATTRIBUTE = "data-payload-field";
+var TYPE_ATTRIBUTE = "data-payload-type";
+var TARGET_ATTRIBUTE_ATTRIBUTE = "data-payload-attribute";
+var HREF_ATTRIBUTE = "data-payload-href";
+var SRC_ATTRIBUTE = "data-payload-src";
+var ALT_ATTRIBUTE = "data-payload-alt";
+var ARRAY_TEMPLATE_ATTRIBUTE = "data-payload-array-template";
+var ARRAY_SEPARATOR_ATTRIBUTE = "data-payload-array-separator";
+var LOCALE_ATTRIBUTE = "data-payload-locale";
+var FIELD_SELECTOR = `[${FIELD_ATTRIBUTE}]`;
+var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "richText",
+  "email",
+  "number",
+  "checkbox",
+  "date",
+  "select",
+  "radio",
+  "array",
+  "blocks",
+  "group",
+  "tabs",
+  "row",
+  "collapsible",
+  "relationship",
+  "upload",
+  "point",
+  "json",
+  "code",
+  "ui",
+  "html",
+  "url",
+  "image",
+  "structural-array"
+]);
+var ElementCache = class {
+  #entries = /* @__PURE__ */ new Map();
+  #elementToEntry = /* @__PURE__ */ new WeakMap();
+  #filter;
+  constructor(options = {}) {
+    this.#filter = options.filter ?? alwaysTrue;
+  }
+  /**
+   * Rebuild the cache from `root`'s descendants. Pre-existing entries
+   * are discarded. Returns build statistics so callers can emit
+   * cache-refresh events with the durations populated.
+   */
+  buildFromRoot(root) {
+    const t0 = performance.now();
+    this.#entries.clear();
+    const elements = root.querySelectorAll(FIELD_SELECTOR);
+    let elementCount = 0;
+    for (const element of elements) {
+      if (!this.#filter(element)) continue;
+      const entry = this.#resolveBinding(element);
+      if (!entry) continue;
+      this.#append(entry);
+      this.#elementToEntry.set(element, entry);
+      elementCount += 1;
+    }
+    return {
+      elementCount,
+      fieldCount: this.#entries.size,
+      durationMs: performance.now() - t0
+    };
+  }
+  /**
+   * Insert a single element into the cache, returning the new entry
+   * (or `undefined` if the element does not declare a valid binding).
+   */
+  add(element) {
+    if (!this.#filter(element)) return void 0;
+    const entry = this.#resolveBinding(element);
+    if (!entry) return void 0;
+    this.#append(entry);
+    this.#elementToEntry.set(element, entry);
+    return entry;
+  }
+  /**
+   * Remove the entry bound to `element`, if any. Returns `true` when a
+   * binding was actually removed.
+   */
+  remove(element) {
+    const entry = this.#elementToEntry.get(element);
+    if (!entry) return false;
+    this.#elementToEntry.delete(element);
+    const bucket = this.#entries.get(entry.fieldName);
+    if (!bucket) return false;
+    const index = bucket.indexOf(entry);
+    if (index < 0) return false;
+    bucket.splice(index, 1);
+    if (bucket.length === 0) this.#entries.delete(entry.fieldName);
+    return true;
+  }
+  /** Returns the cached bindings for `fieldName`, or `undefined`. */
+  get(fieldName) {
+    return this.#entries.get(fieldName);
+  }
+  /** Returns the cache entry for `element`, or `undefined`. */
+  getByElement(element) {
+    return this.#elementToEntry.get(element);
+  }
+  /** Number of distinct field names currently cached. */
+  get fieldCount() {
+    return this.#entries.size;
+  }
+  /** Total number of cached element bindings. */
+  get elementCount() {
+    let count = 0;
+    for (const bucket of this.#entries.values()) count += bucket.length;
+    return count;
+  }
+  /** Iterate `[fieldName, bindings]` pairs. */
+  entries() {
+    return this.#entries.entries();
+  }
+  /** Iterate every cached binding. */
+  *values() {
+    for (const bucket of this.#entries.values()) yield* bucket;
+  }
+  /** Test whether `element` is registered with the cache. */
+  has(element) {
+    return this.#elementToEntry.has(element);
+  }
+  /** Remove every entry. */
+  clear() {
+    this.#entries.clear();
+  }
+  #append(entry) {
+    const bucket = this.#entries.get(entry.fieldName);
+    if (bucket) {
+      bucket.push(entry);
+      return;
+    }
+    this.#entries.set(entry.fieldName, [entry]);
+  }
+  #resolveBinding(element) {
+    const fieldName = element.getAttribute(FIELD_ATTRIBUTE);
+    if (fieldName === null || fieldName.length === 0) return void 0;
+    const explicit = element.getAttribute(TYPE_ATTRIBUTE);
+    const fieldType = resolveFieldType(element);
+    const targetAttribute = element.getAttribute(TARGET_ATTRIBUTE_ATTRIBUTE);
+    const hrefField = element.getAttribute(HREF_ATTRIBUTE);
+    const srcField = element.getAttribute(SRC_ATTRIBUTE);
+    const altField = element.getAttribute(ALT_ATTRIBUTE);
+    const arrayTemplate = element.getAttribute(ARRAY_TEMPLATE_ATTRIBUTE);
+    const arraySeparator = element.getAttribute(ARRAY_SEPARATOR_ATTRIBUTE);
+    const locale = element.getAttribute(LOCALE_ATTRIBUTE);
+    const entry = {
+      element,
+      fieldName,
+      fieldType,
+      explicitFieldType: explicit !== null && VALID_FIELD_TYPES.has(explicit),
+      ...targetAttribute !== null && targetAttribute.length > 0 ? { targetAttribute } : {},
+      ...hrefField !== null ? { hrefField } : {},
+      ...srcField !== null ? { srcField } : {},
+      ...altField !== null ? { altField } : {},
+      ...arrayTemplate !== null ? { arrayTemplate } : {},
+      ...arraySeparator !== null ? { arraySeparator } : {},
+      ...locale !== null ? { locale } : {}
+    };
+    return entry;
+  }
+};
+function resolveFieldType(element) {
+  const explicit = element.getAttribute(TYPE_ATTRIBUTE);
+  if (explicit !== null && VALID_FIELD_TYPES.has(explicit)) {
+    return explicit;
+  }
+  if (element.hasAttribute("data-payload-richtext")) return "richText";
+  if (element.hasAttribute("data-payload-html")) return "html";
+  if (element.hasAttribute("data-payload-structural")) return "structural-array";
+  if (element.hasAttribute("data-payload-array")) return "array";
+  if (element.tagName === "IMG") return "image";
+  if (element.tagName === "A") return "url";
+  if (element.tagName === "TIME") return "date";
+  if (element.tagName === "INPUT") {
+    const inputType = element.type;
+    if (inputType === "checkbox") return "checkbox";
+    if (inputType === "number") return "number";
+    if (inputType === "date" || inputType === "datetime-local") return "date";
+  }
+  return "text";
+}
+function alwaysTrue() {
+  return true;
+}
+
+// src/core/observers.ts
+var DEFAULT_DEBOUNCE_MS = 100;
+var DEFAULT_ROOT_MARGIN = "200px";
+var ObserverManager = class {
+  #callbacks;
+  #debounceMs;
+  #rootMargin;
+  #visible = /* @__PURE__ */ new Set();
+  #mutation = null;
+  #intersection = null;
+  #debounceTimer = null;
+  constructor(callbacks, options = {}) {
+    this.#callbacks = callbacks;
+    this.#debounceMs = options.mutationDebounceMs ?? DEFAULT_DEBOUNCE_MS;
+    this.#rootMargin = options.intersectionRootMargin ?? DEFAULT_ROOT_MARGIN;
+  }
+  /** Begin observing `root` for mutations and create the intersection observer. */
+  start(root) {
+    this.#mutation = new MutationObserver((mutations) => {
+      this.#handleMutations(mutations);
+    });
+    this.#mutation.observe(root, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: [FIELD_ATTRIBUTE]
+    });
+    this.#intersection = new IntersectionObserver(
+      (entries) => {
+        this.#handleIntersection(entries);
+      },
+      { rootMargin: this.#rootMargin, threshold: 0 }
+    );
+  }
+  /** Add an element to the intersection observer. */
+  observeElement(element) {
+    this.#intersection?.observe(element);
+  }
+  /** Remove an element from the intersection observer. */
+  unobserveElement(element) {
+    this.#intersection?.unobserve(element);
+    this.#visible.delete(element);
+  }
+  /** Mark an element as currently visible. Useful for tests/seeding. */
+  markVisible(element, visible) {
+    if (visible) this.#visible.add(element);
+    else this.#visible.delete(element);
+  }
+  /** Is `element` currently within the (margined) viewport? */
+  isVisible(element) {
+    return this.#visible.has(element);
+  }
+  /** Disconnect all observers and clear pending timers. */
+  stop() {
+    if (this.#debounceTimer !== null) {
+      clearTimeout(this.#debounceTimer);
+      this.#debounceTimer = null;
+    }
+    this.#mutation?.disconnect();
+    this.#intersection?.disconnect();
+    this.#mutation = null;
+    this.#intersection = null;
+    this.#visible.clear();
+  }
+  #handleMutations(mutations) {
+    if (!hasStructuralImpact(mutations)) return;
+    if (this.#debounceTimer !== null) clearTimeout(this.#debounceTimer);
+    this.#debounceTimer = setTimeout(() => {
+      this.#debounceTimer = null;
+      this.#callbacks.onStructuralChange();
+    }, this.#debounceMs);
+  }
+  #handleIntersection(entries) {
+    for (const entry of entries) {
+      const target = entry.target;
+      if (entry.isIntersecting) {
+        if (!this.#visible.has(target)) {
+          this.#visible.add(target);
+          this.#callbacks.onVisibilityChange(target, true);
+        }
+      } else if (this.#visible.has(target)) {
+        this.#visible.delete(target);
+        this.#callbacks.onVisibilityChange(target, false);
+      }
+    }
+  }
+};
+function hasStructuralImpact(mutations) {
+  for (const m of mutations) {
+    if (m.type === "attributes" && m.attributeName === FIELD_ATTRIBUTE) return true;
+    for (const node of m.addedNodes) {
+      if (containsTrackedElement(node)) return true;
+    }
+    for (const node of m.removedNodes) {
+      if (containsTrackedElement(node)) return true;
+    }
+  }
+  return false;
+}
+function containsTrackedElement(node) {
+  if (node.nodeType !== Node.ELEMENT_NODE) return false;
+  const element = node;
+  if (element.hasAttribute(FIELD_ATTRIBUTE)) return true;
+  return element.querySelector(`[${FIELD_ATTRIBUTE}]`) !== null;
+}
+
+// src/core/protocol-version.ts
+var LIBRARY_PROTOCOL_VERSION = 4;
+var CAPABILITY_REQUIREMENTS = {
+  basic: 1,
+  "schema-json": 2,
+  "preview-token": 3,
+  "nested-arrays": 4,
+  "recursive-diffs": 4
+};
+function negotiateProtocol(theirs) {
+  const sanitisedTheirs = typeof theirs === "number" && Number.isFinite(theirs) && theirs >= 1 ? Math.floor(theirs) : void 0;
+  const effectiveTheirs = sanitisedTheirs ?? 1;
+  const negotiated = Math.min(LIBRARY_PROTOCOL_VERSION, effectiveTheirs);
+  const capabilities = /* @__PURE__ */ new Set();
+  for (const [flag, minVersion] of Object.entries(CAPABILITY_REQUIREMENTS)) {
+    if (negotiated >= minVersion) capabilities.add(flag);
+  }
+  return {
+    ours: LIBRARY_PROTOCOL_VERSION,
+    ...sanitisedTheirs !== void 0 ? { theirs: sanitisedTheirs } : { theirs: void 0 },
+    negotiated,
+    capabilities
+  };
+}
+function hasCapability(negotiation, capability) {
+  return negotiation.capabilities.has(capability);
+}
+
+// src/core/message-bus.ts
+var MessageBus = class {
+  #matcher;
+  #handlers;
+  #boundListener;
+  #attached = false;
+  constructor(matcher, handlers) {
+    this.#matcher = matcher;
+    this.#handlers = handlers;
+    this.#boundListener = (event) => {
+      this.#receive(event);
+    };
+  }
+  /** Begin listening for window-level `message` events. Idempotent. */
+  attach(target = window) {
+    if (this.#attached) return;
+    target.addEventListener("message", this.#boundListener);
+    this.#attached = true;
+  }
+  /** Stop listening. Idempotent. */
+  detach(target = window) {
+    if (!this.#attached) return;
+    target.removeEventListener("message", this.#boundListener);
+    this.#attached = false;
+  }
+  /**
+   * Send a `ready` handshake message to one or more parent windows.
+   *
+   * `targets` are the windows to notify (parent and/or opener). For
+   * each target the message is sent to every `origin` so the Payload
+   * admin in the parent receives it regardless of which origin it
+   * happens to be served on.
+   */
+  static sendReady(targets, origins) {
+    if (targets.length === 0 || origins.length === 0) return;
+    const payload = {
+      type: "payload-live-preview",
+      ready: true,
+      protocolVersion: LIBRARY_PROTOCOL_VERSION
+    };
+    for (const target of targets) {
+      for (const origin of origins) {
+        try {
+          target.postMessage(payload, origin);
+        } catch {
+        }
+      }
+    }
+  }
+  #receive(event) {
+    const origin = event.origin;
+    if (!this.#matcher(origin)) {
+      this.#handlers.onInvalid?.("origin", origin);
+      return;
+    }
+    const data = event.data;
+    if (!isObjectMessage(data)) {
+      this.#handlers.onInvalid?.("shape", origin);
+      return;
+    }
+    switch (data.type) {
+      case "payload-live-preview":
+        this.#dispatchUpdate(data, origin);
+        return;
+      case "payload-document-event":
+        this.#handlers.onDocumentEvent(data, origin);
+        return;
+      default:
+        this.#handlers.onInvalid?.("type", origin);
+    }
+  }
+  #dispatchUpdate(message, origin) {
+    const validator = this.#handlers.validateToken;
+    if (validator === void 0) {
+      this.#handlers.onUpdate(message, origin);
+      return;
+    }
+    if (message.ready === true && message.data === void 0) {
+      this.#handlers.onUpdate(message, origin);
+      return;
+    }
+    let approved;
+    try {
+      approved = validator(message.previewToken, origin);
+    } catch {
+      this.#handlers.onInvalid?.("token", origin);
+      return;
+    }
+    if (typeof approved === "boolean") {
+      if (approved) this.#handlers.onUpdate(message, origin);
+      else this.#handlers.onInvalid?.("token", origin);
+      return;
+    }
+    void approved.then(
+      (ok) => {
+        if (ok) this.#handlers.onUpdate(message, origin);
+        else this.#handlers.onInvalid?.("token", origin);
+      },
+      () => {
+        this.#handlers.onInvalid?.("token", origin);
+      }
+    );
+  }
+};
+function isObjectMessage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("type" in value)) return false;
+  return typeof value.type === "string";
+}
+
+// src/core/state.ts
+var DEFAULT_TIMEOUT_MS = 0;
+var HeartbeatTimer = class {
+  #timeoutMs;
+  #onTimeout;
+  #handle = null;
+  #lastKick = 0;
+  constructor(options) {
+    this.#timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.#onTimeout = options.onTimeout;
+  }
+  /** Reset the timer. Schedules `onTimeout` after `timeoutMs`. */
+  kick() {
+    this.#lastKick = Date.now();
+    if (this.#timeoutMs <= 0) return;
+    if (this.#handle !== null) clearTimeout(this.#handle);
+    this.#handle = setTimeout(() => {
+      this.#handle = null;
+      this.#onTimeout();
+    }, this.#timeoutMs);
+  }
+  /** Cancel any pending timeout. Safe to call repeatedly. */
+  stop() {
+    if (this.#handle === null) return;
+    clearTimeout(this.#handle);
+    this.#handle = null;
+  }
+  /** Test introspection: timestamp of the most recent kick (ms epoch). */
+  get lastKickAt() {
+    return this.#lastKick;
+  }
+  /** Test introspection: is a timeout currently scheduled? */
+  get pending() {
+    return this.#handle !== null;
+  }
+};
+var ConnectionState = class {
+  #status = "disconnected";
+  #onChange;
+  constructor(onChange) {
+    this.#onChange = onChange;
+  }
+  get status() {
+    return this.#status;
+  }
+  /** Mark as `connected`; idempotent. Returns true if state transitioned. */
+  markConnected() {
+    return this.#transition("connected");
+  }
+  /** Mark as `connecting`; idempotent. */
+  markConnecting() {
+    return this.#transition("connecting");
+  }
+  /** Mark as `disconnected`; idempotent. */
+  markDisconnected() {
+    return this.#transition("disconnected");
+  }
+  #transition(next) {
+    if (this.#status === next) return false;
+    const previous = this.#status;
+    this.#status = next;
+    this.#onChange(next, previous);
+    return true;
+  }
+};
+
+// src/core/data-merger.ts
+var noop = () => void 0;
+var DataMerger = class {
+  #serverURL;
+  #apiRoute;
+  #depth;
+  #fetchFn;
+  #log;
+  #inflight = null;
+  constructor(options) {
+    this.#serverURL = options.serverURL.replace(/\/+$/, "");
+    const route = options.apiRoute ?? "/api";
+    this.#apiRoute = route.startsWith("/") ? route : `/${route}`;
+    this.#depth = options.depth ?? 1;
+    this.#fetchFn = options.fetchFn;
+    this.#log = options.log ?? noop;
+  }
+  /**
+   * Whether this message can be merged at all: collections need an
+   * `id` in the form values (the admin always includes one), globals
+   * only need their slug.
+   */
+  canMerge(request) {
+    if (request.globalSlug !== void 0 && request.globalSlug !== "") return true;
+    if (request.collectionSlug === void 0 || request.collectionSlug === "") return false;
+    const id = request.data["id"];
+    return typeof id === "string" || typeof id === "number";
+  }
+  /**
+   * Merge raw form values into the stored document via the Payload
+   * REST API. See {@link MergeResult} for the outcome semantics.
+   */
+  async merge(request) {
+    if (!this.canMerge(request)) return { status: "unavailable" };
+    const fetchFn = this.#fetchFn ?? (typeof fetch === "function" ? fetch : void 0);
+    if (fetchFn === void 0) return { status: "unavailable" };
+    this.#inflight?.abort();
+    const controller = new AbortController();
+    this.#inflight = controller;
+    const endpoint = request.globalSlug !== void 0 && request.globalSlug !== "" ? `globals/${request.globalSlug}` : `${request.collectionSlug}/${String(request.data["id"])}`;
+    const url = `${this.#serverURL}${this.#apiRoute}/${encodeURI(endpoint)}`;
+    try {
+      const response = await fetchFn(url, {
+        method: "POST",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/json",
+          // Payload's REST layer treats this POST as a GET with a body:
+          // the body's `data` is merged into the stored document and the
+          // populated result is returned.
+          "X-Payload-HTTP-Method-Override": "GET"
+        },
+        body: JSON.stringify({
+          data: request.data,
+          depth: this.#depth,
+          // The admin already flattens locales before posting.
+          flattenLocales: false,
+          ...request.locale !== void 0 ? { locale: request.locale } : {}
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        this.#log("merge fetch failed", response.status, url);
+        return { status: "unavailable" };
+      }
+      const merged = await response.json();
+      if (merged === null || typeof merged !== "object" || Array.isArray(merged)) {
+        this.#log("merge fetch returned non-object", url);
+        return { status: "unavailable" };
+      }
+      return { status: "merged", doc: merged };
+    } catch (error) {
+      if (controller.signal.aborted) return { status: "superseded" };
+      this.#log("merge fetch error", error);
+      return { status: "unavailable" };
+    } finally {
+      if (this.#inflight === controller) this.#inflight = null;
+    }
+  }
+  /** Abort any in-flight merge request. */
+  destroy() {
+    this.#inflight?.abort();
+    this.#inflight = null;
+  }
+};
+
+// src/security/url-validator.ts
+var SAFE_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:"]);
+var DANGEROUS_PROTOCOL_PATTERN = /^\s*(?:javascript|data|vbscript|file|blob|about)\s*:/i;
+var RELATIVE_PATH = /^(?:\.{1,2}\/|[a-zA-Z0-9_-]+\/?)/;
+function isSafeUrl(url) {
+  if (typeof url !== "string" || url.length === 0) return false;
+  const trimmed = url.trim();
+  if (trimmed.length === 0) return false;
+  if (DANGEROUS_PROTOCOL_PATTERN.test(trimmed)) return false;
+  if (trimmed.startsWith("#") || trimmed.startsWith("?")) return true;
+  if (trimmed.startsWith("//")) return true;
+  if (trimmed.startsWith("/")) return true;
+  try {
+    const parsed = new URL(trimmed);
+    return SAFE_PROTOCOLS.has(parsed.protocol);
+  } catch {
+    return RELATIVE_PATH.test(trimmed);
+  }
+}
+function isExternalHttpUrl(url) {
+  if (!isSafeUrl(url)) return false;
+  const trimmed = url.trim();
+  return /^https?:\/\//i.test(trimmed) || /^\/\/[^/]/.test(trimmed);
+}
+
+// src/core/attribute-binding.ts
+var BLOCKED_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "style",
+  "srcdoc",
+  "formaction",
+  "form",
+  "id",
+  "name",
+  "is",
+  "srcset",
+  "imagesrcset"
+]);
+var URL_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "href",
+  "src",
+  "poster",
+  "cite",
+  "action",
+  "xlink:href",
+  "data"
+]);
+function applyAttributeBinding(element, attribute, value) {
+  const name = attribute.toLowerCase().trim();
+  if (name.length === 0) return "blocked";
+  if (name.startsWith("on")) return "blocked";
+  if (BLOCKED_ATTRIBUTES.has(name)) return "blocked";
+  if (value === null || value === void 0) {
+    element.removeAttribute(name);
+    return "applied";
+  }
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    return "blocked";
+  }
+  const stringValue = String(value);
+  if (URL_ATTRIBUTES.has(name) && !isSafeUrl(stringValue)) return "blocked";
+  element.setAttribute(name, stringValue);
+  return "applied";
+}
+
+// src/core/update-scheduler.ts
+var DEFAULT_DEBOUNCE_MS2 = 50;
+var DEFAULT_VISIBILITY_THRESHOLD = 50;
+var UpdateScheduler = class {
+  #apply;
+  #debounceMs;
+  #isVisible;
+  #gateThreshold;
+  #gateDisabled;
+  #getCacheSize;
+  #onFlush;
+  #scheduleFrame;
+  #cancelFrame;
+  /** Per-element latest pending value, applied on next flush. */
+  #pending = /* @__PURE__ */ new Map();
+  /** Per-element value to apply when element becomes visible. */
+  #replay = /* @__PURE__ */ new Map();
+  #debounceTimer = null;
+  #frameHandle = null;
+  constructor(apply, options) {
+    this.#apply = apply;
+    this.#debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS2;
+    this.#isVisible = options.isVisible;
+    this.#gateThreshold = options.visibilityGateThreshold ?? DEFAULT_VISIBILITY_THRESHOLD;
+    this.#gateDisabled = options.disableVisibilityGate ?? false;
+    this.#getCacheSize = options.getCacheSize;
+    this.#onFlush = options.onFlush;
+    this.#scheduleFrame = options.scheduleFrame ?? (typeof requestAnimationFrame === "function" ? requestAnimationFrame.bind(globalThis) : (cb) => {
+      return setTimeout(() => {
+        cb(performance.now());
+      }, 0);
+    });
+    this.#cancelFrame = options.cancelFrame ?? (typeof cancelAnimationFrame === "function" ? cancelAnimationFrame.bind(globalThis) : (handle) => {
+      clearTimeout(handle);
+    });
+  }
+  /**
+   * Queue an update. The same `(element)` pair is coalesced — only the
+   * most-recent value survives until the next flush.
+   */
+  schedule(update) {
+    const existing = this.#pending.get(update.target.element);
+    if (existing) {
+      existing.value = update.value;
+      existing.allFields = update.allFields;
+    } else {
+      this.#pending.set(update.target.element, {
+        target: update.target,
+        value: update.value,
+        allFields: update.allFields
+      });
+    }
+    this.#armDebounce();
+  }
+  /**
+   * Flush every pending write immediately, bypassing the debounce.
+   * Useful for tests and for `destroy()` to drain in-flight work.
+   */
+  flushNow() {
+    if (this.#debounceTimer !== null) {
+      clearTimeout(this.#debounceTimer);
+      this.#debounceTimer = null;
+    }
+    return this.#flush();
+  }
+  /**
+   * Signal that an element has become visible. Any buffered value for
+   * that element is applied immediately.
+   */
+  notifyVisible(element) {
+    const entry = this.#replay.get(element);
+    if (!entry) return;
+    this.#replay.delete(element);
+    this.#apply(entry);
+  }
+  /**
+   * Discard any replay state for an element. Called when the element
+   * leaves the cache.
+   */
+  forget(element) {
+    this.#pending.delete(element);
+    this.#replay.delete(element);
+  }
+  /** Cancel timers and drop buffered state. */
+  destroy() {
+    if (this.#debounceTimer !== null) {
+      clearTimeout(this.#debounceTimer);
+      this.#debounceTimer = null;
+    }
+    if (this.#frameHandle !== null) {
+      this.#cancelFrame(this.#frameHandle);
+      this.#frameHandle = null;
+    }
+    this.#pending.clear();
+    this.#replay.clear();
+  }
+  /** Test introspection: number of pending writes. */
+  get pendingCount() {
+    return this.#pending.size;
+  }
+  /** Test introspection: number of buffered offscreen replays. */
+  get replayCount() {
+    return this.#replay.size;
+  }
+  #armDebounce() {
+    if (this.#debounceTimer !== null) clearTimeout(this.#debounceTimer);
+    this.#debounceTimer = setTimeout(() => {
+      this.#debounceTimer = null;
+      this.#requestFrame();
+    }, this.#debounceMs);
+  }
+  #requestFrame() {
+    if (this.#frameHandle !== null) this.#cancelFrame(this.#frameHandle);
+    this.#frameHandle = this.#scheduleFrame(() => {
+      this.#frameHandle = null;
+      this.#flush();
+    });
+  }
+  #flush() {
+    const t0 = performance.now();
+    const gateActive = !this.#gateDisabled && this.#getCacheSize() > this.#gateThreshold;
+    const pending = this.#pending;
+    this.#pending = /* @__PURE__ */ new Map();
+    let applied = 0;
+    let deferred = 0;
+    for (const entry of pending.values()) {
+      if (gateActive && !this.#isVisible(entry.target.element)) {
+        this.#replay.set(entry.target.element, entry);
+        deferred += 1;
+        continue;
+      }
+      this.#apply(entry);
+      applied += 1;
+    }
+    const stats = {
+      applied,
+      deferred,
+      durationMs: performance.now() - t0
+    };
+    this.#onFlush?.(stats);
+    return stats;
+  }
+};
+
+// src/detection/locale.ts
+var FALLBACK_LOCALE = "en";
+function detectInitialLocale() {
+  const fromHtml = readHtmlLang();
+  if (fromHtml !== void 0) return fromHtml;
+  const fromNavigator = readNavigatorLanguage();
+  if (fromNavigator !== void 0) return fromNavigator;
+  return FALLBACK_LOCALE;
+}
+function readHtmlLang() {
+  if (typeof document === "undefined") return void 0;
+  const lang = document.documentElement.getAttribute("lang");
+  return lang === null || lang.length === 0 ? void 0 : lang;
+}
+function readNavigatorLanguage() {
+  if (typeof navigator === "undefined") return void 0;
+  const lang = navigator.language;
+  return typeof lang === "string" && lang.length > 0 ? lang : void 0;
+}
+
+// src/core/a11y.ts
+var ELEMENT_ID = "payload-live-preview-a11y";
+var CLEAR_DELAY_MS = 1500;
+var STYLE = [
+  "position:absolute",
+  "width:1px",
+  "height:1px",
+  "padding:0",
+  "margin:-1px",
+  "overflow:hidden",
+  "clip:rect(0 0 0 0)",
+  "clip-path:inset(50%)",
+  "white-space:nowrap",
+  "border:0"
+].join(";");
+var FALLBACK_STRINGS = {
+  connected: "Live preview connected",
+  disconnected: "Live preview disconnected",
+  updated: (n) => `${String(n)} ${n === 1 ? "change" : "changes"} applied`
+};
+var STRINGS = {
+  en: FALLBACK_STRINGS,
+  de: {
+    connected: "Vorschau verbunden",
+    disconnected: "Vorschau getrennt",
+    updated: (n) => `${String(n)} ${n === 1 ? "\xC4nderung" : "\xC4nderungen"} angewendet`
+  }
+};
+function resolveStrings(locale) {
+  const lang = locale.split(/[-_]/)[0]?.toLowerCase() ?? "en";
+  return STRINGS[lang] ?? FALLBACK_STRINGS;
+}
+var A11yAnnouncer = class {
+  #element = null;
+  #strings;
+  #clearTimer = null;
+  constructor(locale = detectInitialLocale()) {
+    this.#strings = resolveStrings(locale);
+  }
+  /**
+   * Create (or adopt) the shared live-region element. Returns `null`
+   * when no DOM is available yet — announcements are then dropped,
+   * which is fine: they are progress niceties, not state.
+   */
+  #mount() {
+    if (this.#element !== null && this.#element.isConnected) return this.#element;
+    if (typeof document === "undefined" || document.body === null) {
+      return null;
+    }
+    let element = document.getElementById(ELEMENT_ID);
+    if (!element) {
+      element = document.createElement("div");
+      element.id = ELEMENT_ID;
+      element.setAttribute("role", "status");
+      element.setAttribute("aria-live", "polite");
+      element.setAttribute("aria-atomic", "true");
+      element.setAttribute("style", STYLE);
+      document.body.appendChild(element);
+    }
+    this.#element = element;
+    return element;
+  }
+  /** Announce that the preview successfully connected. */
+  announceConnected() {
+    this.#say(this.#strings.connected);
+  }
+  /** Announce that the preview lost its connection. */
+  announceDisconnected() {
+    this.#say(this.#strings.disconnected);
+  }
+  /** Announce that `count` updates were applied. */
+  announceUpdate(count) {
+    if (count <= 0) return;
+    this.#say(this.#strings.updated(count));
+  }
+  /**
+   * Remove the live region from the document. Called by the runtime
+   * during `destroy()`. Idempotent.
+   */
+  detach() {
+    if (this.#clearTimer !== null) {
+      clearTimeout(this.#clearTimer);
+      this.#clearTimer = null;
+    }
+    if (this.#element?.parentNode) {
+      this.#element.parentNode.removeChild(this.#element);
+    }
+  }
+  #say(message) {
+    const element = this.#mount();
+    if (!element) return;
+    element.textContent = message;
+    if (this.#clearTimer !== null) clearTimeout(this.#clearTimer);
+    this.#clearTimer = setTimeout(() => {
+      this.#clearTimer = null;
+      if (this.#element) this.#element.textContent = "";
+    }, CLEAR_DELAY_MS);
+  }
+};
+
+// src/schema/walker.ts
+var STRUCTURAL_TYPES = /* @__PURE__ */ new Set([
+  "tabs",
+  "row",
+  "collapsible"
+]);
+function buildSchemaIndex(schemas, basePath = "") {
+  const out = /* @__PURE__ */ new Map();
+  walk(schemas, basePath, out);
+  return out;
+}
+function walk(schemas, basePath, out) {
+  for (const schema of schemas) {
+    if (STRUCTURAL_TYPES.has(schema.type)) {
+      if (schema.fields) walk(schema.fields, basePath, out);
+      continue;
+    }
+    if (schema.type === "group") {
+      const path2 = basePath === "" ? schema.name : `${basePath}.${schema.name}`;
+      out.set(path2, schema);
+      if (schema.fields) walk(schema.fields, path2, out);
+      continue;
+    }
+    const path = basePath === "" ? schema.name : `${basePath}.${schema.name}`;
+    out.set(path, schema);
+    if (schema.type === "array" && schema.fields) {
+      walk(schema.fields, `${path}.*`, out);
+    } else if (schema.type === "blocks" && schema.blocks) {
+      for (const block of schema.blocks) {
+        walk(block.fields, `${path}.*.${block.slug}`, out);
+      }
+    }
+  }
+}
+function lookupSchema(index, fieldPath) {
+  if (index.has(fieldPath)) return index.get(fieldPath);
+  const wildcardPath = fieldPath.replace(/\.\d+(?=\.|$)/g, ".*");
+  if (index.has(wildcardPath)) return index.get(wildcardPath);
+  return void 0;
+}
+
+// src/schema/diff.ts
+function getId(item) {
+  if (typeof item !== "object" || item === null) return void 0;
+  const id = item["id"];
+  if (typeof id === "string" || typeof id === "number") return id;
+  return void 0;
+}
+function getBlockType(item) {
+  if (typeof item !== "object" || item === null) return void 0;
+  const blockType = item["blockType"];
+  return typeof blockType === "string" ? blockType : void 0;
+}
+function diffArray(prev, next) {
+  const haveIds = next.every((item) => getId(item) !== void 0);
+  if (haveIds) return diffById(prev, next);
+  return diffByPosition(prev, next);
+}
+function diffById(prev, next) {
+  const patches = [];
+  const prevIndexById = /* @__PURE__ */ new Map();
+  for (let i = 0; i < prev.length; i += 1) {
+    const id = getId(prev[i]);
+    if (id !== void 0) prevIndexById.set(id, i);
+  }
+  const consumedFromPrev = /* @__PURE__ */ new Set();
+  for (let to = 0; to < next.length; to += 1) {
+    const item = next[to];
+    const id = getId(item);
+    if (id === void 0) {
+      patches.push({ kind: "insert", index: to, value: item });
+      continue;
+    }
+    const from = prevIndexById.get(id);
+    if (from === void 0) {
+      patches.push({ kind: "insert", index: to, value: item });
+      continue;
+    }
+    consumedFromPrev.add(from);
+    const prevItem = prev[from];
+    if (getBlockType(prevItem) !== getBlockType(item)) {
+      patches.push({ kind: "replace", index: to, oldValue: prevItem, value: item });
+      continue;
+    }
+    if (from !== to) {
+      patches.push({ kind: "move", from, to, value: item });
+    }
+    if (!shallowEqual(prevItem, item)) {
+      patches.push({ kind: "update", index: to, value: item });
+    }
+  }
+  for (let i = 0; i < prev.length; i += 1) {
+    if (consumedFromPrev.has(i)) continue;
+    patches.push({ kind: "remove", index: i, value: prev[i] });
+  }
+  return patches;
+}
+function diffByPosition(prev, next) {
+  const patches = [];
+  const min = Math.min(prev.length, next.length);
+  for (let i = 0; i < min; i += 1) {
+    if (!shallowEqual(prev[i], next[i])) {
+      patches.push({ kind: "update", index: i, value: next[i] });
+    }
+  }
+  if (next.length > prev.length) {
+    for (let i = prev.length; i < next.length; i += 1) {
+      patches.push({ kind: "insert", index: i, value: next[i] });
+    }
+  }
+  if (prev.length > next.length) {
+    for (let i = next.length; i < prev.length; i += 1) {
+      patches.push({ kind: "remove", index: i, value: prev[i] });
+    }
+  }
+  return patches;
+}
+function shallowEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const aRec = a;
+  const bRec = b;
+  const aKeys = Object.keys(aRec);
+  const bKeys = Object.keys(bRec);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (!Object.is(aRec[key], bRec[key])) return false;
+  }
+  return true;
+}
+
+// src/schema/field-type-map.ts
+var MAP = {
+  text: "text",
+  textarea: "textarea",
+  richText: "richText",
+  email: "email",
+  number: "number",
+  checkbox: "checkbox",
+  date: "date",
+  select: "select",
+  radio: "radio",
+  array: "array",
+  blocks: "blocks",
+  group: "text",
+  // group itself has no display; bound element shows nothing useful
+  tabs: "text",
+  // structural — walker should have stripped this
+  row: "text",
+  collapsible: "text",
+  relationship: "relationship",
+  upload: "upload",
+  point: "text",
+  json: "text",
+  code: "text",
+  ui: "text"
+};
+function payloadTypeToRenderer(type) {
+  if (Object.prototype.hasOwnProperty.call(MAP, type)) {
+    return MAP[type];
+  }
+  return void 0;
+}
+
+// src/core/lifecycle.ts
+var READY_RETRY_DELAYS_MS = [0, 500, 1e3, 2e3];
+var LivePreviewRuntime = class {
+  #emitter;
+  #cache;
+  #observers;
+  #scheduler;
+  #bus;
+  #state;
+  #heartbeat;
+  #renderers;
+  #root;
+  #readyTargets;
+  #sendReady;
+  #onHeartbeatTimeoutHook;
+  #log;
+  #warn;
+  #readyTimers = [];
+  #a11y;
+  #merger;
+  #currentLocale;
+  #currentSchema;
+  #schemaIndex;
+  #protocolNegotiation = negotiateProtocol(void 0);
+  #started = false;
+  #deferredStart = null;
+  #updateCount = 0;
+  /**
+   * Field names we've already warned about as "orphan updates" — updates
+   * arrived for them but no `[data-payload-field=…]` anchor exists.
+   * Set-membership prevents the diagnostic from spamming the console
+   * during continuous editing.
+   */
+  #warnedOrphanFields = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.#emitter = options.emitter;
+    this.#renderers = options.renderers;
+    this.#root = options.root ?? (typeof document !== "undefined" ? document : null);
+    this.#readyTargets = options.readyTargets;
+    this.#sendReady = options.sendReady ?? defaultSendReady;
+    this.#onHeartbeatTimeoutHook = options.onHeartbeatTimeout;
+    this.#log = options.log ?? noopLogger;
+    this.#warn = options.warn ?? defaultWarn;
+    this.#a11y = createA11y(options);
+    this.#merger = options.dataMerge !== void 0 ? new DataMerger({
+      serverURL: options.dataMerge.serverURL,
+      ...options.dataMerge.apiRoute !== void 0 ? { apiRoute: options.dataMerge.apiRoute } : {},
+      ...options.dataMerge.depth !== void 0 ? { depth: options.dataMerge.depth } : {},
+      ...options.dataMerge.fetchFn !== void 0 ? { fetchFn: options.dataMerge.fetchFn } : {},
+      log: (...args) => {
+        this.#log(...args);
+      }
+    }) : null;
+    this.#cache = new ElementCache();
+    this.#observers = new ObserverManager(
+      {
+        onStructuralChange: () => {
+          this.#rebuildCache();
+        },
+        onVisibilityChange: (element, visible) => {
+          if (visible) this.#scheduler.notifyVisible(element);
+        }
+      },
+      {
+        ...options.intersectionRootMargin !== void 0 ? { intersectionRootMargin: options.intersectionRootMargin } : {}
+      }
+    );
+    this.#scheduler = new UpdateScheduler(
+      (update) => {
+        this.#applyUpdate(update);
+      },
+      {
+        ...options.debounceMs !== void 0 ? { debounceMs: options.debounceMs } : {},
+        ...options.disableVisibilityGate !== void 0 ? { disableVisibilityGate: options.disableVisibilityGate } : {},
+        ...options.visibilityGateThreshold !== void 0 ? { visibilityGateThreshold: options.visibilityGateThreshold } : {},
+        isVisible: (element) => this.#observers.isVisible(element),
+        getCacheSize: () => this.#cache.elementCount,
+        onFlush: (stats) => {
+          this.#onFlush(stats);
+        }
+      }
+    );
+    this.#bus = new MessageBus(options.originMatcher, {
+      onUpdate: (msg, origin) => {
+        this.#handleUpdate(msg, origin);
+      },
+      onDocumentEvent: (msg, origin) => {
+        this.#handleDocumentEvent(msg, origin);
+      },
+      onInvalid: (reason, origin) => {
+        if (reason === "token") {
+          const error = new Error(`Preview token rejected (origin: ${origin})`);
+          void this.#emitter.emit("error", { error, context: "token" });
+        }
+        this.#log("message rejected:", reason, origin);
+      },
+      ...options.validateToken !== void 0 ? { validateToken: options.validateToken } : {}
+    });
+    this.#state = new ConnectionState((next, prev) => {
+      this.#log("connection", prev, "\u2192", next);
+    });
+    this.#heartbeat = new HeartbeatTimer({
+      ...options.heartbeatMs !== void 0 ? { timeoutMs: options.heartbeatMs } : {},
+      onTimeout: () => {
+        this.#onHeartbeatTimeout();
+      }
+    });
+  }
+  /**
+   * Start the runtime: build cache, attach observers, listen for
+   * messages, broadcast `ready`. Returns `true` if it actually started
+   * (it will refuse to start a second time).
+   *
+   * When the script executes while the document is still parsing
+   * (e.g. injected via `<script>` in `<head>` — Astro's `head-inline`
+   * stage), `document.body` does not exist yet and attaching the
+   * MutationObserver would throw. In that case the actual startup is
+   * deferred until `DOMContentLoaded`; `start()` still returns `true`
+   * and `destroy()` cancels the pending startup.
+   */
+  start() {
+    if (this.#started) return false;
+    this.#started = true;
+    const root = this.#root;
+    if (root instanceof Document && root.readyState === "loading") {
+      const onReady = () => {
+        this.#deferredStart = null;
+        this.#startNow();
+      };
+      this.#deferredStart = onReady;
+      root.addEventListener("DOMContentLoaded", onReady, { once: true });
+      return true;
+    }
+    this.#startNow();
+    return true;
+  }
+  #startNow() {
+    this.#buildCacheAndObserve();
+    this.#observers.start(this.#root instanceof Document ? this.#root.body : this.#root);
+    this.#bus.attach();
+    this.#emitInit();
+    for (const delay of READY_RETRY_DELAYS_MS) {
+      if (delay === 0) {
+        this.#sendReady(this.#readyTargets);
+      } else {
+        const handle = setTimeout(() => {
+          this.#sendReady(this.#readyTargets);
+        }, delay);
+        this.#readyTimers.push(handle);
+      }
+    }
+  }
+  /** Tear down all observers, timers, and listeners. Idempotent. */
+  destroy() {
+    if (!this.#started) return;
+    this.#started = false;
+    if (this.#deferredStart !== null) {
+      const root = this.#root;
+      if (root instanceof Document) {
+        root.removeEventListener("DOMContentLoaded", this.#deferredStart);
+      }
+      this.#deferredStart = null;
+      void this.#emitter.emit("destroy", { timestamp: Date.now() });
+      return;
+    }
+    for (const handle of this.#readyTimers) clearTimeout(handle);
+    this.#readyTimers.length = 0;
+    this.#heartbeat.stop();
+    this.#bus.detach();
+    this.#observers.stop();
+    this.#scheduler.destroy();
+    this.#merger?.destroy();
+    this.#cache.clear();
+    const wasConnected = this.#state.status === "connected";
+    this.#state.markDisconnected();
+    if (wasConnected) {
+      this.#a11y?.announceDisconnected();
+      void this.#emitter.emit("disconnect", { reason: "destroy", timestamp: Date.now() });
+    }
+    this.#a11y?.detach();
+    void this.#emitter.emit("destroy", { timestamp: Date.now() });
+  }
+  /** Re-scan the DOM and re-register every binding. */
+  refreshCache() {
+    this.#rebuildCache();
+  }
+  /** Current connection status, exposed for the high-level client. */
+  get status() {
+    return this.#state.status;
+  }
+  /** Read-only view of the element cache. */
+  get cache() {
+    return this.#cache;
+  }
+  /** Read-only view of how many updates have been received. */
+  get updateCount() {
+    return this.#updateCount;
+  }
+  /**
+   * Negotiated protocol view — `min(library, remote)`. Useful for
+   * consumers that want to branch on protocol capabilities without
+   * hard-coding version numbers. Updates lazily as the remote party's
+   * version arrives on incoming messages.
+   */
+  get protocol() {
+    return this.#protocolNegotiation;
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+  // Internals
+  // ──────────────────────────────────────────────────────────────────────────
+  #buildCacheAndObserve() {
+    const stats = this.#cache.buildFromRoot(this.#root);
+    this.#log("cache built", stats);
+    void this.#emitter.emit("cacheRefresh", stats);
+    for (const entry of this.#cache.values()) {
+      this.#observers.observeElement(entry.element);
+    }
+  }
+  #rebuildCache() {
+    for (const entry of this.#cache.values()) {
+      this.#observers.unobserveElement(entry.element);
+      this.#scheduler.forget(entry.element);
+    }
+    this.#buildCacheAndObserve();
+  }
+  #emitInit() {
+    void this.#emitter.emit("init", { timestamp: Date.now() });
+  }
+  #applyNegotiation(remoteVersion) {
+    const next = negotiateProtocol(remoteVersion);
+    if (next.negotiated === this.#protocolNegotiation.negotiated) return;
+    this.#protocolNegotiation = next;
+    this.#log(
+      "protocol negotiated",
+      `ours=${LIBRARY_PROTOCOL_VERSION}`,
+      `theirs=${remoteVersion}`,
+      `negotiated=${next.negotiated}`
+    );
+  }
+  #handleUpdate(message, origin) {
+    this.#heartbeat.kick();
+    if (message.protocolVersion !== void 0) {
+      this.#applyNegotiation(message.protocolVersion);
+    }
+    if (message.data === void 0) {
+      return;
+    }
+    if (this.#state.markConnected()) {
+      this.#a11y?.announceConnected();
+      void this.#emitter.emit("connect", { origin, timestamp: Date.now() });
+    }
+    this.#updateCount += 1;
+    if (message.locale !== void 0) this.#currentLocale = message.locale;
+    if (message.fieldSchemaJSON !== void 0) {
+      this.#currentSchema = message.fieldSchemaJSON;
+      this.#schemaIndex = buildSchemaIndex(message.fieldSchemaJSON);
+    }
+    void this.#resolveIncomingFields(message).then((fields) => {
+      if (fields === null) return;
+      const data = {
+        fields,
+        ...this.#currentSchema !== void 0 ? { schema: this.#currentSchema } : {},
+        ...message.globalSlug !== void 0 ? { globalSlug: message.globalSlug } : {},
+        ...message.collectionSlug !== void 0 ? { collectionSlug: message.collectionSlug } : {},
+        ...this.#currentLocale !== void 0 ? { locale: this.#currentLocale } : {}
+      };
+      let cancelled = false;
+      void this.#emitter.emit("beforeUpdate", {
+        data,
+        cancel: () => {
+          cancelled = true;
+        }
+      }).then(() => {
+        if (cancelled) return;
+        this.#scheduleAllFields(data);
+      });
+    });
+  }
+  /**
+   * Resolve the field values to render for an incoming update. With a
+   * configured `DataMerger` the raw form values are exchanged for the
+   * server-populated document; without one (or on failure) the raw
+   * values pass through unchanged. Returns `null` when a newer update
+   * superseded this one mid-flight.
+   */
+  async #resolveIncomingFields(message) {
+    const raw = message.data ?? {};
+    if (this.#merger === null) return raw;
+    const result = await this.#merger.merge({
+      collectionSlug: message.collectionSlug,
+      globalSlug: message.globalSlug,
+      data: raw,
+      locale: this.#currentLocale
+    });
+    if (result.status === "merged") return result.doc;
+    if (result.status === "superseded") return null;
+    return raw;
+  }
+  #handleDocumentEvent(_message, _origin) {
+    void this.#emitter.emit("documentSave", { timestamp: Date.now() });
+  }
+  #scheduleAllFields(data) {
+    for (const [fieldName, bindings] of this.#cache.entries()) {
+      const value = resolveFieldValue(data.fields, fieldName, this.#currentLocale);
+      if (value === void 0) continue;
+      for (const target of bindings) {
+        const update = {
+          target,
+          value,
+          allFields: data.fields
+        };
+        this.#scheduler.schedule(update);
+      }
+    }
+    this.#diagnoseOrphanFields(data.fields);
+  }
+  /**
+   * Walk the incoming `data` payload and warn (via `this.#log`) when an
+   * editable-looking field arrives for which **no `[data-payload-field]`
+   * anchor exists** in the page. This is the most common live-preview
+   * footgun: an SSR template renders the binding only when the field is
+   * non-empty, so editing a previously-empty field has nowhere to land.
+   *
+   * The warning is gated by:
+   *   - `this.#log` being a real logger (no-op when debug disabled)
+   *   - per-field deduplication via `#warnedOrphanFields`
+   *   - scalar value heuristic (objects/arrays don't get warned)
+   *   - a small ignore-list of system fields Payload always ships
+   *
+   * The method intentionally lives on the runtime — not on the cache —
+   * because it depends on the locale and on schema knowledge that the
+   * cache does not own.
+   */
+  #diagnoseOrphanFields(fields) {
+    if (this.#cache.elementCount === 0) return;
+    const boundNames = /* @__PURE__ */ new Set();
+    for (const [name] of this.#cache.entries()) boundNames.add(name);
+    for (const [rawName, value] of Object.entries(fields)) {
+      if (this.#warnedOrphanFields.has(rawName)) continue;
+      if (SYSTEM_FIELD_NAMES.has(rawName)) continue;
+      if (!isLiveBindableScalar(value)) continue;
+      const baseName = stripLocaleSuffix(rawName, this.#currentLocale);
+      if (boundNames.has(rawName) || boundNames.has(baseName)) continue;
+      this.#warnedOrphanFields.add(rawName);
+      this.#warn(
+        `[live-preview] update arrived for field "${rawName}" but no <\u2026 data-payload-field="${baseName}"> element exists on this page. Render the binding anchor unconditionally in your template so live edits to an initially-empty field have somewhere to land.`
+      );
+    }
+  }
+  #applyUpdate(update) {
+    const schemaEntry = this.#schemaIndex !== void 0 ? lookupSchema(this.#schemaIndex, update.target.fieldName) : void 0;
+    let resolvedType = this.#resolveFieldType(update.target, schemaEntry?.type);
+    if (resolvedType === "text" && update.target.explicitFieldType !== true && looksLikeLexicalRoot(update.value)) {
+      resolvedType = "richText";
+    }
+    const renderer = this.#renderers[resolvedType];
+    const previous = readElementSnapshot(update.target.element);
+    const context = {
+      allFields: update.allFields,
+      locale: this.#currentLocale,
+      schema: schemaEntry
+    };
+    try {
+      if (update.target.targetAttribute !== void 0) {
+        const outcome = applyAttributeBinding(
+          update.target.element,
+          update.target.targetAttribute,
+          update.value
+        );
+        if (outcome === "blocked") {
+          this.#warn(
+            `[live-preview] refused to write field "${update.target.fieldName}" into attribute "${update.target.targetAttribute}" (unsafe attribute or value)`
+          );
+        }
+      } else if (renderer) {
+        renderer.render(update.target, update.value, context);
+      } else {
+        this.#log("no renderer for", resolvedType);
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      void this.#emitter.emit("error", { error, context: "renderer" });
+      return;
+    }
+    void this.#emitter.emit("elementUpdate", {
+      element: update.target.element,
+      fieldName: update.target.fieldName,
+      previousValue: previous,
+      nextValue: update.value
+    });
+  }
+  /**
+   * Resolve the renderer name for an update. Explicit consumer DOM
+   * attributes (`data-payload-type`) always win; otherwise the schema
+   * type maps to a renderer; otherwise the cache's tag-based heuristic
+   * stands.
+   */
+  #resolveFieldType(target, schemaType) {
+    if (target.explicitFieldType) return target.fieldType;
+    if (schemaType !== void 0) {
+      const mapped = payloadTypeToRenderer(schemaType);
+      if (mapped !== void 0) return mapped;
+    }
+    return target.fieldType;
+  }
+  #onFlush(stats) {
+    if (stats.applied === 0 && stats.deferred === 0) return;
+    if (stats.applied > 0) this.#a11y?.announceUpdate(stats.applied);
+    void this.#emitter.emit("afterUpdate", {
+      data: {
+        fields: {},
+        ...this.#currentLocale !== void 0 ? { locale: this.#currentLocale } : {}
+      },
+      updatedCount: stats.applied,
+      durationMs: stats.durationMs
+    });
+  }
+  #onHeartbeatTimeout() {
+    if (this.#state.markDisconnected()) {
+      this.#a11y?.announceDisconnected();
+      void this.#emitter.emit("disconnect", { reason: "timeout", timestamp: Date.now() });
+    }
+    try {
+      this.#onHeartbeatTimeoutHook?.();
+    } catch (err) {
+      this.#log("onHeartbeatTimeout hook threw:", err);
+    }
+    this.#sendReady(this.#readyTargets);
+  }
+};
+function createA11y(options) {
+  if (options.enableA11y === false) return null;
+  return options.a11yLocale !== void 0 ? new A11yAnnouncer(options.a11yLocale) : new A11yAnnouncer();
+}
+function noopLogger() {
+}
+function looksLikeLexicalRoot(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("root" in value)) return false;
+  const root = value.root;
+  if (typeof root !== "object" || root === null) return false;
+  return Array.isArray(root.children);
+}
+function defaultWarn(...args) {
+  if (typeof console !== "undefined" && typeof console.warn === "function") {
+    console.warn(...args);
+  }
+}
+function defaultSendReady(origins) {
+  if (typeof window === "undefined") return;
+  const targets = [];
+  if (window.parent !== window) targets.push(window.parent);
+  if (window.opener instanceof Window) targets.push(window.opener);
+  MessageBus.sendReady(targets, origins);
+}
+var BLOCKED_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var SYSTEM_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "id",
+  "_id",
+  "createdAt",
+  "updatedAt",
+  "createdBy",
+  "updatedBy",
+  "_status",
+  "globalType",
+  "collection",
+  "locale",
+  "localized"
+]);
+function isLiveBindableScalar(value) {
+  if (value === null || value === void 0) return false;
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
+}
+function stripLocaleSuffix(name, locale) {
+  if (!locale) return name;
+  const suffix = `_${locale}`;
+  return name.endsWith(suffix) ? name.slice(0, -suffix.length) : name;
+}
+function resolveFieldValue(fields, path, locale) {
+  const direct = readSafe(fields, path);
+  if (direct !== void 0) return direct;
+  if (path.includes(".")) {
+    const segments = path.split(".");
+    let current = fields;
+    for (const segment of segments) {
+      if (BLOCKED_KEYS.has(segment)) return void 0;
+      if (current === null || typeof current !== "object") return void 0;
+      current = current[segment];
+    }
+    if (current !== void 0) return current;
+  }
+  if (locale !== void 0) {
+    const localised = readSafe(fields, `${path}_${locale}`);
+    if (localised !== void 0) return localised;
+  }
+  return void 0;
+}
+function readSafe(obj, key) {
+  if (BLOCKED_KEYS.has(key)) return void 0;
+  if (!Object.prototype.hasOwnProperty.call(obj, key)) return void 0;
+  return obj[key];
+}
+function readElementSnapshot(element) {
+  if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
+    return element.value;
+  }
+  if (element.tagName === "IMG") {
+    return element.src;
+  }
+  return element.textContent;
+}
+
+// src/events/emitter.ts
+var EventEmitter = class {
+  #regular = /* @__PURE__ */ new Map();
+  #once = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe `handler` to `event`. Returns an unsubscribe function;
+   * call it to remove the handler. The handler is invoked for every
+   * subsequent emit until unsubscribed.
+   */
+  on(event, handler) {
+    return this.#register(this.#regular, event, handler);
+  }
+  /**
+   * Subscribe `handler` for a single emit. After the first dispatch,
+   * the handler is removed automatically.
+   */
+  once(event, handler) {
+    return this.#register(this.#once, event, handler);
+  }
+  /**
+   * Remove `handler` from `event`. Works for both `on`- and
+   * `once`-registered handlers. No-op when the handler isn't registered.
+   */
+  off(event, handler) {
+    this.#regular.get(event)?.delete(handler);
+    this.#once.get(event)?.delete(handler);
+  }
+  /**
+   * Dispatch `payload` to every handler registered for `event`.
+   *
+   * Handlers run sequentially in registration order — regular ones
+   * first, then `once` handlers. Async handlers are awaited. Synchronous
+   * exceptions are caught, logged, and isolated to the offending handler.
+   */
+  async emit(event, payload) {
+    const regular = this.#regular.get(event);
+    if (regular) {
+      for (const handler of [...regular]) await this.#invoke(handler, payload, event);
+    }
+    const once = this.#once.get(event);
+    if (once && once.size > 0) {
+      const snapshot = [...once];
+      this.#once.delete(event);
+      for (const handler of snapshot) await this.#invoke(handler, payload, event);
+    }
+  }
+  /**
+   * Number of handlers currently registered for `event`.
+   * Sum of `on` and `once` registrations.
+   */
+  listenerCount(event) {
+    return (this.#regular.get(event)?.size ?? 0) + (this.#once.get(event)?.size ?? 0);
+  }
+  /**
+   * Remove every handler. Pass an event name to limit the removal to
+   * one event; omit it to clear every event on this emitter.
+   *
+   * Crucially this only affects the current instance — there is no
+   * shared global state.
+   */
+  removeAllListeners(event) {
+    if (event === void 0) {
+      this.#regular.clear();
+      this.#once.clear();
+      return;
+    }
+    this.#regular.delete(event);
+    this.#once.delete(event);
+  }
+  /**
+   * Snapshot of all event names that currently have at least one
+   * registered handler. Useful for debugging.
+   */
+  eventNames() {
+    const names = /* @__PURE__ */ new Set();
+    for (const key of this.#regular.keys()) names.add(key);
+    for (const key of this.#once.keys()) names.add(key);
+    return [...names];
+  }
+  #register(bucket, event, handler) {
+    let set = bucket.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      bucket.set(event, set);
+    }
+    set.add(handler);
+    return () => {
+      bucket.get(event)?.delete(handler);
+    };
+  }
+  async #invoke(handler, payload, event) {
+    try {
+      await handler(payload);
+    } catch (err) {
+      const label = typeof event === "string" || typeof event === "number" ? String(event) : "<event>";
+      console.error(`[live-preview] handler for "${label}" threw:`, err);
+    }
+  }
+};
+
+// src/detection/environment.ts
+function isInIframe() {
+  if (typeof window === "undefined") return false;
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+}
+function isInPopup() {
+  if (typeof window === "undefined") return false;
+  return window.opener != null;
+}
+function isInPreviewContext() {
+  return isInIframe() || isInPopup();
+}
+function isDevMode() {
+  const nodeEnv = readNodeEnv();
+  if (nodeEnv !== void 0) return nodeEnv !== "production";
+  const importMetaDev = readImportMetaDev();
+  if (importMetaDev !== void 0) return importMetaDev;
+  if (typeof window !== "undefined") {
+    const host = window.location.hostname;
+    if (host === "localhost" || host === "127.0.0.1") return true;
+  }
+  return false;
+}
+function getEnvVar(name) {
+  if (typeof process !== "undefined") {
+    const value = process.env[name];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  const meta = tryReadImportMetaEnv();
+  if (meta) {
+    const value = meta[name];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return void 0;
+}
+function readNodeEnv() {
+  if (typeof process === "undefined") return void 0;
+  const value = process.env["NODE_ENV"];
+  return typeof value === "string" ? value : void 0;
+}
+function readImportMetaDev() {
+  const meta = tryReadImportMetaEnv();
+  if (!meta) return void 0;
+  const dev = meta["DEV"];
+  return typeof dev === "boolean" ? dev : void 0;
+}
+var importMetaEnvCache;
+function tryReadImportMetaEnv() {
+  if (typeof __INLINE_RUNTIME_BUILD__ !== "undefined" && __INLINE_RUNTIME_BUILD__) {
+    return void 0;
+  }
+  if (importMetaEnvCache !== void 0) return importMetaEnvCache ?? void 0;
+  importMetaEnvCache = null;
+  try {
+    const reader = new Function(
+      "try { return import.meta && import.meta.env; } catch (_) { return undefined; }"
+    );
+    const result = reader();
+    if (result && typeof result === "object") {
+      importMetaEnvCache = result;
+      return importMetaEnvCache;
+    }
+  } catch {
+  }
+  return void 0;
+}
+
+// src/detection/origin.ts
+var LOCALHOST_PATTERN = /^https?:\/\/(localhost|127\.0\.0\.1)(?::\d+)?$/i;
+var VALID_ORIGIN_PATTERN = /^https?:\/\/[^/?#\s]+$/i;
+var ENV_VAR_NAMES = [
+  "PAYLOAD_ADMIN_ORIGIN",
+  "PUBLIC_PAYLOAD_ADMIN_ORIGIN",
+  "NEXT_PUBLIC_PAYLOAD_ADMIN_ORIGIN"
+];
+var OriginDetector = class {
+  #explicitOrigins;
+  #referrerOrigin;
+  #allowLocalhost;
+  #referrerWasAvailable;
+  #lockedOrigin;
+  constructor(options = {}) {
+    const explicit = /* @__PURE__ */ new Set();
+    for (const origin of options.additionalOrigins ?? []) {
+      const normalised = normaliseOrigin(origin);
+      if (normalised !== void 0) explicit.add(normalised);
+    }
+    for (const envName of ENV_VAR_NAMES) {
+      const value = getEnvVar(envName);
+      if (value === void 0) continue;
+      for (const raw of value.split(",")) {
+        const normalised = normaliseOrigin(raw);
+        if (normalised !== void 0) explicit.add(normalised);
+      }
+    }
+    this.#explicitOrigins = explicit;
+    const useReferrer = options.enableReferrerDetection ?? true;
+    let referrerOrigin;
+    if (useReferrer) {
+      const referrer = options.referrer ?? (typeof document !== "undefined" ? document.referrer : "");
+      if (referrer.length > 0) {
+        try {
+          const origin = new URL(referrer).origin;
+          if (origin && origin !== "null") referrerOrigin = origin;
+        } catch {
+        }
+      }
+    }
+    this.#referrerOrigin = referrerOrigin;
+    this.#referrerWasAvailable = referrerOrigin !== void 0;
+    const allowLocalhost = (options.enableLocalhostMatching ?? true) && (options.forceDevMode ?? isDevMode());
+    this.#allowLocalhost = allowLocalhost;
+  }
+  /**
+   * Returns `true` when `origin` is trusted under the current policy.
+   *
+   * If an origin has been locked, only that exact value matches.
+   * Otherwise explicit origins and (in dev mode) localhost-pattern
+   * matches are accepted. The referrer-derived origin is a **fallback,
+   * not a union member**: it only counts when NO explicit origins are
+   * configured. `document.referrer` always names whoever actually
+   * framed the page — if it were unioned with the explicit list, any
+   * site embedding the page in an iframe would become a trusted
+   * postMessage sender despite the consumer having pinned the admin
+   * origin explicitly.
+   */
+  matches(origin) {
+    if (origin.length === 0 || origin === "null") return false;
+    if (this.#lockedOrigin !== void 0) return origin === this.#lockedOrigin;
+    if (this.#explicitOrigins.has(origin)) return true;
+    if (this.#explicitOrigins.size === 0 && this.#referrerOrigin !== void 0 && origin === this.#referrerOrigin) {
+      return true;
+    }
+    if (this.#allowLocalhost && LOCALHOST_PATTERN.test(origin)) return true;
+    return false;
+  }
+  /**
+   * Narrow the trusted set to a single origin after a successful
+   * handshake. Subsequent calls to `matches()` only allow `origin`.
+   *
+   * Returns `true` if locking succeeded; `false` if the candidate is
+   * not currently considered trusted (which would defeat the purpose
+   * of locking).
+   */
+  lockOrigin(origin) {
+    if (!this.matches(origin)) return false;
+    this.#lockedOrigin = origin;
+    return true;
+  }
+  /**
+   * Release the origin lock so any allow-listed origin is trusted
+   * again until the next successful handshake. The lifecycle calls
+   * this on heartbeat timeout — after the trusted parent disappears,
+   * a different (still-allowed) origin should be free to reconnect.
+   *
+   * Returns the previously-locked origin, or `undefined` when nothing
+   * was locked.
+   */
+  unlockOrigin() {
+    const previous = this.#lockedOrigin;
+    this.#lockedOrigin = void 0;
+    return previous;
+  }
+  /** The currently locked origin, or `undefined`. */
+  get lockedOrigin() {
+    return this.#lockedOrigin;
+  }
+  /**
+   * Snapshot of every origin currently allowed by the policy. Used by
+   * the message bus to broadcast `ready` messages.
+   *
+   * Localhost pattern matches are expanded into the common dev ports
+   * so the handshake can find a Payload running on its usual port.
+   */
+  enumerate() {
+    if (this.#lockedOrigin !== void 0) return [this.#lockedOrigin];
+    const result = new Set(this.#explicitOrigins);
+    if (this.#explicitOrigins.size === 0 && this.#referrerOrigin !== void 0) {
+      result.add(this.#referrerOrigin);
+    }
+    if (this.#allowLocalhost) {
+      for (const port of LOCALHOST_HANDSHAKE_PORTS) {
+        result.add(`http://localhost:${String(port)}`);
+        result.add(`http://127.0.0.1:${String(port)}`);
+      }
+    }
+    return [...result];
+  }
+  /**
+   * Reports whether `document.referrer` contributed at least one
+   * origin. Useful for surfacing a console warning when running in
+   * production without an explicit origin and the referrer is absent
+   * (because of a `Referrer-Policy: no-referrer` header).
+   */
+  get referrerWasAvailable() {
+    return this.#referrerWasAvailable;
+  }
+  /**
+   * Indicates whether the detector is operating in a "production-without-
+   * explicit-origin" configuration. When `true`, the host should log a
+   * loud warning — silent connection failure is the worst outcome.
+   */
+  get isProductionUnconfigured() {
+    if (!isInIframe()) return false;
+    if (this.#explicitOrigins.size > 0) return false;
+    if (this.#allowLocalhost) return false;
+    if (this.#referrerOrigin !== void 0) return false;
+    return true;
+  }
+  /**
+   * `true` when the referrer is the ONLY trust source (no explicit
+   * origins, no localhost matching). In that mode any site that frames
+   * the page becomes a trusted postMessage sender — `document.referrer`
+   * always names the actual embedder. Content is still sanitized, but
+   * the origin allow-list no longer restricts who may drive it. Hosts
+   * should surface a warning suggesting explicit `allowedOrigins` and
+   * a `frame-ancestors` policy in production.
+   */
+  get isReferrerOnlyTrust() {
+    if (this.#explicitOrigins.size > 0) return false;
+    if (this.#allowLocalhost) return false;
+    return this.#referrerOrigin !== void 0;
+  }
+};
+var LOCALHOST_HANDSHAKE_PORTS = [
+  3e3,
+  3001,
+  3333,
+  4e3,
+  4321,
+  5e3,
+  5173,
+  5174,
+  8e3,
+  8080,
+  8888,
+  9e3
+];
+function normaliseOrigin(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return void 0;
+  try {
+    const url = new URL(trimmed);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    if (!VALID_ORIGIN_PATTERN.test(url.origin)) return void 0;
+    return url.origin;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/plugins/manager.ts
+var PluginManager = class {
+  #events;
+  #config;
+  #registerRenderer;
+  #log;
+  #plugins = /* @__PURE__ */ new Map();
+  #transforms = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#events = options.events;
+    this.#config = options.config;
+    this.#registerRenderer = options.registerFieldRenderer;
+    this.#log = options.log;
+  }
+  /**
+   * Register a plugin and run its `init` hook. Duplicate names are
+   * ignored (with a debug warning). Errors thrown by `init` are
+   * caught and surfaced via the error logger; the plugin is *not*
+   * added to the registry in that case.
+   */
+  async register(plugin) {
+    if (this.#plugins.has(plugin.name)) {
+      this.#log(`plugin "${plugin.name}" already registered`);
+      return;
+    }
+    const context = {
+      events: this.#events,
+      registerFieldRenderer: (renderer) => {
+        this.#registerRenderer(renderer);
+      },
+      registerTransform: (fieldName, transform) => {
+        this.#addTransform(fieldName, transform);
+      },
+      getConfig: () => this.#config,
+      log: (...args) => {
+        this.#log(`[${plugin.name}]`, ...args);
+      }
+    };
+    try {
+      await plugin.init(context);
+      this.#plugins.set(plugin.name, plugin);
+      this.#log(`plugin "${plugin.name}" registered`);
+    } catch (err) {
+      this.#log(`plugin "${plugin.name}" init failed:`, err);
+    }
+  }
+  /**
+   * Remove a plugin and call its `destroy` hook.
+   */
+  async unregister(name) {
+    const plugin = this.#plugins.get(name);
+    if (!plugin) return;
+    this.#plugins.delete(name);
+    if (plugin.destroy) {
+      try {
+        await plugin.destroy();
+      } catch (err) {
+        this.#log(`plugin "${name}" destroy failed:`, err);
+      }
+    }
+  }
+  /**
+   * Destroy every registered plugin. Used by `LivePreviewClient.destroy`.
+   * Errors from individual plugins are isolated.
+   */
+  async destroyAll() {
+    const names = [...this.#plugins.keys()];
+    for (const name of names) await this.unregister(name);
+    this.#transforms.clear();
+  }
+  /**
+   * Apply every transform registered for `fieldName` to `value`, in
+   * registration order. Returns the transformed value.
+   */
+  applyTransforms(fieldName, value, context) {
+    const transforms = this.#transforms.get(fieldName);
+    if (!transforms || transforms.length === 0) return value;
+    let result = value;
+    for (const transform of transforms) {
+      try {
+        result = transform(result, {
+          fieldName,
+          element: context.element,
+          allFields: context.allFields
+        });
+      } catch (err) {
+        this.#log(`transform for "${fieldName}" threw:`, err);
+        return value;
+      }
+    }
+    return result;
+  }
+  /** Names of currently registered plugins. */
+  list() {
+    return [...this.#plugins.keys()];
+  }
+  /** Test introspection — number of plugins. */
+  get size() {
+    return this.#plugins.size;
+  }
+  #addTransform(fieldName, transform) {
+    const existing = this.#transforms.get(fieldName);
+    if (existing) existing.push(transform);
+    else this.#transforms.set(fieldName, [transform]);
+  }
+};
+
+// src/security/sanitizer.ts
+var ALLOWED_TAGS = /* @__PURE__ */ new Set([
+  "p",
+  "br",
+  "strong",
+  "b",
+  "em",
+  "i",
+  "u",
+  "s",
+  "strike",
+  "mark",
+  "small",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "ul",
+  "ol",
+  "li",
+  "dl",
+  "dt",
+  "dd",
+  "blockquote",
+  "code",
+  "pre",
+  "kbd",
+  "samp",
+  "var",
+  "a",
+  "span",
+  "div",
+  "section",
+  "article",
+  "aside",
+  "header",
+  "footer",
+  "nav",
+  "figure",
+  "figcaption",
+  "img",
+  "picture",
+  "source",
+  "audio",
+  "video",
+  "sub",
+  "sup",
+  "hr",
+  "time",
+  "abbr",
+  "cite",
+  "q",
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "caption",
+  "colgroup",
+  "col"
+]);
+var REMOVE_COMPLETELY = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "iframe",
+  "object",
+  "embed",
+  "link",
+  "meta",
+  "base",
+  "form",
+  "input",
+  "button",
+  "select",
+  "textarea",
+  "svg",
+  "math",
+  "template",
+  "frame",
+  "frameset",
+  "noframes",
+  "noscript"
+]);
+var ATTR_GLOBAL = /* @__PURE__ */ new Set([
+  "id",
+  "class",
+  "lang",
+  "dir",
+  "title",
+  "role",
+  "tabindex"
+]);
+var ATTR_ARIA_PREFIX = "aria-";
+var ATTR_DATA_PREFIX = "data-";
+var ATTR_BY_TAG = {
+  a: /* @__PURE__ */ new Set(["href", "target", "rel", "download", "hreflang", "type"]),
+  img: /* @__PURE__ */ new Set(["src", "srcset", "sizes", "alt", "width", "height", "loading", "decoding"]),
+  picture: /* @__PURE__ */ new Set([]),
+  source: /* @__PURE__ */ new Set(["src", "srcset", "sizes", "type", "media"]),
+  audio: /* @__PURE__ */ new Set(["src", "controls", "autoplay", "loop", "muted", "preload"]),
+  video: /* @__PURE__ */ new Set([
+    "src",
+    "poster",
+    "controls",
+    "autoplay",
+    "loop",
+    "muted",
+    "preload",
+    "width",
+    "height",
+    "playsinline"
+  ]),
+  time: /* @__PURE__ */ new Set(["datetime"]),
+  abbr: /* @__PURE__ */ new Set(["title"]),
+  q: /* @__PURE__ */ new Set(["cite"]),
+  blockquote: /* @__PURE__ */ new Set(["cite"]),
+  table: /* @__PURE__ */ new Set(["summary"]),
+  th: /* @__PURE__ */ new Set(["colspan", "rowspan", "scope", "headers", "abbr"]),
+  td: /* @__PURE__ */ new Set(["colspan", "rowspan", "headers"]),
+  col: /* @__PURE__ */ new Set(["span"]),
+  colgroup: /* @__PURE__ */ new Set(["span"]),
+  ol: /* @__PURE__ */ new Set(["start", "reversed", "type"]),
+  li: /* @__PURE__ */ new Set(["value"]),
+  code: /* @__PURE__ */ new Set(["class"]),
+  pre: /* @__PURE__ */ new Set(["class"])
+};
+var URL_ATTRIBUTES2 = /* @__PURE__ */ new Set(["href", "src", "cite", "poster"]);
+var SanitizerEnvironmentError = class extends Error {
+  name = "SanitizerEnvironmentError";
+};
+function resolvePolicy(options) {
+  if (!options) {
+    const attrMap2 = /* @__PURE__ */ new Map();
+    for (const [tag, attrs] of Object.entries(ATTR_BY_TAG)) attrMap2.set(tag, attrs);
+    return { allowedTags: ALLOWED_TAGS, attrByTag: attrMap2 };
+  }
+  const allowed = new Set(ALLOWED_TAGS);
+  for (const tag of options.additionalAllowedTags ?? []) allowed.add(tag);
+  const attrMap = /* @__PURE__ */ new Map();
+  for (const [tag, attrs] of Object.entries(ATTR_BY_TAG)) attrMap.set(tag, attrs);
+  for (const [tag, attrs] of Object.entries(options.additionalAllowedAttributes ?? {})) {
+    const existing = attrMap.get(tag);
+    const merged = new Set(existing ?? []);
+    for (const attr of attrs) merged.add(attr);
+    attrMap.set(tag, merged);
+  }
+  return { allowedTags: allowed, attrByTag: attrMap };
+}
+var documentOverride;
+function setSanitizerDocument(doc) {
+  documentOverride = doc ?? void 0;
+}
+function sanitizeHtml(html, options) {
+  const doc = resolveDocument();
+  if (!doc) {
+    throw new SanitizerEnvironmentError(
+      "sanitizeHtml requires a DOM. Inject one via setSanitizerDocument() for SSR (linkedom, jsdom, happy-dom, \u2026) or use the plain-text path on the server."
+    );
+  }
+  if (html === "") return "";
+  const policy = resolvePolicy(options);
+  const template = doc.createElement("template");
+  template.innerHTML = html;
+  sanitizeFragment(template.content, policy);
+  return template.innerHTML;
+}
+function resolveDocument() {
+  if (documentOverride) return documentOverride;
+  if (typeof document === "undefined") return void 0;
+  return document;
+}
+function hasSanitizerDocument() {
+  return resolveDocument() !== void 0;
+}
+function sanitizeFragment(node, policy) {
+  for (const child of Array.from(node.childNodes)) {
+    if (child.nodeType === Node.ELEMENT_NODE) {
+      sanitizeElement(child, policy);
+    } else if (child.nodeType === Node.COMMENT_NODE) {
+      child.remove();
+    }
+  }
+}
+function sanitizeElement(element, policy) {
+  const tag = element.tagName.toLowerCase();
+  if (REMOVE_COMPLETELY.has(tag)) {
+    element.remove();
+    return;
+  }
+  if (!policy.allowedTags.has(tag)) {
+    sanitizeFragment(element, policy);
+    const parent = element.parentNode;
+    if (parent) {
+      while (element.firstChild) parent.insertBefore(element.firstChild, element);
+      element.remove();
+    }
+    return;
+  }
+  sanitizeAttributes(element, tag, policy);
+  if (tag === "a") hardenAnchor(element);
+  sanitizeFragment(element, policy);
+}
+function sanitizeAttributes(element, tag, policy) {
+  const tagAttrs = policy.attrByTag.get(tag);
+  for (const attr of Array.from(element.attributes)) {
+    const name = attr.name.toLowerCase();
+    if (name.startsWith("on")) {
+      element.removeAttribute(attr.name);
+      continue;
+    }
+    if (name === "style") {
+      element.removeAttribute(attr.name);
+      continue;
+    }
+    if (ATTR_GLOBAL.has(name) || name.startsWith(ATTR_ARIA_PREFIX) || name.startsWith(ATTR_DATA_PREFIX)) {
+      continue;
+    }
+    if (tagAttrs?.has(name)) {
+      if (URL_ATTRIBUTES2.has(name) && !isSafeUrl(attr.value)) {
+        element.removeAttribute(attr.name);
+      } else if (name === "srcset" && !isSafeSrcset(attr.value)) {
+        element.removeAttribute(attr.name);
+      }
+      continue;
+    }
+    element.removeAttribute(attr.name);
+  }
+}
+function isSafeSrcset(value) {
+  const candidates = value.split(",");
+  for (const candidate of candidates) {
+    const trimmed = candidate.trim();
+    if (trimmed.length === 0) continue;
+    const url = trimmed.split(/\s+/, 1)[0];
+    if (url === void 0 || url.length === 0 || !isSafeUrl(url)) return false;
+  }
+  return true;
+}
+function hardenAnchor(anchor) {
+  const href = anchor.getAttribute("href");
+  if (!href) return;
+  if (!isExternalHttpUrl(href)) return;
+  anchor.setAttribute("rel", "noopener noreferrer");
+  if (!anchor.hasAttribute("target")) anchor.setAttribute("target", "_blank");
+}
+
+// src/lexical/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function register(type, renderer) {
+  registry.set(type, renderer);
+}
+function lookup(type) {
+  return registry.get(type);
+}
+
+// src/lexical/utils.ts
+var ALIGNMENT_NUMERIC = {
+  1: "left",
+  2: "center",
+  3: "right",
+  4: "justify"
+};
+var ALIGNMENT_STRING = /* @__PURE__ */ new Set(["left", "center", "right", "justify", "start", "end"]);
+function resolveAlignment(node) {
+  const fmt = node.format;
+  if (typeof fmt === "string" && ALIGNMENT_STRING.has(fmt)) return fmt;
+  if (typeof fmt === "number") {
+    const mapped = ALIGNMENT_NUMERIC[fmt];
+    if (mapped !== void 0) return mapped;
+  }
+  return void 0;
+}
+function resolveIndent(node) {
+  const indent = node.indent;
+  return typeof indent === "number" && indent > 0 ? indent : 0;
+}
+function dirAttribute(node) {
+  if (node.direction === "rtl") return ' dir="rtl"';
+  if (node.direction === "ltr") return ' dir="ltr"';
+  return "";
+}
+function styleAttribute(node) {
+  const align = resolveAlignment(node);
+  const indent = resolveIndent(node);
+  const styles = [];
+  if (align !== void 0) styles.push(`text-align:${align}`);
+  if (indent > 0) styles.push(`padding-inline-start:${String(indent * 40)}px`);
+  if (styles.length === 0) return "";
+  return ` style="${styles.join(";")}"`;
+}
+
+// src/security/escape.ts
+var HTML_ESCAPES = Object.freeze({
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#x27;",
+  "/": "&#x2F;",
+  "`": "&#x60;",
+  "=": "&#x3D;"
+});
+var HTML_ESCAPE_PATTERN = /[&<>"'/`=]/g;
+function escapeHtml(text) {
+  if (text === "") return "";
+  return text.replace(HTML_ESCAPE_PATTERN, (char) => HTML_ESCAPES[char]);
+}
+function escapeCssUrl(value) {
+  return value.replace(/['"()\\]/g, "\\$&");
+}
+var ATTR_ESCAPES = Object.freeze({
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#x27;"
+});
+var ATTR_ESCAPE_PATTERN = /[&<>"']/g;
+function escapeHtmlAttribute(value) {
+  if (value === "") return "";
+  return value.replace(ATTR_ESCAPE_PATTERN, (char) => ATTR_ESCAPES[char]);
+}
+function escapeAndLinebreak(text) {
+  return escapeHtml(text).replace(/\r\n|\r|\n/g, "<br>");
+}
+
+// src/lexical/types.ts
+var TextFormat = {
+  BOLD: 1,
+  ITALIC: 2,
+  STRIKETHROUGH: 4,
+  UNDERLINE: 8,
+  CODE: 16,
+  SUBSCRIPT: 32,
+  SUPERSCRIPT: 64,
+  HIGHLIGHT: 128
+};
+
+// src/lexical/nodes/text.ts
+var textRenderer = (node) => {
+  const raw = typeof node.text === "string" ? node.text : "";
+  let out = escapeHtml(raw);
+  const format2 = typeof node.format === "number" ? node.format : 0;
+  if ((format2 & TextFormat.CODE) !== 0) out = `<code>${out}</code>`;
+  if ((format2 & TextFormat.BOLD) !== 0) out = `<strong>${out}</strong>`;
+  if ((format2 & TextFormat.ITALIC) !== 0) out = `<em>${out}</em>`;
+  if ((format2 & TextFormat.UNDERLINE) !== 0) out = `<u>${out}</u>`;
+  if ((format2 & TextFormat.STRIKETHROUGH) !== 0) out = `<s>${out}</s>`;
+  if ((format2 & TextFormat.SUBSCRIPT) !== 0) out = `<sub>${out}</sub>`;
+  if ((format2 & TextFormat.SUPERSCRIPT) !== 0) out = `<sup>${out}</sup>`;
+  if ((format2 & TextFormat.HIGHLIGHT) !== 0) out = `<mark>${out}</mark>`;
+  return out;
+};
+register("text", textRenderer);
+
+// src/lexical/nodes/paragraph.ts
+var paragraphRenderer = (node, ctx) => {
+  const children = ctx.renderChildren(node.children ?? []);
+  return `<p${dirAttribute(node)}${styleAttribute(node)}>${children}</p>`;
+};
+register("paragraph", paragraphRenderer);
+
+// src/lexical/nodes/heading.ts
+var VALID_TAGS = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+var headingRenderer = (node, ctx) => {
+  const tagRaw = typeof node["tag"] === "string" ? node["tag"].toLowerCase() : "h2";
+  const tag = VALID_TAGS.has(tagRaw) ? tagRaw : "h2";
+  const children = ctx.renderChildren(node.children ?? []);
+  return `<${tag}${dirAttribute(node)}${styleAttribute(node)}>${children}</${tag}>`;
+};
+register("heading", headingRenderer);
+
+// src/lexical/nodes/list.ts
+var listRenderer = (node, ctx) => {
+  const listType = typeof node["listType"] === "string" ? node["listType"] : "bullet";
+  const tag = listType === "number" ? "ol" : "ul";
+  const startAttr = listType === "number" && typeof node["start"] === "number" && node["start"] > 1 ? ` start="${String(node["start"])}"` : "";
+  const checkAttr = listType === "check" ? ' role="list"' : "";
+  const children = ctx.renderChildren(node.children ?? []);
+  return `<${tag}${dirAttribute(node)}${styleAttribute(node)}${startAttr}${checkAttr}>${children}</${tag}>`;
+};
+var listItemRenderer = (node, ctx) => {
+  const children = ctx.renderChildren(node.children ?? []);
+  if (typeof node["checked"] === "boolean") {
+    const state = node["checked"] ? "true" : "false";
+    return `<li role="checkbox" aria-checked="${state}"${styleAttribute(node)}>${children}</li>`;
+  }
+  const valueAttr = typeof node["value"] === "number" ? ` value="${escapeHtml(String(node["value"]))}"` : "";
+  return `<li${dirAttribute(node)}${styleAttribute(node)}${valueAttr}>${children}</li>`;
+};
+register("list", listRenderer);
+register("listitem", listItemRenderer);
+
+// src/lexical/nodes/link.ts
+var linkRenderer = (node, ctx) => {
+  const url = typeof node["url"] === "string" ? node["url"] : "";
+  const children = ctx.renderChildren(node.children ?? []);
+  if (url.length === 0 || !isSafeUrl(url)) return children;
+  const targetAttr = isExternalHttpUrl(url) ? ' target="_blank" rel="noopener noreferrer"' : buildOptionalAttrs(node);
+  const titleAttr = typeof node["title"] === "string" ? ` title="${escapeHtml(node["title"])}"` : "";
+  return `<a href="${escapeHtmlAttribute(url)}"${targetAttr}${titleAttr}>${children}</a>`;
+};
+function buildOptionalAttrs(node) {
+  const target = typeof node["target"] === "string" ? node["target"] : "";
+  if (target.length === 0) return "";
+  const safeTarget = escapeHtml(target);
+  if (target === "_blank") return ` target="_blank" rel="noopener noreferrer"`;
+  return ` target="${safeTarget}"`;
+}
+register("link", linkRenderer);
+register("autolink", linkRenderer);
+
+// src/lexical/nodes/quote.ts
+var quoteRenderer = (node, ctx) => {
+  const children = ctx.renderChildren(node.children ?? []);
+  return `<blockquote${dirAttribute(node)}${styleAttribute(node)}>${children}</blockquote>`;
+};
+register("quote", quoteRenderer);
+
+// src/lexical/nodes/code.ts
+var codeRenderer = (node) => {
+  const language = sanitizeLangClass(typeof node["language"] === "string" ? node["language"] : "");
+  const inner = extractText(node);
+  const langClass = language === "" ? "" : ` class="language-${language}"`;
+  return `<pre><code${langClass}>${escapeHtml(inner)}</code></pre>`;
+};
+var codeHighlightRenderer = (node) => {
+  const text = typeof node.text === "string" ? node.text : "";
+  const highlight = typeof node["highlightType"] === "string" ? ` class="token-${sanitizeLangClass(node["highlightType"])}"` : "";
+  return `<span${highlight}>${escapeHtml(text)}</span>`;
+};
+register("code", codeRenderer);
+register("code-highlight", codeHighlightRenderer);
+function extractText(node) {
+  if (typeof node.text === "string") return node.text;
+  if (!node.children) return "";
+  let out = "";
+  for (const child of node.children) out += extractText(child);
+  return out;
+}
+function sanitizeLangClass(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "");
+}
+
+// src/lexical/nodes/linebreak.ts
+var linebreakRenderer = () => "<br>";
+var horizontalRuleRenderer = () => "<hr>";
+var tabRenderer = () => "	";
+register("linebreak", linebreakRenderer);
+register("horizontalrule", horizontalRuleRenderer);
+register("tab", tabRenderer);
+
+// src/lexical/nodes/upload.ts
+var uploadRenderer = (node) => {
+  const value = readUploadValue(node);
+  if (value === void 0) return "";
+  const url = value.url;
+  if (typeof url !== "string" || !isSafeUrl(url)) return "";
+  const mime = typeof value.mimeType === "string" ? value.mimeType : "";
+  if (mime.startsWith("video/")) return renderVideo(value, url);
+  if (mime.startsWith("audio/")) return renderAudio(value, url);
+  if (mime === "" || mime.startsWith("image/")) return renderImage(value, url);
+  return renderFallbackLink(value, url);
+};
+register("upload", uploadRenderer);
+function readUploadValue(node) {
+  const raw = node["value"];
+  if (typeof raw !== "object" || raw === null) return void 0;
+  return raw;
+}
+function renderImage(value, url) {
+  const alt = typeof value.alt === "string" ? escapeHtml(value.alt) : "";
+  const width = typeof value.width === "number" ? ` width="${String(value.width)}"` : "";
+  const height = typeof value.height === "number" ? ` height="${String(value.height)}"` : "";
+  return `<img src="${escapeHtmlAttribute(url)}" alt="${alt}"${width}${height} loading="lazy" decoding="async">`;
+}
+function renderVideo(value, url) {
+  const width = typeof value.width === "number" ? ` width="${String(value.width)}"` : "";
+  const height = typeof value.height === "number" ? ` height="${String(value.height)}"` : "";
+  const type = typeof value.mimeType === "string" ? ` type="${escapeHtmlAttribute(value.mimeType)}"` : "";
+  return `<video controls${width}${height}><source src="${escapeHtmlAttribute(url)}"${type}></video>`;
+}
+function renderAudio(value, url) {
+  const type = typeof value.mimeType === "string" ? ` type="${escapeHtmlAttribute(value.mimeType)}"` : "";
+  return `<audio controls><source src="${escapeHtmlAttribute(url)}"${type}></audio>`;
+}
+function renderFallbackLink(value, url) {
+  const label = typeof value.filename === "string" ? escapeHtml(value.filename) : escapeHtml(url);
+  return `<a href="${escapeHtmlAttribute(url)}" target="_blank" rel="noopener noreferrer">${label}</a>`;
+}
+
+// src/lexical/nodes/relationship.ts
+var relationshipRenderer = (node) => {
+  const relationTo = typeof node["relationTo"] === "string" ? node["relationTo"] : "";
+  const value = readValue(node);
+  const label = pickLabel(value, relationTo);
+  const safeLabel = escapeHtml(label);
+  const relAttr = relationTo === "" ? "" : ` data-relation-to="${escapeHtml(relationTo)}"`;
+  const url = value?.url;
+  if (typeof url === "string" && isSafeUrl(url)) {
+    return `<a href="${escapeHtmlAttribute(url)}"${relAttr}>${safeLabel}</a>`;
+  }
+  return `<span${relAttr}>${safeLabel}</span>`;
+};
+register("relationship", relationshipRenderer);
+function readValue(node) {
+  const raw = node["value"];
+  if (typeof raw !== "object" || raw === null) return void 0;
+  return raw;
+}
+function pickLabel(value, relationTo) {
+  if (value === void 0) return relationTo === "" ? "#" : `#${relationTo}`;
+  if (typeof value.title === "string" && value.title.length > 0) return value.title;
+  if (typeof value.name === "string" && value.name.length > 0) return value.name;
+  if (typeof value.slug === "string" && value.slug.length > 0) return value.slug;
+  if (value.id !== void 0) return String(value.id);
+  return relationTo === "" ? "#" : `#${relationTo}`;
+}
+
+// src/lexical/blocks/registry.ts
+var registry2 = /* @__PURE__ */ new Map();
+function registerBlockRenderer(blockType, renderer) {
+  registry2.set(blockType, renderer);
+}
+function lookupBlockRenderer(blockType) {
+  return registry2.get(blockType);
+}
+
+// src/lexical/nodes/block.ts
+var blockRenderer = (node, ctx) => {
+  const fields = readFields(node);
+  const blockTypeRaw = typeof fields["blockType"] === "string" ? fields["blockType"] : "";
+  const slug = sanitizeIdent(blockTypeRaw);
+  if (blockTypeRaw !== "") {
+    const custom = lookupBlockRenderer(blockTypeRaw) ?? lookupBlockRenderer(slug);
+    if (custom) {
+      return custom(fields, { renderChildren: ctx.renderChildren });
+    }
+  }
+  const attrs = [];
+  if (slug !== "") attrs.push(`data-block-type="${escapeHtml(slug)}"`);
+  for (const [key, value] of Object.entries(fields)) {
+    if (key === "blockType" || key === "id") continue;
+    if (value === null || value === void 0) continue;
+    const stringValue = typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
+    attrs.push(`data-block-${sanitizeIdent(key)}="${escapeHtml(stringValue)}"`);
+  }
+  const attrString = attrs.length === 0 ? "" : ` ${attrs.join(" ")}`;
+  return `<div${attrString}></div>`;
+};
+register("block", blockRenderer);
+function readFields(node) {
+  const raw = node["fields"];
+  if (typeof raw !== "object" || raw === null) return {};
+  return raw;
+}
+function sanitizeIdent(value) {
+  return value.replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
+}
+
+// src/lexical/render.ts
+register("text", textRenderer);
+register("paragraph", paragraphRenderer);
+register("heading", headingRenderer);
+register("list", listRenderer);
+register("listitem", listItemRenderer);
+register("link", linkRenderer);
+register("autolink", linkRenderer);
+register("quote", quoteRenderer);
+register("code", codeRenderer);
+register("code-highlight", codeHighlightRenderer);
+register("linebreak", linebreakRenderer);
+register("horizontalrule", horizontalRuleRenderer);
+register("tab", tabRenderer);
+register("upload", uploadRenderer);
+register("relationship", relationshipRenderer);
+register("block", blockRenderer);
+var RENDER_CONTEXT = {
+  renderChildren,
+  resolveAlignment,
+  resolveIndent
+};
+function isLexicalContent(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (!("root" in value)) return false;
+  const root = value.root;
+  if (typeof root !== "object" || root === null) return false;
+  if (!("children" in root)) return false;
+  return Array.isArray(root.children);
+}
+function lexicalToHtml(content, options = {}) {
+  if (!isLexicalContent(content)) return "";
+  const html = renderChildren(content.root.children);
+  if (options.sanitize === false) return html;
+  if (!hasSanitizerDocument()) return html;
+  return sanitizeHtml(html);
+}
+function lexicalToPlainText(content) {
+  if (!isLexicalContent(content)) return "";
+  return content.root.children.map(extractPlainText).join("\n").trim();
+}
+function renderChildren(children) {
+  let out = "";
+  for (const child of children) out += renderNode(child);
+  return out;
+}
+function renderNode(node) {
+  const renderer = lookup(node.type);
+  if (renderer) return renderer(node, RENDER_CONTEXT);
+  return node.children !== void 0 ? renderChildren(node.children) : "";
+}
+function extractPlainText(node) {
+  if (typeof node.text === "string") return node.text;
+  if (node.type === "linebreak") return "\n";
+  if (node.children === void 0) return "";
+  let out = "";
+  for (const child of node.children) out += extractPlainText(child);
+  return out;
+}
+
+// src/field-types/registry.ts
+var builtinRenderers = /* @__PURE__ */ new Map();
+function buildBuiltinRenderers(extras = []) {
+  for (const renderer of extras) builtinRenderers.set(renderer.name, renderer);
+  const out = {};
+  for (const [type, renderer] of builtinRenderers) out[type] = renderer;
+  return Object.freeze(out);
+}
+function registerBuiltinRenderer(renderer) {
+  builtinRenderers.set(renderer.name, renderer);
+}
+
+// src/field-types/text.ts
+var TEXT_OPT_IN_ATTRIBUTE = "data-payload-text";
+var warnedElements = /* @__PURE__ */ new WeakSet();
+var textRenderer2 = {
+  name: "text",
+  render(target, value) {
+    const element = target.element;
+    const text = toPlainString(value);
+    if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
+      element.value = text;
+      return;
+    }
+    if (hasStructuredChildren(element) && !element.hasAttribute(TEXT_OPT_IN_ATTRIBUTE)) {
+      warnOnce(element, target.fieldName);
+      return;
+    }
+    if (text.includes("\n") || text.includes("\r")) {
+      element.innerHTML = escapeAndLinebreak(text);
+      return;
+    }
+    element.textContent = text;
+  }
+};
+function hasStructuredChildren(element) {
+  return element.firstElementChild !== null;
+}
+function warnOnce(element, fieldName) {
+  if (warnedElements.has(element)) return;
+  warnedElements.add(element);
+  console.warn(
+    `[live-preview] Skipping text update for "${fieldName}" \u2014 the bound <${element.tagName.toLowerCase()}> has structured child elements. Either move data-payload-field to the element whose textContent is the field value, or opt in with data-payload-text to replace the structure.`
+  );
+}
+function toPlainString(value) {
+  if (value === null || value === void 0) return "";
+  if (isLexicalContent(value)) return lexicalToPlainText(value);
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+registerBuiltinRenderer(textRenderer2);
+
+// src/field-types/utils.ts
+function safeStringify(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+
+// src/field-types/textarea.ts
+var textareaRenderer = {
+  name: "textarea",
+  render(target, value) {
+    const element = target.element;
+    const text = isLexicalContent(value) ? lexicalToPlainText(value) : safeStringify(value);
+    if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
+      element.value = text;
+      return;
+    }
+    element.innerHTML = escapeAndLinebreak(text);
+  }
+};
+registerBuiltinRenderer(textareaRenderer);
+
+// src/field-types/rich-text.ts
+var richTextRenderer = {
+  name: "richText",
+  render(target, value) {
+    if (isLexicalContent(value)) {
+      target.element.innerHTML = lexicalToHtml(value);
+      return;
+    }
+    if (typeof value === "string") {
+      target.element.innerHTML = sanitizeHtml(value);
+    }
+  }
+};
+registerBuiltinRenderer(richTextRenderer);
+
+// src/field-types/html.ts
+var htmlRenderer = {
+  name: "html",
+  render(target, value) {
+    if (value === null || value === void 0) {
+      target.element.textContent = "";
+      return;
+    }
+    const html = typeof value === "string" ? value : safeStringify(value);
+    target.element.innerHTML = sanitizeHtml(html);
+  }
+};
+registerBuiltinRenderer(htmlRenderer);
+
+// src/field-types/url.ts
+var urlRenderer = {
+  name: "url",
+  render(target, value, context) {
+    const element = target.element;
+    const text = safeStringify(value);
+    if (element.tagName === "A") {
+      const anchor = element;
+      const hrefField = target.hrefField;
+      const hrefSource = hrefField ? context.allFields[hrefField] : value;
+      if (typeof hrefSource === "string" && isSafeUrl(hrefSource)) {
+        anchor.href = hrefSource;
+      }
+      anchor.textContent = text;
+      return;
+    }
+    if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
+      element.value = text;
+      return;
+    }
+    element.textContent = text;
+  }
+};
+registerBuiltinRenderer(urlRenderer);
+registerBuiltinRenderer({ ...urlRenderer, name: "email" });
+
+// src/field-types/image.ts
+var imageRenderer = {
+  name: "image",
+  render(target, value, context) {
+    const element = target.element;
+    const media = readMedia(value);
+    const url = pickUrl(media, value);
+    if (url === void 0) return;
+    if (element.tagName === "IMG") {
+      const img = element;
+      img.src = url;
+      const alt = pickAlt(media, target.altField, context.allFields);
+      if (alt !== void 0) img.alt = alt;
+      return;
+    }
+    element.style.backgroundImage = `url('${escapeCssUrl(url)}')`;
+  }
+};
+function readMedia(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  return value;
+}
+function pickUrl(media, value) {
+  if (media?.url !== void 0 && isSafeUrl(media.url)) return media.url;
+  if (typeof value === "string" && isSafeUrl(value)) return value;
+  return void 0;
+}
+function pickAlt(media, altField, allFields) {
+  if (media?.alt !== void 0) return media.alt;
+  if (altField !== void 0) {
+    const sibling = allFields[altField];
+    if (typeof sibling === "string") return sibling;
+  }
+  return void 0;
+}
+registerBuiltinRenderer(imageRenderer);
+
+// src/field-types/upload.ts
+var uploadRenderer2 = {
+  name: "upload",
+  render(target, value) {
+    const element = target.element;
+    const media = readMedia2(value);
+    if (media === void 0) return;
+    const url = media.url;
+    if (typeof url !== "string" || !isSafeUrl(url)) return;
+    if (element.tagName === "IMG") {
+      const img = element;
+      img.src = url;
+      if (media.alt !== void 0) img.alt = media.alt;
+      return;
+    }
+    if (element.tagName === "A") {
+      const anchor = element;
+      anchor.href = url;
+      anchor.textContent = media.filename ?? url;
+      return;
+    }
+    const label = media.filename !== void 0 ? escapeHtml(media.filename) : escapeHtml(url);
+    element.innerHTML = `<a href="${escapeHtmlAttribute(url)}">${label}</a>`;
+  }
+};
+function readMedia2(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  return value;
+}
+registerBuiltinRenderer(uploadRenderer2);
+
+// src/field-types/relationship.ts
+var relationshipRenderer2 = {
+  name: "relationship",
+  render(target, value) {
+    const element = target.element;
+    const labels = collectLabels(value);
+    const text = labels.join(", ");
+    if (element.tagName === "A" && !Array.isArray(value)) {
+      const anchor = element;
+      const url = value?.url;
+      if (typeof url === "string" && isSafeUrl(url)) anchor.href = url;
+      anchor.textContent = text;
+      return;
+    }
+    element.textContent = text;
+  }
+};
+function collectLabels(value) {
+  if (value === null || value === void 0) return [""];
+  if (Array.isArray(value)) return value.map(pickLabel2);
+  return [pickLabel2(value)];
+}
+function pickLabel2(value) {
+  if (typeof value === "object" && value !== null) {
+    const rel = value;
+    if (typeof rel.title === "string" && rel.title.length > 0) return rel.title;
+    if (typeof rel.name === "string" && rel.name.length > 0) return rel.name;
+    if (typeof rel.slug === "string" && rel.slug.length > 0) return rel.slug;
+    if (rel.id !== void 0) return String(rel.id);
+    return "";
+  }
+  return safeStringify(value);
+}
+registerBuiltinRenderer(relationshipRenderer2);
+
+// src/field-types/select.ts
+var selectRenderer = {
+  name: "select",
+  render(target, value) {
+    const element = target.element;
+    const text = stringify(value);
+    if (element.tagName === "SELECT") {
+      element.value = text;
+      return;
+    }
+    if (element.tagName === "INPUT" && element.type === "radio") {
+      const radio = element;
+      radio.checked = radio.value === text;
+      return;
+    }
+    element.textContent = text;
+  }
+};
+function stringify(value) {
+  if (Array.isArray(value)) return value.map((v) => stringify(v)).join(", ");
+  return safeStringify(value);
+}
+registerBuiltinRenderer(selectRenderer);
+registerBuiltinRenderer({ ...selectRenderer, name: "radio" });
+
+// src/field-types/checkbox.ts
+var checkboxRenderer = {
+  name: "checkbox",
+  render(target, value) {
+    const element = target.element;
+    const checked = Boolean(value);
+    if (element.tagName === "INPUT" && element.type === "checkbox") {
+      element.checked = checked;
+      return;
+    }
+    if (element.hasAttribute("aria-checked")) {
+      element.setAttribute("aria-checked", checked ? "true" : "false");
+      return;
+    }
+    element.textContent = checked ? "true" : "false";
+  }
+};
+registerBuiltinRenderer(checkboxRenderer);
+
+// src/core/intl-cache.ts
+var NUMBER_CACHE = /* @__PURE__ */ new Map();
+var DATE_CACHE = /* @__PURE__ */ new Map();
+var DEFAULT_MAX_ENTRIES = 64;
+var maxEntries = DEFAULT_MAX_ENTRIES;
+function getNumberFormat(locale, options) {
+  const key = buildKey(locale, options);
+  const cached = NUMBER_CACHE.get(key);
+  if (cached !== void 0) {
+    NUMBER_CACHE.delete(key);
+    NUMBER_CACHE.set(key, cached);
+    return cached;
+  }
+  const formatter = new Intl.NumberFormat(locale, options);
+  NUMBER_CACHE.set(key, formatter);
+  trimToLimit(NUMBER_CACHE);
+  return formatter;
+}
+function getDateTimeFormat(locale, options) {
+  const key = buildKey(locale, options);
+  const cached = DATE_CACHE.get(key);
+  if (cached !== void 0) {
+    DATE_CACHE.delete(key);
+    DATE_CACHE.set(key, cached);
+    return cached;
+  }
+  const formatter = new Intl.DateTimeFormat(locale, options);
+  DATE_CACHE.set(key, formatter);
+  trimToLimit(DATE_CACHE);
+  return formatter;
+}
+function buildKey(locale, options) {
+  const localePart = locale ?? "";
+  if (options === void 0 || options === null) return localePart;
+  const serialised = stableStringify(options);
+  if (serialised === "{}") return localePart;
+  return `${localePart}|${serialised}`;
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((v) => stableStringify(v)).join(",")}]`;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort();
+  const parts = [];
+  for (const key of keys) {
+    const inner = record[key];
+    if (inner === void 0) continue;
+    parts.push(`${JSON.stringify(key)}:${stableStringify(inner)}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+function trimToLimit(map) {
+  while (map.size > maxEntries) {
+    const oldest = map.keys().next().value;
+    if (oldest === void 0) break;
+    map.delete(oldest);
+  }
+}
+
+// src/field-types/date.ts
+var dateRenderer = {
+  name: "date",
+  render(target, value, context) {
+    const element = target.element;
+    if (value === null || value === void 0 || value === "") {
+      if (element.tagName === "INPUT") {
+        element.value = "";
+      } else if (element.tagName === "TIME") {
+        element.removeAttribute("datetime");
+        element.textContent = "";
+      } else {
+        element.textContent = "";
+      }
+      return;
+    }
+    const iso = typeof value === "string" ? value : safeStringify(value);
+    const date = new Date(iso);
+    const isValid = !Number.isNaN(date.getTime());
+    if (element.tagName === "INPUT") {
+      element.value = isValid ? toIsoForInput(element.type, date) : iso;
+      return;
+    }
+    if (element.tagName === "TIME") {
+      element.setAttribute("datetime", isValid ? date.toISOString() : iso);
+      element.textContent = isValid ? formatDate(date, context) : iso;
+      return;
+    }
+    element.textContent = isValid ? formatDate(date, context) : iso;
+  }
+};
+function formatDate(date, context) {
+  const locale = context.locale ?? detectInitialLocale();
+  try {
+    return getDateTimeFormat(locale, { dateStyle: "medium", timeStyle: "short" }).format(date);
+  } catch {
+    return date.toISOString();
+  }
+}
+function toIsoForInput(type, date) {
+  if (type === "date") return date.toISOString().slice(0, 10);
+  if (type === "datetime-local") return date.toISOString().slice(0, 16);
+  return date.toISOString();
+}
+registerBuiltinRenderer(dateRenderer);
+
+// src/field-types/number.ts
+var numberRenderer = {
+  name: "number",
+  render(target, value, context) {
+    const element = target.element;
+    if (value === null || value === void 0 || value === "") {
+      if (element.tagName === "INPUT") element.value = "";
+      else element.textContent = "";
+      return;
+    }
+    const num = typeof value === "number" ? value : Number(safeStringify(value));
+    if (Number.isNaN(num)) {
+      element.textContent = safeStringify(value);
+      return;
+    }
+    if (element.tagName === "INPUT") {
+      element.value = String(num);
+      return;
+    }
+    element.textContent = format(num, context);
+  }
+};
+function format(num, context) {
+  const locale = context.locale ?? detectInitialLocale();
+  try {
+    return getNumberFormat(locale).format(num);
+  } catch {
+    return String(num);
+  }
+}
+registerBuiltinRenderer(numberRenderer);
+
+// src/field-types/array.ts
+var arrayRenderer = {
+  name: "array",
+  render(target, value) {
+    const element = target.element;
+    if (!Array.isArray(value)) return;
+    const template = target.arrayTemplate;
+    if (template !== void 0 && template.length > 0) {
+      const html = renderTemplate(template, value);
+      element.innerHTML = sanitizeHtml(html);
+      return;
+    }
+    const separator = target.arraySeparator ?? ", ";
+    element.textContent = value.map(stringify2).join(separator);
+  }
+};
+function renderTemplate(template, items) {
+  let out = "";
+  for (let i = 0; i < items.length; i += 1) {
+    out += interpolate(template, items[i], i);
+  }
+  return out;
+}
+function interpolate(template, item, index) {
+  let out = template;
+  if (typeof item === "object" && item !== null) {
+    for (const [key, value] of Object.entries(item)) {
+      const pattern = new RegExp(`\\{\\{${escapeRegex(key)}\\}\\}`, "g");
+      out = out.replace(pattern, escapeHtml(safeStringify(value)));
+    }
+  } else {
+    out = out.replace(/\{\{value\}\}/g, escapeHtml(safeStringify(item)));
+  }
+  out = out.replace(/\{\{index\}\}/g, String(index));
+  return out;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stringify2(value) {
+  return safeStringify(value);
+}
+registerBuiltinRenderer(arrayRenderer);
+registerBuiltinRenderer({ ...arrayRenderer, name: "blocks" });
+
+// src/core/view-transitions.ts
+function viewTransitionsSupported() {
+  if (typeof document === "undefined") return false;
+  return typeof document.startViewTransition === "function";
+}
+async function runWithTransition(callback) {
+  if (!viewTransitionsSupported()) {
+    callback();
+    return;
+  }
+  const start = document.startViewTransition;
+  const transition = start.call(document, callback);
+  try {
+    await transition.finished;
+  } catch {
+  }
+}
+
+// src/core/structural-applier.ts
+var KEY_ATTRIBUTE = "data-payload-key";
+var NESTED_KEY_ATTRIBUTE = "data-payload-nested-key";
+var NESTED_TEMPLATE_ATTRIBUTE = "data-payload-nested-template";
+var previousItemValues = /* @__PURE__ */ new WeakMap();
+function applyStructuralPatches(options) {
+  const { template, container, patches } = options;
+  const memory = getMemory(container);
+  const removes = [];
+  const inserts = [];
+  const moves = [];
+  const updates = [];
+  const replaces = [];
+  for (const patch of patches) {
+    if (patch.kind === "remove") removes.push(patch);
+    else if (patch.kind === "insert") inserts.push(patch);
+    else if (patch.kind === "move") moves.push(patch);
+    else if (patch.kind === "update") updates.push(patch);
+    else replaces.push(patch);
+  }
+  removes.sort((a, b) => indexOf(b) - indexOf(a));
+  for (const patch of removes) {
+    if (patch.kind !== "remove") continue;
+    const node = container.children[patch.index];
+    node?.remove();
+    forgetItem(memory, patch.value);
+  }
+  for (const patch of replaces) {
+    if (patch.kind !== "replace") continue;
+    const node = container.children[patch.index];
+    const replacement = renderItem(template, patch.value, patch.index);
+    if (!node || !replacement) continue;
+    populateNestedSlots(replacement, patch.value);
+    container.replaceChild(replacement, node);
+    rememberItem(memory, patch.value);
+  }
+  for (const patch of updates) {
+    if (patch.kind !== "update") continue;
+    const oldNode = container.children[patch.index];
+    const newNode = renderItem(template, patch.value, patch.index);
+    if (!oldNode || !newNode) continue;
+    reconcileNestedSlots(oldNode, newNode, patch.value, memory);
+    container.replaceChild(newNode, oldNode);
+    rememberItem(memory, patch.value);
+  }
+  inserts.sort((a, b) => indexOf(a) - indexOf(b));
+  for (const patch of inserts) {
+    if (patch.kind !== "insert") continue;
+    const before = container.children[patch.index] ?? null;
+    const node = renderItem(template, patch.value, patch.index);
+    if (!node) continue;
+    populateNestedSlots(node, patch.value);
+    container.insertBefore(node, before);
+    rememberItem(memory, patch.value);
+  }
+  for (const patch of moves) {
+    if (patch.kind !== "move") continue;
+    const key = readKey(patch.value);
+    const node = key !== void 0 ? findByKey(container, key) : null;
+    if (!node) continue;
+    const before = container.children[patch.to] ?? null;
+    if (node === before) continue;
+    container.insertBefore(node, before);
+  }
+}
+function populateNestedSlots(item, value) {
+  const slots = item.querySelectorAll(`[${NESTED_KEY_ATTRIBUTE}]`);
+  for (const slot of Array.from(slots)) {
+    const key = slot.getAttribute(NESTED_KEY_ATTRIBUTE);
+    if (key === null) continue;
+    const nestedTemplate = slot.getAttribute(NESTED_TEMPLATE_ATTRIBUTE);
+    if (!nestedTemplate) continue;
+    const nestedItems = readNestedArray(value, key);
+    if (nestedItems === void 0) continue;
+    const patches = diffArray([], nestedItems);
+    if (patches.length === 0) continue;
+    applyStructuralPatches({
+      template: nestedTemplate,
+      container: slot,
+      patches});
+  }
+}
+function reconcileNestedSlots(oldItem, newItem, nextValue, memory) {
+  const oldSlots = oldItem.querySelectorAll(`[${NESTED_KEY_ATTRIBUTE}]`);
+  if (oldSlots.length === 0) return;
+  const itemKey = readKey(nextValue);
+  const prevValue = itemKey !== void 0 ? memory.get(itemKey) : void 0;
+  for (const oldSlot of Array.from(oldSlots)) {
+    const key = oldSlot.getAttribute(NESTED_KEY_ATTRIBUTE);
+    if (key === null) continue;
+    const newSlot = newItem.querySelector(`[${NESTED_KEY_ATTRIBUTE}="${cssEscape(key)}"]`);
+    if (!newSlot) continue;
+    newSlot.replaceWith(oldSlot);
+    const nestedTemplate = oldSlot.getAttribute(NESTED_TEMPLATE_ATTRIBUTE) ?? newSlot.getAttribute(NESTED_TEMPLATE_ATTRIBUTE);
+    if (!nestedTemplate) continue;
+    const nextNested = readNestedArray(nextValue, key) ?? [];
+    const prevNested = readNestedArray(prevValue, key) ?? [];
+    const patches = diffArray(prevNested, nextNested);
+    if (patches.length === 0) continue;
+    applyStructuralPatches({
+      template: nestedTemplate,
+      container: oldSlot,
+      patches});
+  }
+}
+function readNestedArray(value, key) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const nested = value[key];
+  if (!Array.isArray(nested)) return void 0;
+  return nested;
+}
+function getMemory(container) {
+  let map = previousItemValues.get(container);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    previousItemValues.set(container, map);
+  }
+  return map;
+}
+function rememberItem(memory, value) {
+  const key = readKey(value);
+  if (key === void 0) return;
+  memory.set(key, value);
+}
+function forgetItem(memory, value) {
+  const key = readKey(value);
+  if (key === void 0) return;
+  memory.delete(key);
+}
+function indexOf(patch) {
+  if (patch.kind === "move") return patch.to;
+  return patch.index;
+}
+function readKey(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const id = value["id"];
+  if (typeof id === "string" || typeof id === "number") return String(id);
+  return void 0;
+}
+function findByKey(container, key) {
+  return container.querySelector(`[${KEY_ATTRIBUTE}="${cssEscape(key)}"]`);
+}
+function cssEscape(value) {
+  const css = globalThis.CSS;
+  if (css?.escape) return css.escape(value);
+  return value.replace(/[^a-zA-Z0-9_-]/g, "\\$&");
+}
+function renderItem(template, value, index) {
+  if (typeof document === "undefined") return null;
+  const filled = fillTemplate(template, value, index);
+  const safe = sanitizeHtml(filled);
+  const host = document.createElement("template");
+  host.innerHTML = safe;
+  const first = host.content.firstElementChild;
+  if (!first) return null;
+  const key = readKey(value);
+  if (key !== void 0) first.setAttribute(KEY_ATTRIBUTE, key);
+  return first;
+}
+function fillTemplate(template, value, index) {
+  let out = template;
+  if (typeof value === "object" && value !== null) {
+    for (const [key, raw] of Object.entries(value)) {
+      const pattern = new RegExp(`\\{\\{${escapeRegex2(key)}\\}\\}`, "g");
+      const replacement = escapeHtml(stringifyForTemplate(raw));
+      out = out.replace(pattern, () => replacement);
+    }
+  } else {
+    const replacement = escapeHtml(stringifyForTemplate(value));
+    out = out.replace(/\{\{value\}\}/g, () => replacement);
+  }
+  return out.replace(/\{\{index\}\}/g, String(index));
+}
+function stringifyForTemplate(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+function escapeRegex2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/field-types/structural-array.ts
+var previousValues = /* @__PURE__ */ new WeakMap();
+var warnedContainers = /* @__PURE__ */ new WeakSet();
+var structuralArrayRenderer = {
+  name: "structural-array",
+  render(target, value) {
+    if (!Array.isArray(value)) return;
+    const container = target.element;
+    const template = target.arrayTemplate;
+    if (template === void 0 || template.length === 0) {
+      warnMissingTemplate(container, target.fieldName);
+      return;
+    }
+    const previous = previousValues.get(container) ?? [];
+    const patches = diffArray(previous, value);
+    if (patches.length === 0) {
+      previousValues.set(container, value.slice());
+      return;
+    }
+    void runWithTransition(() => {
+      applyStructuralPatches({
+        template,
+        container,
+        patches});
+    });
+    previousValues.set(container, value.slice());
+  }
+};
+function warnMissingTemplate(container, fieldName) {
+  if (warnedContainers.has(container)) return;
+  warnedContainers.add(container);
+  console.warn(
+    `[live-preview] Skipping structural update for "${fieldName}" \u2014 the <${container.tagName.toLowerCase()}> with data-payload-structural is missing data-payload-array-template. Add an inline template (e.g., data-payload-array-template="<li>{{label}}</li>") so the renderer can materialise new items.`
+  );
+}
+registerBuiltinRenderer(structuralArrayRenderer);
+
+// src/field-types/index.ts
+var BUILTIN = [
+  textRenderer2,
+  textareaRenderer,
+  richTextRenderer,
+  htmlRenderer,
+  urlRenderer,
+  { ...urlRenderer, name: "email" },
+  imageRenderer,
+  uploadRenderer2,
+  relationshipRenderer2,
+  selectRenderer,
+  { ...selectRenderer, name: "radio" },
+  checkboxRenderer,
+  dateRenderer,
+  numberRenderer,
+  arrayRenderer,
+  { ...arrayRenderer, name: "blocks" },
+  structuralArrayRenderer
+];
+function buildBuiltinRenderers2() {
+  return buildBuiltinRenderers(BUILTIN);
+}
+
+// src/client/index.ts
+var LivePreviewClient = class {
+  #emitter = new EventEmitter();
+  #detector;
+  #renderers;
+  #runtime;
+  #plugins;
+  #log;
+  #started = false;
+  #destroyed = false;
+  constructor(config = {}) {
+    const debug = config.debug ?? isDevMode();
+    this.#log = debug ? (...args) => {
+      console.debug("[live-preview]", ...args);
+    } : () => {
+    };
+    this.#detector = new OriginDetector({
+      ...config.allowedOrigins !== void 0 ? { additionalOrigins: config.allowedOrigins } : {},
+      ...config.disableReferrerDetection !== void 0 ? { enableReferrerDetection: !config.disableReferrerDetection } : {},
+      ...config.disableLocalhostMatching !== void 0 ? { enableLocalhostMatching: !config.disableLocalhostMatching } : {}
+    });
+    if (this.#detector.isProductionUnconfigured) {
+      this.#log("no trusted origin could be detected \u2014 set allowedOrigins or PAYLOAD_ADMIN_ORIGIN");
+    }
+    const builtin = buildBuiltinRenderers2();
+    this.#renderers = { ...builtin };
+    this.#plugins = new PluginManager({
+      events: this.#emitter,
+      config: Object.freeze({ ...config }),
+      registerFieldRenderer: (renderer) => {
+        this.#renderers[renderer.name] = renderer;
+      },
+      log: this.#log
+    });
+    this.#runtime = new LivePreviewRuntime({
+      ...config.root !== void 0 ? { root: config.root } : {},
+      renderers: this.#renderers,
+      originMatcher: (origin) => this.#detector.matches(origin),
+      readyTargets: this.#detector.enumerate(),
+      emitter: this.#emitter,
+      ...config.serverURL !== void 0 && config.serverURL !== "" ? {
+        dataMerge: {
+          serverURL: config.serverURL,
+          ...config.apiRoute !== void 0 ? { apiRoute: config.apiRoute } : {},
+          ...config.mergeDepth !== void 0 ? { depth: config.mergeDepth } : {},
+          ...config.mergeFetch !== void 0 ? { fetchFn: config.mergeFetch } : {}
+        }
+      } : {},
+      ...config.debounceMs !== void 0 ? { debounceMs: config.debounceMs } : {},
+      ...config.heartbeatMs !== void 0 ? { heartbeatMs: config.heartbeatMs } : {},
+      ...config.intersectionRootMargin !== void 0 ? { intersectionRootMargin: config.intersectionRootMargin } : {},
+      ...config.disableVisibilityGate !== void 0 ? { disableVisibilityGate: config.disableVisibilityGate } : {},
+      ...config.visibilityGateThreshold !== void 0 ? { visibilityGateThreshold: config.visibilityGateThreshold } : {},
+      ...config.enableA11y !== void 0 ? { enableA11y: config.enableA11y } : {},
+      ...config.a11yLocale !== void 0 ? { a11yLocale: config.a11yLocale } : {},
+      onHeartbeatTimeout: () => {
+        this.#detector.unlockOrigin();
+      },
+      ...config.validateToken !== void 0 ? { validateToken: config.validateToken } : {},
+      log: this.#log
+    });
+    this.#emitter.on("connect", (e) => {
+      this.#detector.lockOrigin(e.origin);
+    });
+    if (config.autoStart !== false) {
+      this.start();
+    }
+  }
+  /**
+   * Start the runtime. Returns `true` when the runtime actually
+   * started (it may refuse to start outside a preview context).
+   */
+  start() {
+    if (this.#destroyed) return false;
+    if (this.#started) return true;
+    if (!isInPreviewContext()) return false;
+    this.#started = true;
+    return this.#runtime.start();
+  }
+  /**
+   * Stop the runtime and tear down every plugin. Idempotent.
+   */
+  async destroy() {
+    if (this.#destroyed) return;
+    this.#destroyed = true;
+    this.#runtime.destroy();
+    await this.#plugins.destroyAll();
+    this.#emitter.removeAllListeners();
+  }
+  /**
+   * Register a plugin.
+   */
+  async use(plugin) {
+    if (this.#destroyed) throw new Error("LivePreviewClient: already destroyed");
+    await this.#plugins.register(plugin);
+  }
+  /**
+   * Unregister a plugin by name.
+   */
+  async unuse(name) {
+    await this.#plugins.unregister(name);
+  }
+  /** Rebuild the element cache manually. */
+  refreshCache() {
+    this.#runtime.refreshCache();
+  }
+  /** Read-only access to the event emitter for `on`/`once`/`off`. */
+  get events() {
+    return this.#emitter;
+  }
+  /** Names of currently registered plugins. */
+  get plugins() {
+    return this.#plugins.list();
+  }
+  /** Current connection status. */
+  get status() {
+    return this.#runtime.status;
+  }
+  /** Number of valid updates received so far. */
+  get updateCount() {
+    return this.#runtime.updateCount;
+  }
+  /** `true` once `destroy()` has been called. */
+  get destroyed() {
+    return this.#destroyed;
+  }
+};
+function initLivePreview(config = {}) {
+  const client = new LivePreviewClient({ ...config, autoStart: false });
+  return client.start() ? client : null;
+}
+
+// src/inline/runtime.generated.ts
+var RUNTIME_SOURCE = '"use strict";(()=>{var Jr=Object.defineProperty;var Dn=t=>{throw TypeError(t)};var Zr=(t,e,n)=>e in t?Jr(t,e,{enumerable:!0,configurable:!0,writable:!0,value:n}):t[e]=n;var $n=(t,e,n)=>Zr(t,typeof e!="symbol"?e+"":e,n),Ot=(t,e,n)=>e.has(t)||Dn("Cannot "+n);var i=(t,e,n)=>(Ot(t,e,"read from private field"),n?n.call(t):e.get(t)),l=(t,e,n)=>e.has(t)?Dn("Cannot add the same private member more than once"):e instanceof WeakSet?e.add(t):e.set(t,n),d=(t,e,n,r)=>(Ot(t,e,"write to private field"),r?r.call(t,n):e.set(t,n),n),f=(t,e,n)=>(Ot(t,e,"access private method"),n);var F,_,te,Pt,Ft,bt=class{constructor(){l(this,te);l(this,F,new Map);l(this,_,new Map)}on(e,n){return f(this,te,Pt).call(this,i(this,F),e,n)}once(e,n){return f(this,te,Pt).call(this,i(this,_),e,n)}off(e,n){i(this,F).get(e)?.delete(n),i(this,_).get(e)?.delete(n)}async emit(e,n){let r=i(this,F).get(e);if(r)for(let s of[...r])await f(this,te,Ft).call(this,s,n,e);let o=i(this,_).get(e);if(o&&o.size>0){let s=[...o];i(this,_).delete(e);for(let a of s)await f(this,te,Ft).call(this,a,n,e)}}listenerCount(e){return(i(this,F).get(e)?.size??0)+(i(this,_).get(e)?.size??0)}removeAllListeners(e){if(e===void 0){i(this,F).clear(),i(this,_).clear();return}i(this,F).delete(e),i(this,_).delete(e)}eventNames(){let e=new Set;for(let n of i(this,F).keys())e.add(n);for(let n of i(this,_).keys())e.add(n);return[...e]}};F=new WeakMap,_=new WeakMap,te=new WeakSet,Pt=function(e,n,r){let o=e.get(n);return o||(o=new Set,e.set(n,o)),o.add(r),()=>{e.get(n)?.delete(r)}},Ft=async function(e,n,r){try{await e(n)}catch(o){let s=typeof r=="string"||typeof r=="number"?String(r):"<event>";console.error(`[live-preview] handler for "${s}" threw:`,o)}};var le="data-payload-field",Un="data-payload-type",Qr="data-payload-attribute",ei="data-payload-href",ti="data-payload-src",ni="data-payload-alt",ri="data-payload-array-template",ii="data-payload-array-separator",oi="data-payload-locale",si=`[${le}]`,Hn=new Set(["text","textarea","richText","email","number","checkbox","date","select","radio","array","blocks","group","tabs","row","collapsible","relationship","upload","point","json","code","ui","html","url","image","structural-array"]),k,W,Te,ne,Dt,$t,Rt=class{constructor(e={}){l(this,ne);l(this,k,new Map);l(this,W,new WeakMap);l(this,Te);d(this,Te,e.filter??di)}buildFromRoot(e){let n=performance.now();i(this,k).clear();let r=e.querySelectorAll(si),o=0;for(let s of r){if(!i(this,Te).call(this,s))continue;let a=f(this,ne,$t).call(this,s);a&&(f(this,ne,Dt).call(this,a),i(this,W).set(s,a),o+=1)}return{elementCount:o,fieldCount:i(this,k).size,durationMs:performance.now()-n}}add(e){if(!i(this,Te).call(this,e))return;let n=f(this,ne,$t).call(this,e);if(n)return f(this,ne,Dt).call(this,n),i(this,W).set(e,n),n}remove(e){let n=i(this,W).get(e);if(!n)return!1;i(this,W).delete(e);let r=i(this,k).get(n.fieldName);if(!r)return!1;let o=r.indexOf(n);return o<0?!1:(r.splice(o,1),r.length===0&&i(this,k).delete(n.fieldName),!0)}get(e){return i(this,k).get(e)}getByElement(e){return i(this,W).get(e)}get fieldCount(){return i(this,k).size}get elementCount(){let e=0;for(let n of i(this,k).values())e+=n.length;return e}entries(){return i(this,k).entries()}*values(){for(let e of i(this,k).values())yield*e}has(e){return i(this,W).has(e)}clear(){i(this,k).clear()}};k=new WeakMap,W=new WeakMap,Te=new WeakMap,ne=new WeakSet,Dt=function(e){let n=i(this,k).get(e.fieldName);if(n){n.push(e);return}i(this,k).set(e.fieldName,[e])},$t=function(e){let n=e.getAttribute(le);if(n===null||n.length===0)return;let r=e.getAttribute(Un),o=ai(e),s=e.getAttribute(Qr),a=e.getAttribute(ei),u=e.getAttribute(ti),m=e.getAttribute(ni),w=e.getAttribute(ri),c=e.getAttribute(ii),b=e.getAttribute(oi);return{element:e,fieldName:n,fieldType:o,explicitFieldType:r!==null&&Hn.has(r),...s!==null&&s.length>0?{targetAttribute:s}:{},...a!==null?{hrefField:a}:{},...u!==null?{srcField:u}:{},...m!==null?{altField:m}:{},...w!==null?{arrayTemplate:w}:{},...c!==null?{arraySeparator:c}:{},...b!==null?{locale:b}:{}}};function ai(t){let e=t.getAttribute(Un);if(e!==null&&Hn.has(e))return e;if(t.hasAttribute("data-payload-richtext"))return"richText";if(t.hasAttribute("data-payload-html"))return"html";if(t.hasAttribute("data-payload-structural"))return"structural-array";if(t.hasAttribute("data-payload-array"))return"array";if(t.tagName==="IMG")return"image";if(t.tagName==="A")return"url";if(t.tagName==="TIME")return"date";if(t.tagName==="INPUT"){let n=t.type;if(n==="checkbox")return"checkbox";if(n==="number")return"number";if(n==="date"||n==="datetime-local")return"date"}return"text"}function di(){return!0}var li=100,ui="200px",ue,De,$e,M,ce,re,D,we,jn,Vn,Tt=class{constructor(e,n={}){l(this,we);l(this,ue);l(this,De);l(this,$e);l(this,M,new Set);l(this,ce,null);l(this,re,null);l(this,D,null);d(this,ue,e),d(this,De,n.mutationDebounceMs??li),d(this,$e,n.intersectionRootMargin??ui)}start(e){d(this,ce,new MutationObserver(n=>{f(this,we,jn).call(this,n)})),i(this,ce).observe(e,{childList:!0,subtree:!0,attributes:!0,attributeFilter:[le]}),d(this,re,new IntersectionObserver(n=>{f(this,we,Vn).call(this,n)},{rootMargin:i(this,$e),threshold:0}))}observeElement(e){i(this,re)?.observe(e)}unobserveElement(e){i(this,re)?.unobserve(e),i(this,M).delete(e)}markVisible(e,n){n?i(this,M).add(e):i(this,M).delete(e)}isVisible(e){return i(this,M).has(e)}stop(){i(this,D)!==null&&(clearTimeout(i(this,D)),d(this,D,null)),i(this,ce)?.disconnect(),i(this,re)?.disconnect(),d(this,ce,null),d(this,re,null),i(this,M).clear()}};ue=new WeakMap,De=new WeakMap,$e=new WeakMap,M=new WeakMap,ce=new WeakMap,re=new WeakMap,D=new WeakMap,we=new WeakSet,jn=function(e){ci(e)&&(i(this,D)!==null&&clearTimeout(i(this,D)),d(this,D,setTimeout(()=>{d(this,D,null),i(this,ue).onStructuralChange()},i(this,De))))},Vn=function(e){for(let n of e){let r=n.target;n.isIntersecting?i(this,M).has(r)||(i(this,M).add(r),i(this,ue).onVisibilityChange(r,!0)):i(this,M).has(r)&&(i(this,M).delete(r),i(this,ue).onVisibilityChange(r,!1))}};function ci(t){for(let e of t){if(e.type==="attributes"&&e.attributeName===le)return!0;for(let n of e.addedNodes)if(Bn(n))return!0;for(let n of e.removedNodes)if(Bn(n))return!0}return!1}function Bn(t){if(t.nodeType!==Node.ELEMENT_NODE)return!1;let e=t;return e.hasAttribute(le)?!0:e.querySelector(`[${le}]`)!==null}var fi={basic:1,"schema-json":2,"preview-token":3,"nested-arrays":4,"recursive-diffs":4};function Ut(t){let e=typeof t=="number"&&Number.isFinite(t)&&t>=1?Math.floor(t):void 0,r=Math.min(4,e??1),o=new Set;for(let[s,a]of Object.entries(fi))r>=a&&o.add(s);return{ours:4,...e!==void 0?{theirs:e}:{theirs:void 0},negotiated:r,capabilities:o}}var He,v,xe,fe,ve,Gn,Wn,Ue=class{constructor(e,n){l(this,ve);l(this,He);l(this,v);l(this,xe);l(this,fe,!1);d(this,He,e),d(this,v,n),d(this,xe,r=>{f(this,ve,Gn).call(this,r)})}attach(e=window){i(this,fe)||(e.addEventListener("message",i(this,xe)),d(this,fe,!0))}detach(e=window){i(this,fe)&&(e.removeEventListener("message",i(this,xe)),d(this,fe,!1))}static sendReady(e,n){if(e.length===0||n.length===0)return;let r={type:"payload-live-preview",ready:!0,protocolVersion:4};for(let o of e)for(let s of n)try{o.postMessage(r,s)}catch{}}};He=new WeakMap,v=new WeakMap,xe=new WeakMap,fe=new WeakMap,ve=new WeakSet,Gn=function(e){let n=e.origin;if(!i(this,He).call(this,n)){i(this,v).onInvalid?.("origin",n);return}let r=e.data;if(!pi(r)){i(this,v).onInvalid?.("shape",n);return}switch(r.type){case"payload-live-preview":f(this,ve,Wn).call(this,r,n);return;case"payload-document-event":i(this,v).onDocumentEvent(r,n);return;default:i(this,v).onInvalid?.("type",n)}},Wn=function(e,n){let r=i(this,v).validateToken;if(r===void 0){i(this,v).onUpdate(e,n);return}if(e.ready===!0&&e.data===void 0){i(this,v).onUpdate(e,n);return}let o;try{o=r(e.previewToken,n)}catch{i(this,v).onInvalid?.("token",n);return}if(typeof o=="boolean"){o?i(this,v).onUpdate(e,n):i(this,v).onInvalid?.("token",n);return}o.then(s=>{s?i(this,v).onUpdate(e,n):i(this,v).onInvalid?.("token",n)},()=>{i(this,v).onInvalid?.("token",n)})};function pi(t){return typeof t!="object"||t===null||!("type"in t)?!1:typeof t.type=="string"}var Ee,Be,C,je,xt=class{constructor(e){l(this,Ee);l(this,Be);l(this,C,null);l(this,je,0);d(this,Ee,e.timeoutMs??0),d(this,Be,e.onTimeout)}kick(){d(this,je,Date.now()),!(i(this,Ee)<=0)&&(i(this,C)!==null&&clearTimeout(i(this,C)),d(this,C,setTimeout(()=>{d(this,C,null),i(this,Be).call(this)},i(this,Ee))))}stop(){i(this,C)!==null&&(clearTimeout(i(this,C)),d(this,C,null))}get lastKickAt(){return i(this,je)}get pending(){return i(this,C)!==null}};Ee=new WeakMap,Be=new WeakMap,C=new WeakMap,je=new WeakMap;var pe,Ve,ke,wt,vt=class{constructor(e){l(this,ke);l(this,pe,"disconnected");l(this,Ve);d(this,Ve,e)}get status(){return i(this,pe)}markConnected(){return f(this,ke,wt).call(this,"connected")}markConnecting(){return f(this,ke,wt).call(this,"connecting")}markDisconnected(){return f(this,ke,wt).call(this,"disconnected")}};pe=new WeakMap,Ve=new WeakMap,ke=new WeakSet,wt=function(e){if(i(this,pe)===e)return!1;let n=i(this,pe);return d(this,pe,e),i(this,Ve).call(this,e,n),!0};var mi=()=>{},ze,Ge,We,Ye,me,Y,Et=class{constructor(e){l(this,ze);l(this,Ge);l(this,We);l(this,Ye);l(this,me);l(this,Y,null);d(this,ze,e.serverURL.replace(/\\/+$/,""));let n=e.apiRoute??"/api";d(this,Ge,n.startsWith("/")?n:`/${n}`),d(this,We,e.depth??1),d(this,Ye,e.fetchFn),d(this,me,e.log??mi)}canMerge(e){if(e.globalSlug!==void 0&&e.globalSlug!=="")return!0;if(e.collectionSlug===void 0||e.collectionSlug==="")return!1;let n=e.data.id;return typeof n=="string"||typeof n=="number"}async merge(e){if(!this.canMerge(e))return{status:"unavailable"};let n=i(this,Ye)??(typeof fetch=="function"?fetch:void 0);if(n===void 0)return{status:"unavailable"};i(this,Y)?.abort();let r=new AbortController;d(this,Y,r);let o=e.globalSlug!==void 0&&e.globalSlug!==""?`globals/${e.globalSlug}`:`${e.collectionSlug}/${String(e.data.id)}`,s=`${i(this,ze)}${i(this,Ge)}/${encodeURI(o)}`;try{let a=await n(s,{method:"POST",credentials:"include",headers:{"Content-Type":"application/json","X-Payload-HTTP-Method-Override":"GET"},body:JSON.stringify({data:e.data,depth:i(this,We),flattenLocales:!1,...e.locale!==void 0?{locale:e.locale}:{}}),signal:r.signal});if(!a.ok)return i(this,me).call(this,"merge fetch failed",a.status,s),{status:"unavailable"};let u=await a.json();return u===null||typeof u!="object"||Array.isArray(u)?(i(this,me).call(this,"merge fetch returned non-object",s),{status:"unavailable"}):{status:"merged",doc:u}}catch(a){return r.signal.aborted?{status:"superseded"}:(i(this,me).call(this,"merge fetch error",a),{status:"unavailable"})}finally{i(this,Y)===r&&d(this,Y,null)}}destroy(){i(this,Y)?.abort(),d(this,Y,null)}};ze=new WeakMap,Ge=new WeakMap,We=new WeakMap,Ye=new WeakMap,me=new WeakMap,Y=new WeakMap;var hi=new Set(["http:","https:","mailto:","tel:"]),yi=/^\\s*(?:javascript|data|vbscript|file|blob|about)\\s*:/i,gi=/^(?:\\.{1,2}\\/|[a-zA-Z0-9_-]+\\/?)/;function R(t){if(typeof t!="string"||t.length===0)return!1;let e=t.trim();if(e.length===0||yi.test(e))return!1;if(e.startsWith("#")||e.startsWith("?")||e.startsWith("//")||e.startsWith("/"))return!0;try{let n=new URL(e);return hi.has(n.protocol)}catch{return gi.test(e)}}function kt(t){if(!R(t))return!1;let e=t.trim();return/^https?:\\/\\//i.test(e)||/^\\/\\/[^/]/.test(e)}var bi=new Set(["style","srcdoc","formaction","form","id","name","is","srcset","imagesrcset"]),Ri=new Set(["href","src","poster","cite","action","xlink:href","data"]);function Yn(t,e,n){let r=e.toLowerCase().trim();if(r.length===0||r.startsWith("on")||bi.has(r))return"blocked";if(n==null)return t.removeAttribute(r),"applied";if(typeof n!="string"&&typeof n!="number"&&typeof n!="boolean")return"blocked";let o=String(n);return Ri.has(r)&&!R(o)?"blocked":(t.setAttribute(r,o),"applied")}var Se,qe,Ke,Xe,Je,Ze,Qe,et,Ae,$,q,S,U,K,qn,Kn,Ht,St=class{constructor(e,n){l(this,K);l(this,Se);l(this,qe);l(this,Ke);l(this,Xe);l(this,Je);l(this,Ze);l(this,Qe);l(this,et);l(this,Ae);l(this,$,new Map);l(this,q,new Map);l(this,S,null);l(this,U,null);d(this,Se,e),d(this,qe,n.debounceMs??50),d(this,Ke,n.isVisible),d(this,Xe,n.visibilityGateThreshold??50),d(this,Je,n.disableVisibilityGate??!1),d(this,Ze,n.getCacheSize),d(this,Qe,n.onFlush),d(this,et,n.scheduleFrame??(typeof requestAnimationFrame=="function"?requestAnimationFrame.bind(globalThis):r=>setTimeout(()=>{r(performance.now())},0))),d(this,Ae,n.cancelFrame??(typeof cancelAnimationFrame=="function"?cancelAnimationFrame.bind(globalThis):r=>{clearTimeout(r)}))}schedule(e){let n=i(this,$).get(e.target.element);n?(n.value=e.value,n.allFields=e.allFields):i(this,$).set(e.target.element,{target:e.target,value:e.value,allFields:e.allFields}),f(this,K,qn).call(this)}flushNow(){return i(this,S)!==null&&(clearTimeout(i(this,S)),d(this,S,null)),f(this,K,Ht).call(this)}notifyVisible(e){let n=i(this,q).get(e);n&&(i(this,q).delete(e),i(this,Se).call(this,n))}forget(e){i(this,$).delete(e),i(this,q).delete(e)}destroy(){i(this,S)!==null&&(clearTimeout(i(this,S)),d(this,S,null)),i(this,U)!==null&&(i(this,Ae).call(this,i(this,U)),d(this,U,null)),i(this,$).clear(),i(this,q).clear()}get pendingCount(){return i(this,$).size}get replayCount(){return i(this,q).size}};Se=new WeakMap,qe=new WeakMap,Ke=new WeakMap,Xe=new WeakMap,Je=new WeakMap,Ze=new WeakMap,Qe=new WeakMap,et=new WeakMap,Ae=new WeakMap,$=new WeakMap,q=new WeakMap,S=new WeakMap,U=new WeakMap,K=new WeakSet,qn=function(){i(this,S)!==null&&clearTimeout(i(this,S)),d(this,S,setTimeout(()=>{d(this,S,null),f(this,K,Kn).call(this)},i(this,qe)))},Kn=function(){i(this,U)!==null&&i(this,Ae).call(this,i(this,U)),d(this,U,i(this,et).call(this,()=>{d(this,U,null),f(this,K,Ht).call(this)}))},Ht=function(){var u;let e=performance.now(),n=!i(this,Je)&&i(this,Ze).call(this)>i(this,Xe),r=i(this,$);d(this,$,new Map);let o=0,s=0;for(let m of r.values()){if(n&&!i(this,Ke).call(this,m.target.element)){i(this,q).set(m.target.element,m),s+=1;continue}i(this,Se).call(this,m),o+=1}let a={applied:o,deferred:s,durationMs:performance.now()-e};return(u=i(this,Qe))==null||u.call(this,a),a};function Le(){let t=Ti();if(t!==void 0)return t;let e=wi();return e!==void 0?e:"en"}function Ti(){if(typeof document>"u")return;let t=document.documentElement.getAttribute("lang");return t===null||t.length===0?void 0:t}function wi(){if(typeof navigator>"u")return;let t=navigator.language;return typeof t=="string"&&t.length>0?t:void 0}var Xn="payload-live-preview-a11y",xi=1500,vi=["position:absolute","width:1px","height:1px","padding:0","margin:-1px","overflow:hidden","clip:rect(0 0 0 0)","clip-path:inset(50%)","white-space:nowrap","border:0"].join(";"),Jn={connected:"Live preview connected",disconnected:"Live preview disconnected",updated:t=>`${String(t)} ${t===1?"change":"changes"} applied`},Ei={en:Jn,de:{connected:"Vorschau verbunden",disconnected:"Vorschau getrennt",updated:t=>`${String(t)} ${t===1?"\\xC4nderung":"\\xC4nderungen"} angewendet`}};function ki(t){let e=t.split(/[-_]/)[0]?.toLowerCase()??"en";return Ei[e]??Jn}var I,he,H,ie,Zn,At,tt=class{constructor(e=Le()){l(this,ie);l(this,I,null);l(this,he);l(this,H,null);d(this,he,ki(e))}announceConnected(){f(this,ie,At).call(this,i(this,he).connected)}announceDisconnected(){f(this,ie,At).call(this,i(this,he).disconnected)}announceUpdate(e){e<=0||f(this,ie,At).call(this,i(this,he).updated(e))}detach(){i(this,H)!==null&&(clearTimeout(i(this,H)),d(this,H,null)),i(this,I)?.parentNode&&i(this,I).parentNode.removeChild(i(this,I))}};I=new WeakMap,he=new WeakMap,H=new WeakMap,ie=new WeakSet,Zn=function(){if(i(this,I)!==null&&i(this,I).isConnected)return i(this,I);if(typeof document>"u"||document.body===null)return null;let e=document.getElementById(Xn);return e||(e=document.createElement("div"),e.id=Xn,e.setAttribute("role","status"),e.setAttribute("aria-live","polite"),e.setAttribute("aria-atomic","true"),e.setAttribute("style",vi),document.body.appendChild(e)),d(this,I,e),e},At=function(e){let n=f(this,ie,Zn).call(this);n&&(n.textContent=e,i(this,H)!==null&&clearTimeout(i(this,H)),d(this,H,setTimeout(()=>{d(this,H,null),i(this,I)&&(i(this,I).textContent="")},xi)))};var Si=new Set(["tabs","row","collapsible"]);function Bt(t,e=""){let n=new Map;return nt(t,e,n),n}function nt(t,e,n){for(let r of t){if(Si.has(r.type)){r.fields&&nt(r.fields,e,n);continue}if(r.type==="group"){let s=e===""?r.name:`${e}.${r.name}`;n.set(s,r),r.fields&&nt(r.fields,s,n);continue}let o=e===""?r.name:`${e}.${r.name}`;if(n.set(o,r),r.type==="array"&&r.fields)nt(r.fields,`${o}.*`,n);else if(r.type==="blocks"&&r.blocks)for(let s of r.blocks)nt(s.fields,`${o}.*.${s.slug}`,n)}}function jt(t,e){if(t.has(e))return t.get(e);let n=e.replace(/\\.\\d+(?=\\.|$)/g,".*");if(t.has(n))return t.get(n)}function Vt(t){if(typeof t!="object"||t===null)return;let e=t.id;if(typeof e=="string"||typeof e=="number")return e}function Qn(t){if(typeof t!="object"||t===null)return;let e=t.blockType;return typeof e=="string"?e:void 0}function rt(t,e){return e.every(r=>Vt(r)!==void 0)?Ai(t,e):Li(t,e)}function Ai(t,e){let n=[],r=new Map;for(let s=0;s<t.length;s+=1){let a=Vt(t[s]);a!==void 0&&r.set(a,s)}let o=new Set;for(let s=0;s<e.length;s+=1){let a=e[s],u=Vt(a);if(u===void 0){n.push({kind:"insert",index:s,value:a});continue}let m=r.get(u);if(m===void 0){n.push({kind:"insert",index:s,value:a});continue}o.add(m);let w=t[m];if(Qn(w)!==Qn(a)){n.push({kind:"replace",index:s,oldValue:w,value:a});continue}m!==s&&n.push({kind:"move",from:m,to:s,value:a}),er(w,a)||n.push({kind:"update",index:s,value:a})}for(let s=0;s<t.length;s+=1)o.has(s)||n.push({kind:"remove",index:s,value:t[s]});return n}function Li(t,e){let n=[],r=Math.min(t.length,e.length);for(let o=0;o<r;o+=1)er(t[o],e[o])||n.push({kind:"update",index:o,value:e[o]});if(e.length>t.length)for(let o=t.length;o<e.length;o+=1)n.push({kind:"insert",index:o,value:e[o]});if(t.length>e.length)for(let o=e.length;o<t.length;o+=1)n.push({kind:"remove",index:o,value:t[o]});return n}function er(t,e){if(Object.is(t,e))return!0;if(typeof t!="object"||typeof e!="object"||t===null||e===null)return!1;let n=t,r=e,o=Object.keys(n),s=Object.keys(r);if(o.length!==s.length)return!1;for(let a of o)if(!Object.is(n[a],r[a]))return!1;return!0}var tr={text:"text",textarea:"textarea",richText:"richText",email:"email",number:"number",checkbox:"checkbox",date:"date",select:"select",radio:"radio",array:"array",blocks:"blocks",group:"text",tabs:"text",row:"text",collapsible:"text",relationship:"relationship",upload:"upload",point:"text",json:"text",code:"text",ui:"text"};function zt(t){if(Object.prototype.hasOwnProperty.call(tr,t))return tr[t]}var Mi=[0,500,1e3,2e3],E,A,X,oe,Me,J,Ie,it,B,ye,ge,ot,O,Ne,_e,Z,be,N,Ce,Oe,Pe,Re,se,st,at,h,Gt,Wt,Yt,rr,ir,or,sr,ar,dr,lr,ur,cr,fr,pr,Lt=class{constructor(e){l(this,h);l(this,E);l(this,A);l(this,X);l(this,oe);l(this,Me);l(this,J);l(this,Ie);l(this,it);l(this,B);l(this,ye);l(this,ge);l(this,ot);l(this,O);l(this,Ne);l(this,_e,[]);l(this,Z);l(this,be);l(this,N);l(this,Ce);l(this,Oe);l(this,Pe,Ut(void 0));l(this,Re,!1);l(this,se,null);l(this,st,0);l(this,at,new Set);d(this,E,e.emitter),d(this,it,e.renderers),d(this,B,e.root??(typeof document<"u"?document:null)),d(this,ye,e.readyTargets),d(this,ge,e.sendReady??Oi),d(this,ot,e.onHeartbeatTimeout),d(this,O,e.log??Ni),d(this,Ne,e.warn??Ci),d(this,Z,Ii(e)),d(this,be,e.dataMerge!==void 0?new Et({serverURL:e.dataMerge.serverURL,...e.dataMerge.apiRoute!==void 0?{apiRoute:e.dataMerge.apiRoute}:{},...e.dataMerge.depth!==void 0?{depth:e.dataMerge.depth}:{},...e.dataMerge.fetchFn!==void 0?{fetchFn:e.dataMerge.fetchFn}:{},log:(...n)=>{i(this,O).call(this,...n)}}):null),d(this,A,new Rt),d(this,X,new Tt({onStructuralChange:()=>{f(this,h,Yt).call(this)},onVisibilityChange:(n,r)=>{r&&i(this,oe).notifyVisible(n)}},{...e.intersectionRootMargin!==void 0?{intersectionRootMargin:e.intersectionRootMargin}:{}})),d(this,oe,new St(n=>{f(this,h,ur).call(this,n)},{...e.debounceMs!==void 0?{debounceMs:e.debounceMs}:{},...e.disableVisibilityGate!==void 0?{disableVisibilityGate:e.disableVisibilityGate}:{},...e.visibilityGateThreshold!==void 0?{visibilityGateThreshold:e.visibilityGateThreshold}:{},isVisible:n=>i(this,X).isVisible(n),getCacheSize:()=>i(this,A).elementCount,onFlush:n=>{f(this,h,fr).call(this,n)}})),d(this,Me,new Ue(e.originMatcher,{onUpdate:(n,r)=>{f(this,h,or).call(this,n,r)},onDocumentEvent:(n,r)=>{f(this,h,ar).call(this,n,r)},onInvalid:(n,r)=>{if(n==="token"){let o=new Error(`Preview token rejected (origin: ${r})`);i(this,E).emit("error",{error:o,context:"token"})}i(this,O).call(this,"message rejected:",n,r)},...e.validateToken!==void 0?{validateToken:e.validateToken}:{}})),d(this,J,new vt((n,r)=>{i(this,O).call(this,"connection",r,"\\u2192",n)})),d(this,Ie,new xt({...e.heartbeatMs!==void 0?{timeoutMs:e.heartbeatMs}:{},onTimeout:()=>{f(this,h,pr).call(this)}}))}start(){if(i(this,Re))return!1;d(this,Re,!0);let e=i(this,B);if(e instanceof Document&&e.readyState==="loading"){let n=()=>{d(this,se,null),f(this,h,Gt).call(this)};return d(this,se,n),e.addEventListener("DOMContentLoaded",n,{once:!0}),!0}return f(this,h,Gt).call(this),!0}destroy(){if(!i(this,Re))return;if(d(this,Re,!1),i(this,se)!==null){let n=i(this,B);n instanceof Document&&n.removeEventListener("DOMContentLoaded",i(this,se)),d(this,se,null),i(this,E).emit("destroy",{timestamp:Date.now()});return}for(let n of i(this,_e))clearTimeout(n);i(this,_e).length=0,i(this,Ie).stop(),i(this,Me).detach(),i(this,X).stop(),i(this,oe).destroy(),i(this,be)?.destroy(),i(this,A).clear();let e=i(this,J).status==="connected";i(this,J).markDisconnected(),e&&(i(this,Z)?.announceDisconnected(),i(this,E).emit("disconnect",{reason:"destroy",timestamp:Date.now()})),i(this,Z)?.detach(),i(this,E).emit("destroy",{timestamp:Date.now()})}refreshCache(){f(this,h,Yt).call(this)}get status(){return i(this,J).status}get cache(){return i(this,A)}get updateCount(){return i(this,st)}get protocol(){return i(this,Pe)}};E=new WeakMap,A=new WeakMap,X=new WeakMap,oe=new WeakMap,Me=new WeakMap,J=new WeakMap,Ie=new WeakMap,it=new WeakMap,B=new WeakMap,ye=new WeakMap,ge=new WeakMap,ot=new WeakMap,O=new WeakMap,Ne=new WeakMap,_e=new WeakMap,Z=new WeakMap,be=new WeakMap,N=new WeakMap,Ce=new WeakMap,Oe=new WeakMap,Pe=new WeakMap,Re=new WeakMap,se=new WeakMap,st=new WeakMap,at=new WeakMap,h=new WeakSet,Gt=function(){f(this,h,Wt).call(this),i(this,X).start(i(this,B)instanceof Document?i(this,B).body:i(this,B)),i(this,Me).attach(),f(this,h,rr).call(this);for(let e of Mi)if(e===0)i(this,ge).call(this,i(this,ye));else{let n=setTimeout(()=>{i(this,ge).call(this,i(this,ye))},e);i(this,_e).push(n)}},Wt=function(){let e=i(this,A).buildFromRoot(i(this,B));i(this,O).call(this,"cache built",e),i(this,E).emit("cacheRefresh",e);for(let n of i(this,A).values())i(this,X).observeElement(n.element)},Yt=function(){for(let e of i(this,A).values())i(this,X).unobserveElement(e.element),i(this,oe).forget(e.element);f(this,h,Wt).call(this)},rr=function(){i(this,E).emit("init",{timestamp:Date.now()})},ir=function(e){let n=Ut(e);n.negotiated!==i(this,Pe).negotiated&&(d(this,Pe,n),i(this,O).call(this,"protocol negotiated",`ours=${4}`,`theirs=${e}`,`negotiated=${n.negotiated}`))},or=function(e,n){i(this,Ie).kick(),e.protocolVersion!==void 0&&f(this,h,ir).call(this,e.protocolVersion),e.data!==void 0&&(i(this,J).markConnected()&&(i(this,Z)?.announceConnected(),i(this,E).emit("connect",{origin:n,timestamp:Date.now()})),d(this,st,i(this,st)+1),e.locale!==void 0&&d(this,N,e.locale),e.fieldSchemaJSON!==void 0&&(d(this,Ce,e.fieldSchemaJSON),d(this,Oe,Bt(e.fieldSchemaJSON))),f(this,h,sr).call(this,e).then(r=>{if(r===null)return;let o={fields:r,...i(this,Ce)!==void 0?{schema:i(this,Ce)}:{},...e.globalSlug!==void 0?{globalSlug:e.globalSlug}:{},...e.collectionSlug!==void 0?{collectionSlug:e.collectionSlug}:{},...i(this,N)!==void 0?{locale:i(this,N)}:{}},s=!1;i(this,E).emit("beforeUpdate",{data:o,cancel:()=>{s=!0}}).then(()=>{s||f(this,h,dr).call(this,o)})}))},sr=async function(e){let n=e.data??{};if(i(this,be)===null)return n;let r=await i(this,be).merge({collectionSlug:e.collectionSlug,globalSlug:e.globalSlug,data:n,locale:i(this,N)});return r.status==="merged"?r.doc:r.status==="superseded"?null:n},ar=function(e,n){i(this,E).emit("documentSave",{timestamp:Date.now()})},dr=function(e){for(let[n,r]of i(this,A).entries()){let o=$i(e.fields,n,i(this,N));if(o!==void 0)for(let s of r){let a={target:s,value:o,allFields:e.fields};i(this,oe).schedule(a)}}f(this,h,lr).call(this,e.fields)},lr=function(e){if(i(this,A).elementCount===0)return;let n=new Set;for(let[r]of i(this,A).entries())n.add(r);for(let[r,o]of Object.entries(e)){if(i(this,at).has(r)||Pi.has(r)||!Fi(o))continue;let s=Di(r,i(this,N));n.has(r)||n.has(s)||(i(this,at).add(r),i(this,Ne).call(this,`[live-preview] update arrived for field "${r}" but no <\\u2026 data-payload-field="${s}"> element exists on this page. Render the binding anchor unconditionally in your template so live edits to an initially-empty field have somewhere to land.`))}},ur=function(e){let n=i(this,Oe)!==void 0?jt(i(this,Oe),e.target.fieldName):void 0,r=f(this,h,cr).call(this,e.target,n?.type);r==="text"&&e.target.explicitFieldType!==!0&&_i(e.value)&&(r="richText");let o=i(this,it)[r],s=Ui(e.target.element),a={allFields:e.allFields,locale:i(this,N),schema:n};try{e.target.targetAttribute!==void 0?Yn(e.target.element,e.target.targetAttribute,e.value)==="blocked"&&i(this,Ne).call(this,`[live-preview] refused to write field "${e.target.fieldName}" into attribute "${e.target.targetAttribute}" (unsafe attribute or value)`):o?o.render(e.target,e.value,a):i(this,O).call(this,"no renderer for",r)}catch(u){let m=u instanceof Error?u:new Error(String(u));i(this,E).emit("error",{error:m,context:"renderer"});return}i(this,E).emit("elementUpdate",{element:e.target.element,fieldName:e.target.fieldName,previousValue:s,nextValue:e.value})},cr=function(e,n){if(e.explicitFieldType)return e.fieldType;if(n!==void 0){let r=zt(n);if(r!==void 0)return r}return e.fieldType},fr=function(e){e.applied===0&&e.deferred===0||(e.applied>0&&i(this,Z)?.announceUpdate(e.applied),i(this,E).emit("afterUpdate",{data:{fields:{},...i(this,N)!==void 0?{locale:i(this,N)}:{}},updatedCount:e.applied,durationMs:e.durationMs}))},pr=function(){var e;i(this,J).markDisconnected()&&(i(this,Z)?.announceDisconnected(),i(this,E).emit("disconnect",{reason:"timeout",timestamp:Date.now()}));try{(e=i(this,ot))==null||e.call(this)}catch(n){i(this,O).call(this,"onHeartbeatTimeout hook threw:",n)}i(this,ge).call(this,i(this,ye))};function Ii(t){return t.enableA11y===!1?null:t.a11yLocale!==void 0?new tt(t.a11yLocale):new tt}function Ni(){}function _i(t){if(typeof t!="object"||t===null||!("root"in t))return!1;let e=t.root;return typeof e!="object"||e===null?!1:Array.isArray(e.children)}function Ci(...t){typeof console<"u"&&typeof console.warn=="function"&&console.warn(...t)}function Oi(t){if(typeof window>"u")return;let e=[];window.parent!==window&&e.push(window.parent),window.opener instanceof Window&&e.push(window.opener),Ue.sendReady(e,t)}var mr=new Set(["__proto__","prototype","constructor"]),Pi=new Set(["id","_id","createdAt","updatedAt","createdBy","updatedBy","_status","globalType","collection","locale","localized"]);function Fi(t){return t==null?!1:typeof t=="string"||typeof t=="number"||typeof t=="boolean"||typeof t=="bigint"}function Di(t,e){if(!e)return t;let n=`_${e}`;return t.endsWith(n)?t.slice(0,-n.length):t}function $i(t,e,n){let r=nr(t,e);if(r!==void 0)return r;if(e.includes(".")){let o=e.split("."),s=t;for(let a of o){if(mr.has(a)||s===null||typeof s!="object")return;s=s[a]}if(s!==void 0)return s}if(n!==void 0){let o=nr(t,`${e}_${n}`);if(o!==void 0)return o}}function nr(t,e){if(!mr.has(e)&&Object.prototype.hasOwnProperty.call(t,e))return t[e]}function Ui(t){return t.tagName==="INPUT"||t.tagName==="TEXTAREA"?t.value:t.tagName==="IMG"?t.src:t.textContent}function dt(){if(typeof window>"u")return!1;try{return window.self!==window.top}catch{return!0}}function qt(){return typeof window>"u"?!1:window.opener!=null}function Kt(){return dt()||qt()}function hr(){let t=Hi();if(t!==void 0)return t!=="production";let e=Bi();if(e!==void 0)return e;if(typeof window<"u"){let n=window.location.hostname;if(n==="localhost"||n==="127.0.0.1")return!0}return!1}function yr(t){if(typeof process<"u"){let n=process.env[t];if(typeof n=="string"&&n.length>0)return n}let e=void 0;if(e){let n=e[t];if(typeof n=="string"&&n.length>0)return n}}function Hi(){if(typeof process>"u")return;let t="production";return typeof t=="string"?t:void 0}function Bi(){let t=void 0;if(!t)return;let e=t.DEV;return typeof e=="boolean"?e:void 0}var ji=/^https?:\\/\\/(localhost|127\\.0\\.0\\.1)(?::\\d+)?$/i,Vi=/^https?:\\/\\/[^/?#\\s]+$/i,zi=["PAYLOAD_ADMIN_ORIGIN","PUBLIC_PAYLOAD_ADMIN_ORIGIN","NEXT_PUBLIC_PAYLOAD_ADMIN_ORIGIN"],j,V,ae,lt,P,Mt=class{constructor(e={}){l(this,j);l(this,V);l(this,ae);l(this,lt);l(this,P);let n=new Set;for(let a of e.additionalOrigins??[]){let u=gr(a);u!==void 0&&n.add(u)}for(let a of zi){let u=yr(a);if(u!==void 0)for(let m of u.split(",")){let w=gr(m);w!==void 0&&n.add(w)}}d(this,j,n);let r=e.enableReferrerDetection??!0,o;if(r){let a=e.referrer??(typeof document<"u"?document.referrer:"");if(a.length>0)try{let u=new URL(a).origin;u&&u!=="null"&&(o=u)}catch{}}d(this,V,o),d(this,lt,o!==void 0);let s=(e.enableLocalhostMatching??!0)&&(e.forceDevMode??hr());d(this,ae,s)}matches(e){return e.length===0||e==="null"?!1:i(this,P)!==void 0?e===i(this,P):!!(i(this,j).has(e)||i(this,j).size===0&&i(this,V)!==void 0&&e===i(this,V)||i(this,ae)&&ji.test(e))}lockOrigin(e){return this.matches(e)?(d(this,P,e),!0):!1}unlockOrigin(){let e=i(this,P);return d(this,P,void 0),e}get lockedOrigin(){return i(this,P)}enumerate(){if(i(this,P)!==void 0)return[i(this,P)];let e=new Set(i(this,j));if(i(this,j).size===0&&i(this,V)!==void 0&&e.add(i(this,V)),i(this,ae))for(let n of Gi)e.add(`http://localhost:${String(n)}`),e.add(`http://127.0.0.1:${String(n)}`);return[...e]}get referrerWasAvailable(){return i(this,lt)}get isProductionUnconfigured(){return!(!dt()||i(this,j).size>0||i(this,ae)||i(this,V)!==void 0)}get isReferrerOnlyTrust(){return i(this,j).size>0||i(this,ae)?!1:i(this,V)!==void 0}};j=new WeakMap,V=new WeakMap,ae=new WeakMap,lt=new WeakMap,P=new WeakMap;var Gi=[3e3,3001,3333,4e3,4321,5e3,5173,5174,8e3,8080,8888,9e3];function gr(t){let e=t.trim();if(e.length!==0)try{let n=new URL(e);return n.protocol!=="http:"&&n.protocol!=="https:"||!Vi.test(n.origin)?void 0:n.origin}catch{return}}var br={name:"payload-live-preview",version:"1.0.0",description:"Framework-agnostic live preview for Payload CMS \\u2014 Astro-first; works with Next.js, SvelteKit, Nuxt, and plain HTML.",author:"relative23",license:"MIT",type:"module",main:"./dist/index.cjs",module:"./dist/index.js",types:"./dist/index.d.ts",exports:{".":{import:{types:"./dist/index.d.ts",default:"./dist/index.js"},require:{types:"./dist/index.d.cts",default:"./dist/index.cjs"}},"./core":{import:{types:"./dist/core.d.ts",default:"./dist/core.js"},require:{types:"./dist/core.d.cts",default:"./dist/core.cjs"}},"./astro":{import:{types:"./dist/adapters/astro/index.d.ts",default:"./dist/adapters/astro/index.js"}},"./nextjs":{import:{types:"./dist/adapters/nextjs/index.d.ts",default:"./dist/adapters/nextjs/index.js"}},"./sveltekit":{import:{types:"./dist/adapters/sveltekit/index.d.ts",default:"./dist/adapters/sveltekit/index.js"}},"./nuxt":{import:{types:"./dist/adapters/nuxt/index.d.ts",default:"./dist/adapters/nuxt/index.js"}},"./codegen":{import:{types:"./dist/codegen.d.ts",default:"./dist/codegen.js"},require:{types:"./dist/codegen.d.cts",default:"./dist/codegen.cjs"}},"./codegen/astro":{import:{types:"./dist/codegen-astro.d.ts",default:"./dist/codegen-astro.js"}},"./payload":{import:{types:"./dist/payload.d.ts",default:"./dist/payload.js"},require:{types:"./dist/payload.d.cts",default:"./dist/payload.cjs"}},"./astro/RichText.astro":"./dist/adapters/astro/RichText.astro","./astro/middleware-entry":{import:{types:"./dist/adapters/astro/middleware-entry.d.ts",default:"./dist/adapters/astro/middleware-entry.js"}}},bin:{"pll-codegen":"./dist/codegen-cli.js"},files:["dist","README.md","LICENSE"],sideEffects:!1,scripts:{prepare:"npm run build:runtime","build:runtime":"tsx scripts/build-runtime.ts",build:"npm run build:runtime && tsup && npm run build:assets","build:assets":`node -e "require(\'node:fs\').copyFileSync(\'src/adapters/astro/RichText.astro\',\'dist/adapters/astro/RichText.astro\')"`,dev:"tsup --watch",test:"vitest run","test:watch":"vitest","test:unit":"vitest run tests/unit","test:integration":"vitest run tests/integration","test:e2e":"playwright test","test:bench":"vitest bench tests/benchmarks","test:coverage":"vitest run --coverage",typecheck:"tsc --noEmit",lint:"eslint .","lint:fix":"eslint . --fix",format:\'prettier --write "src/**/*.ts" "tests/**/*.ts"\',"format:check":\'prettier --check "src/**/*.ts" "tests/**/*.ts"\',check:"npm run typecheck && npm run lint && npm run test",prepublishOnly:"npm run check && npm run build",changeset:"changeset",version:"changeset version",release:"npm run build && changeset publish"},devDependencies:{"@changesets/cli":"^2.31.0","@eslint/js":"^10.0.1","@playwright/test":"^1.61.1","@types/node":"^22.20.1","@vitest/coverage-v8":"^4.1.10",esbuild:"^0.28.1",eslint:"^10.7.0",globals:"^17.7.0",jsdom:"^29.1.1",prettier:"^3.9.5","ts-morph":"^28.0.0",tsup:"^8.5.1",tsx:"^4.23.0",typescript:"^5.9.3","typescript-eslint":"^8.63.0",vitest:"^4.1.10"},keywords:["payload","payload-cms","payload-live-preview","live-preview","cms","headless","astro","nextjs","sveltekit","nuxt","vue","svelte","schema-driven","lexical","csp-safe","framework-agnostic"],peerDependencies:{astro:">=4.0.0 <8.0.0","ts-morph":"^28.0.0"},peerDependenciesMeta:{astro:{optional:!0},"ts-morph":{optional:!0}},engines:{node:">=20.19.0"},publishConfig:{access:"public",provenance:!0},repository:{type:"git",url:"https://github.com/relative23/payload-live-preview.git"},bugs:{url:"https://github.com/relative23/payload-live-preview/issues"},homepage:"https://github.com/relative23/payload-live-preview#readme"};var Rr=br.version;var Xt=new Set(["p","br","strong","b","em","i","u","s","strike","mark","small","h1","h2","h3","h4","h5","h6","ul","ol","li","dl","dt","dd","blockquote","code","pre","kbd","samp","var","a","span","div","section","article","aside","header","footer","nav","figure","figcaption","img","picture","source","audio","video","sub","sup","hr","time","abbr","cite","q","table","thead","tbody","tfoot","tr","th","td","caption","colgroup","col"]),wr=new Set(["script","style","iframe","object","embed","link","meta","base","form","input","button","select","textarea","svg","math","template","frame","frameset","noframes","noscript"]),xr=new Set(["id","class","lang","dir","title","role","tabindex"]),Yi="aria-",qi="data-",Jt={a:new Set(["href","target","rel","download","hreflang","type"]),img:new Set(["src","srcset","sizes","alt","width","height","loading","decoding"]),picture:new Set([]),source:new Set(["src","srcset","sizes","type","media"]),audio:new Set(["src","controls","autoplay","loop","muted","preload"]),video:new Set(["src","poster","controls","autoplay","loop","muted","preload","width","height","playsinline"]),time:new Set(["datetime"]),abbr:new Set(["title"]),q:new Set(["cite"]),blockquote:new Set(["cite"]),table:new Set(["summary"]),th:new Set(["colspan","rowspan","scope","headers","abbr"]),td:new Set(["colspan","rowspan","headers"]),col:new Set(["span"]),colgroup:new Set(["span"]),ol:new Set(["start","reversed","type"]),li:new Set(["value"]),code:new Set(["class"]),pre:new Set(["class"])},vr=new Set(["href","src","cite","poster"]),Zt=class extends Error{constructor(){super(...arguments);$n(this,"name","SanitizerEnvironmentError")}};function Ki(t){if(!t){let r=new Map;for(let[o,s]of Object.entries(Jt))r.set(o,s);return{allowedTags:Xt,attrByTag:r}}let e=new Set(Xt);for(let r of t.additionalAllowedTags??[])e.add(r);let n=new Map;for(let[r,o]of Object.entries(Jt))n.set(r,o);for(let[r,o]of Object.entries(t.additionalAllowedAttributes??{})){let s=n.get(r),a=new Set(s??[]);for(let u of o)a.add(u);n.set(r,a)}return{allowedTags:e,attrByTag:n}}var Tr;function z(t,e){let n=Er();if(!n)throw new Zt("sanitizeHtml requires a DOM. Inject one via setSanitizerDocument() for SSR (linkedom, jsdom, happy-dom, \\u2026) or use the plain-text path on the server.");if(t==="")return"";let r=Ki(e),o=n.createElement("template");return o.innerHTML=t,Qt(o.content,r),o.innerHTML}function Er(){if(Tr)return Tr;if(!(typeof document>"u"))return document}function kr(){return Er()!==void 0}function Qt(t,e){for(let n of Array.from(t.childNodes))n.nodeType===Node.ELEMENT_NODE?Xi(n,e):n.nodeType===Node.COMMENT_NODE&&n.remove()}function Xi(t,e){let n=t.tagName.toLowerCase();if(wr.has(n)){t.remove();return}if(!e.allowedTags.has(n)){Qt(t,e);let r=t.parentNode;if(r){for(;t.firstChild;)r.insertBefore(t.firstChild,t);t.remove()}return}Ji(t,n,e),n==="a"&&Qi(t),Qt(t,e)}function Ji(t,e,n){let r=n.attrByTag.get(e);for(let o of Array.from(t.attributes)){let s=o.name.toLowerCase();if(s.startsWith("on")){t.removeAttribute(o.name);continue}if(s==="style"){t.removeAttribute(o.name);continue}if(!(xr.has(s)||s.startsWith(Yi)||s.startsWith(qi))){if(r?.has(s)){(vr.has(s)&&!R(o.value)||s==="srcset"&&!Zi(o.value))&&t.removeAttribute(o.name);continue}t.removeAttribute(o.name)}}}function Zi(t){let e=t.split(",");for(let n of e){let r=n.trim();if(r.length===0)continue;let o=r.split(/\\s+/,1)[0];if(o===void 0||o.length===0||!R(o))return!1}return!0}function Qi(t){let e=t.getAttribute("href");e&&kt(e)&&(t.setAttribute("rel","noopener noreferrer"),t.hasAttribute("target")||t.setAttribute("target","_blank"))}var Ws=Object.freeze({allowedTags:Xt,removeCompletely:wr,globalAttributes:xr,attributesByTag:Jt,urlAttributes:vr});var Sr=new Map;function p(t,e){Sr.set(t,e)}function Ar(t){return Sr.get(t)}var eo={1:"left",2:"center",3:"right",4:"justify"},to=new Set(["left","center","right","justify","start","end"]);function en(t){let e=t.format;if(typeof e=="string"&&to.has(e))return e;if(typeof e=="number"){let n=eo[e];if(n!==void 0)return n}}function tn(t){let e=t.indent;return typeof e=="number"&&e>0?e:0}function Q(t){return t.direction==="rtl"?\' dir="rtl"\':t.direction==="ltr"?\' dir="ltr"\':""}function G(t){let e=en(t),n=tn(t),r=[];return e!==void 0&&r.push(`text-align:${e}`),n>0&&r.push(`padding-inline-start:${String(n*40)}px`),r.length===0?"":` style="${r.join(";")}"`}var no=Object.freeze({"&":"&amp;","<":"&lt;",">":"&gt;",\'"\':"&quot;","\'":"&#x27;","/":"&#x2F;","`":"&#x60;","=":"&#x3D;"}),ro=/[&<>"\'/`=]/g;function g(t){return t===""?"":t.replace(ro,e=>no[e])}function Lr(t){return t.replace(/[\'"()\\\\]/g,"\\\\$&")}var io=Object.freeze({"&":"&amp;","<":"&lt;",">":"&gt;",\'"\':"&quot;","\'":"&#x27;"}),oo=/[&<>"\']/g;function L(t){return t===""?"":t.replace(oo,e=>io[e])}function It(t){return g(t).replace(/\\r\\n|\\r|\\n/g,"<br>")}var ee={BOLD:1,ITALIC:2,STRIKETHROUGH:4,UNDERLINE:8,CODE:16,SUBSCRIPT:32,SUPERSCRIPT:64,HIGHLIGHT:128};var nn=t=>{let e=typeof t.text=="string"?t.text:"",n=g(e),r=typeof t.format=="number"?t.format:0;return(r&ee.CODE)!==0&&(n=`<code>${n}</code>`),(r&ee.BOLD)!==0&&(n=`<strong>${n}</strong>`),(r&ee.ITALIC)!==0&&(n=`<em>${n}</em>`),(r&ee.UNDERLINE)!==0&&(n=`<u>${n}</u>`),(r&ee.STRIKETHROUGH)!==0&&(n=`<s>${n}</s>`),(r&ee.SUBSCRIPT)!==0&&(n=`<sub>${n}</sub>`),(r&ee.SUPERSCRIPT)!==0&&(n=`<sup>${n}</sup>`),(r&ee.HIGHLIGHT)!==0&&(n=`<mark>${n}</mark>`),n};p("text",nn);var rn=(t,e)=>{let n=e.renderChildren(t.children??[]);return`<p${Q(t)}${G(t)}>${n}</p>`};p("paragraph",rn);var so=new Set(["h1","h2","h3","h4","h5","h6"]),on=(t,e)=>{let n=typeof t.tag=="string"?t.tag.toLowerCase():"h2",r=so.has(n)?n:"h2",o=e.renderChildren(t.children??[]);return`<${r}${Q(t)}${G(t)}>${o}</${r}>`};p("heading",on);var sn=(t,e)=>{let n=typeof t.listType=="string"?t.listType:"bullet",r=n==="number"?"ol":"ul",o=n==="number"&&typeof t.start=="number"&&t.start>1?` start="${String(t.start)}"`:"",s=n==="check"?\' role="list"\':"",a=e.renderChildren(t.children??[]);return`<${r}${Q(t)}${G(t)}${o}${s}>${a}</${r}>`},an=(t,e)=>{let n=e.renderChildren(t.children??[]);if(typeof t.checked=="boolean")return`<li role="checkbox" aria-checked="${t.checked?"true":"false"}"${G(t)}>${n}</li>`;let r=typeof t.value=="number"?` value="${g(String(t.value))}"`:"";return`<li${Q(t)}${G(t)}${r}>${n}</li>`};p("list",sn);p("listitem",an);var ut=(t,e)=>{let n=typeof t.url=="string"?t.url:"",r=e.renderChildren(t.children??[]);if(n.length===0||!R(n))return r;let o=kt(n)?\' target="_blank" rel="noopener noreferrer"\':ao(t),s=typeof t.title=="string"?` title="${g(t.title)}"`:"";return`<a href="${L(n)}"${o}${s}>${r}</a>`};function ao(t){let e=typeof t.target=="string"?t.target:"";if(e.length===0)return"";let n=g(e);return e==="_blank"?\' target="_blank" rel="noopener noreferrer"\':` target="${n}"`}p("link",ut);p("autolink",ut);var dn=(t,e)=>{let n=e.renderChildren(t.children??[]);return`<blockquote${Q(t)}${G(t)}>${n}</blockquote>`};p("quote",dn);var ln=t=>{let e=Ir(typeof t.language=="string"?t.language:""),n=Mr(t);return`<pre><code${e===""?"":` class="language-${e}"`}>${g(n)}</code></pre>`},un=t=>{let e=typeof t.text=="string"?t.text:"";return`<span${typeof t.highlightType=="string"?` class="token-${Ir(t.highlightType)}"`:""}>${g(e)}</span>`};p("code",ln);p("code-highlight",un);function Mr(t){if(typeof t.text=="string")return t.text;if(!t.children)return"";let e="";for(let n of t.children)e+=Mr(n);return e}function Ir(t){return t.replace(/[^a-zA-Z0-9_-]/g,"")}var cn=()=>"<br>",fn=()=>"<hr>",pn=()=>"	";p("linebreak",cn);p("horizontalrule",fn);p("tab",pn);var mn=t=>{let e=lo(t);if(e===void 0)return"";let n=e.url;if(typeof n!="string"||!R(n))return"";let r=typeof e.mimeType=="string"?e.mimeType:"";return r.startsWith("video/")?co(e,n):r.startsWith("audio/")?fo(e,n):r===""||r.startsWith("image/")?uo(e,n):po(e,n)};p("upload",mn);function lo(t){let e=t.value;if(!(typeof e!="object"||e===null))return e}function uo(t,e){let n=typeof t.alt=="string"?g(t.alt):"",r=typeof t.width=="number"?` width="${String(t.width)}"`:"",o=typeof t.height=="number"?` height="${String(t.height)}"`:"";return`<img src="${L(e)}" alt="${n}"${r}${o} loading="lazy" decoding="async">`}function co(t,e){let n=typeof t.width=="number"?` width="${String(t.width)}"`:"",r=typeof t.height=="number"?` height="${String(t.height)}"`:"",o=typeof t.mimeType=="string"?` type="${L(t.mimeType)}"`:"";return`<video controls${n}${r}><source src="${L(e)}"${o}></video>`}function fo(t,e){let n=typeof t.mimeType=="string"?` type="${L(t.mimeType)}"`:"";return`<audio controls><source src="${L(e)}"${n}></audio>`}function po(t,e){let n=typeof t.filename=="string"?g(t.filename):g(e);return`<a href="${L(e)}" target="_blank" rel="noopener noreferrer">${n}</a>`}var hn=t=>{let e=typeof t.relationTo=="string"?t.relationTo:"",n=mo(t),r=ho(n,e),o=g(r),s=e===""?"":` data-relation-to="${g(e)}"`,a=n?.url;return typeof a=="string"&&R(a)?`<a href="${L(a)}"${s}>${o}</a>`:`<span${s}>${o}</span>`};p("relationship",hn);function mo(t){let e=t.value;if(!(typeof e!="object"||e===null))return e}function ho(t,e){return t===void 0?e===""?"#":`#${e}`:typeof t.title=="string"&&t.title.length>0?t.title:typeof t.name=="string"&&t.name.length>0?t.name:typeof t.slug=="string"&&t.slug.length>0?t.slug:t.id!==void 0?String(t.id):e===""?"#":`#${e}`}var yo=new Map;function yn(t){return yo.get(t)}var gn=(t,e)=>{let n=go(t),r=typeof n.blockType=="string"?n.blockType:"",o=Nr(r);if(r!==""){let u=yn(r)??yn(o);if(u)return u(n,{renderChildren:e.renderChildren})}let s=[];o!==""&&s.push(`data-block-type="${g(o)}"`);for(let[u,m]of Object.entries(n)){if(u==="blockType"||u==="id"||m==null)continue;let w=typeof m=="string"||typeof m=="number"||typeof m=="boolean"?String(m):JSON.stringify(m);s.push(`data-block-${Nr(u)}="${g(w)}"`)}return`<div${s.length===0?"":` ${s.join(" ")}`}></div>`};p("block",gn);function go(t){let e=t.fields;return typeof e!="object"||e===null?{}:e}function Nr(t){return t.replace(/[^a-zA-Z0-9_-]/g,"-").toLowerCase()}p("text",nn);p("paragraph",rn);p("heading",on);p("list",sn);p("listitem",an);p("link",ut);p("autolink",ut);p("quote",dn);p("code",ln);p("code-highlight",un);p("linebreak",cn);p("horizontalrule",fn);p("tab",pn);p("upload",mn);p("relationship",hn);p("block",gn);var bo={renderChildren:bn,resolveAlignment:en,resolveIndent:tn};function de(t){if(typeof t!="object"||t===null||!("root"in t))return!1;let e=t.root;return typeof e!="object"||e===null||!("children"in e)?!1:Array.isArray(e.children)}function _r(t,e={}){if(!de(t))return"";let n=bn(t.root.children);return e.sanitize===!1||!kr()?n:z(n)}function Nt(t){return de(t)?t.root.children.map(Cr).join(`\n`).trim():""}function bn(t){let e="";for(let n of t)e+=Ro(n);return e}function Ro(t){let e=Ar(t.type);return e?e(t,bo):t.children!==void 0?bn(t.children):""}function Cr(t){if(typeof t.text=="string")return t.text;if(t.type==="linebreak")return`\n`;if(t.children===void 0)return"";let e="";for(let n of t.children)e+=Cr(n);return e}var Rn=new Map;function Or(t=[]){for(let n of t)Rn.set(n.name,n);let e={};for(let[n,r]of Rn)e[n]=r;return Object.freeze(e)}function y(t){Rn.set(t.name,t)}var To="data-payload-text",Pr=new WeakSet,Tn={name:"text",render(t,e){let n=t.element,r=vo(e);if(n.tagName==="INPUT"||n.tagName==="TEXTAREA"){n.value=r;return}if(wo(n)&&!n.hasAttribute(To)){xo(n,t.fieldName);return}if(r.includes(`\n`)||r.includes("\\r")){n.innerHTML=It(r);return}n.textContent=r}};function wo(t){return t.firstElementChild!==null}function xo(t,e){Pr.has(t)||(Pr.add(t),console.warn(`[live-preview] Skipping text update for "${e}" \\u2014 the bound <${t.tagName.toLowerCase()}> has structured child elements. Either move data-payload-field to the element whose textContent is the field value, or opt in with data-payload-text to replace the structure.`))}function vo(t){return t==null?"":de(t)?Nt(t):typeof t=="string"?t:typeof t=="number"||typeof t=="boolean"?String(t):JSON.stringify(t)}y(Tn);function T(t){if(t==null)return"";if(typeof t=="string")return t;if(typeof t=="number"||typeof t=="boolean"||typeof t=="bigint")return String(t);try{return JSON.stringify(t)}catch{return""}}var wn={name:"textarea",render(t,e){let n=t.element,r=de(e)?Nt(e):T(e);if(n.tagName==="INPUT"||n.tagName==="TEXTAREA"){n.value=r;return}n.innerHTML=It(r)}};y(wn);var xn={name:"richText",render(t,e){if(de(e)){t.element.innerHTML=_r(e);return}typeof e=="string"&&(t.element.innerHTML=z(e))}};y(xn);var vn={name:"html",render(t,e){if(e==null){t.element.textContent="";return}let n=typeof e=="string"?e:T(e);t.element.innerHTML=z(n)}};y(vn);var ct={name:"url",render(t,e,n){let r=t.element,o=T(e);if(r.tagName==="A"){let s=r,a=t.hrefField,u=a?n.allFields[a]:e;typeof u=="string"&&R(u)&&(s.href=u),s.textContent=o;return}if(r.tagName==="INPUT"||r.tagName==="TEXTAREA"){r.value=o;return}r.textContent=o}};y(ct);y({...ct,name:"email"});var En={name:"image",render(t,e,n){let r=t.element,o=Eo(e),s=ko(o,e);if(s!==void 0){if(r.tagName==="IMG"){let a=r;a.src=s;let u=So(o,t.altField,n.allFields);u!==void 0&&(a.alt=u);return}r.style.backgroundImage=`url(\'${Lr(s)}\')`}}};function Eo(t){if(!(typeof t!="object"||t===null))return t}function ko(t,e){if(t?.url!==void 0&&R(t.url))return t.url;if(typeof e=="string"&&R(e))return e}function So(t,e,n){if(t?.alt!==void 0)return t.alt;if(e!==void 0){let r=n[e];if(typeof r=="string")return r}}y(En);var kn={name:"upload",render(t,e){let n=t.element,r=Ao(e);if(r===void 0)return;let o=r.url;if(typeof o!="string"||!R(o))return;if(n.tagName==="IMG"){let a=n;a.src=o,r.alt!==void 0&&(a.alt=r.alt);return}if(n.tagName==="A"){let a=n;a.href=o,a.textContent=r.filename??o;return}let s=r.filename!==void 0?g(r.filename):g(o);n.innerHTML=`<a href="${L(o)}">${s}</a>`}};function Ao(t){if(!(typeof t!="object"||t===null))return t}y(kn);var Sn={name:"relationship",render(t,e){let n=t.element,o=Lo(e).join(", ");if(n.tagName==="A"&&!Array.isArray(e)){let s=n,a=e?.url;typeof a=="string"&&R(a)&&(s.href=a),s.textContent=o;return}n.textContent=o}};function Lo(t){return t==null?[""]:Array.isArray(t)?t.map(Fr):[Fr(t)]}function Fr(t){if(typeof t=="object"&&t!==null){let e=t;return typeof e.title=="string"&&e.title.length>0?e.title:typeof e.name=="string"&&e.name.length>0?e.name:typeof e.slug=="string"&&e.slug.length>0?e.slug:e.id!==void 0?String(e.id):""}return T(t)}y(Sn);var ft={name:"select",render(t,e){let n=t.element,r=Dr(e);if(n.tagName==="SELECT"){n.value=r;return}if(n.tagName==="INPUT"&&n.type==="radio"){let o=n;o.checked=o.value===r;return}n.textContent=r}};function Dr(t){return Array.isArray(t)?t.map(e=>Dr(e)).join(", "):T(t)}y(ft);y({...ft,name:"radio"});var An={name:"checkbox",render(t,e){let n=t.element,r=!!e;if(n.tagName==="INPUT"&&n.type==="checkbox"){n.checked=r;return}if(n.hasAttribute("aria-checked")){n.setAttribute("aria-checked",r?"true":"false");return}n.textContent=r?"true":"false"}};y(An);var pt=new Map,mt=new Map,Mo=64,Io=Mo;function $r(t,e){let n=Hr(t,e),r=pt.get(n);if(r!==void 0)return pt.delete(n),pt.set(n,r),r;let o=new Intl.NumberFormat(t,e);return pt.set(n,o),Br(pt),o}function Ur(t,e){let n=Hr(t,e),r=mt.get(n);if(r!==void 0)return mt.delete(n),mt.set(n,r),r;let o=new Intl.DateTimeFormat(t,e);return mt.set(n,o),Br(mt),o}function Hr(t,e){let n=t??"";if(e==null)return n;let r=Ln(e);return r==="{}"?n:`${n}|${r}`}function Ln(t){if(t===null||typeof t!="object")return JSON.stringify(t);if(Array.isArray(t))return`[${t.map(o=>Ln(o)).join(",")}]`;let e=t,n=Object.keys(e).sort(),r=[];for(let o of n){let s=e[o];s!==void 0&&r.push(`${JSON.stringify(o)}:${Ln(s)}`)}return`{${r.join(",")}}`}function Br(t){for(;t.size>Io;){let e=t.keys().next().value;if(e===void 0)break;t.delete(e)}}var Mn={name:"date",render(t,e,n){let r=t.element;if(e==null||e===""){r.tagName==="INPUT"?r.value="":(r.tagName==="TIME"&&r.removeAttribute("datetime"),r.textContent="");return}let o=typeof e=="string"?e:T(e),s=new Date(o),a=!Number.isNaN(s.getTime());if(r.tagName==="INPUT"){r.value=a?No(r.type,s):o;return}if(r.tagName==="TIME"){r.setAttribute("datetime",a?s.toISOString():o),r.textContent=a?jr(s,n):o;return}r.textContent=a?jr(s,n):o}};function jr(t,e){let n=e.locale??Le();try{return Ur(n,{dateStyle:"medium",timeStyle:"short"}).format(t)}catch{return t.toISOString()}}function No(t,e){return t==="date"?e.toISOString().slice(0,10):t==="datetime-local"?e.toISOString().slice(0,16):e.toISOString()}y(Mn);var In={name:"number",render(t,e,n){let r=t.element;if(e==null||e===""){r.tagName==="INPUT"?r.value="":r.textContent="";return}let o=typeof e=="number"?e:Number(T(e));if(Number.isNaN(o)){r.textContent=T(e);return}if(r.tagName==="INPUT"){r.value=String(o);return}r.textContent=_o(o,n)}};function _o(t,e){let n=e.locale??Le();try{return $r(n).format(t)}catch{return String(t)}}y(In);var ht={name:"array",render(t,e){let n=t.element;if(!Array.isArray(e))return;let r=t.arrayTemplate;if(r!==void 0&&r.length>0){let s=Co(r,e);n.innerHTML=z(s);return}let o=t.arraySeparator??", ";n.textContent=e.map(Fo).join(o)}};function Co(t,e){let n="";for(let r=0;r<e.length;r+=1)n+=Oo(t,e[r],r);return n}function Oo(t,e,n){let r=t;if(typeof e=="object"&&e!==null)for(let[o,s]of Object.entries(e)){let a=new RegExp(`\\\\{\\\\{${Po(o)}\\\\}\\\\}`,"g");r=r.replace(a,g(T(s)))}else r=r.replace(/\\{\\{value\\}\\}/g,g(T(e)));return r=r.replace(/\\{\\{index\\}\\}/g,String(n)),r}function Po(t){return t.replace(/[.*+?^${}()|[\\]\\\\]/g,"\\\\$&")}function Fo(t){return T(t)}y(ht);y({...ht,name:"blocks"});function Do(){return typeof document>"u"?!1:typeof document.startViewTransition=="function"}async function Vr(t){if(!Do()){t();return}let n=document.startViewTransition.call(document,t);try{await n.finished}catch{}}var Yr="data-payload-key",yt="data-payload-nested-key",Cn="data-payload-nested-template",zr=new WeakMap;function Ct(t){let{template:e,container:n,patches:r}=t,o=Uo(n),s=[],a=[],u=[],m=[],w=[];for(let c of r)c.kind==="remove"?s.push(c):c.kind==="insert"?a.push(c):c.kind==="move"?u.push(c):c.kind==="update"?m.push(c):w.push(c);s.sort((c,b)=>_t(b)-_t(c));for(let c of s){if(c.kind!=="remove")continue;n.children[c.index]?.remove(),Ho(o,c.value)}for(let c of w){if(c.kind!=="replace")continue;let b=n.children[c.index],x=_n(e,c.value,c.index);!b||!x||(Gr(x,c.value),n.replaceChild(x,b),Nn(o,c.value))}for(let c of m){if(c.kind!=="update")continue;let b=n.children[c.index],x=_n(e,c.value,c.index);!b||!x||($o(b,x,c.value,o),n.replaceChild(x,b),Nn(o,c.value))}a.sort((c,b)=>_t(c)-_t(b));for(let c of a){if(c.kind!=="insert")continue;let b=n.children[c.index]??null,x=_n(e,c.value,c.index);x&&(Gr(x,c.value),n.insertBefore(x,b),Nn(o,c.value))}for(let c of u){if(c.kind!=="move")continue;let b=gt(c.value),x=b!==void 0?Bo(n,b):null;if(!x)continue;let Fe=n.children[c.to]??null;x!==Fe&&n.insertBefore(x,Fe)}}function Gr(t,e){let n=t.querySelectorAll(`[${yt}]`);for(let r of Array.from(n)){let o=r.getAttribute(yt);if(o===null)continue;let s=r.getAttribute(Cn);if(!s)continue;let a=On(e,o);if(a===void 0)continue;let u=rt([],a);u.length!==0&&Ct({template:s,container:r,patches:u,nextItems:a})}}function $o(t,e,n,r){let o=t.querySelectorAll(`[${yt}]`);if(o.length===0)return;let s=gt(n),a=s!==void 0?r.get(s):void 0;for(let u of Array.from(o)){let m=u.getAttribute(yt);if(m===null)continue;let w=e.querySelector(`[${yt}="${qr(m)}"]`);if(!w)continue;w.replaceWith(u);let c=u.getAttribute(Cn)??w.getAttribute(Cn);if(!c)continue;let b=On(n,m)??[],x=On(a,m)??[],Fe=rt(x,b);Fe.length!==0&&Ct({template:c,container:u,patches:Fe,nextItems:b})}}function On(t,e){if(typeof t!="object"||t===null)return;let n=t[e];if(Array.isArray(n))return n}function Uo(t){let e=zr.get(t);return e||(e=new Map,zr.set(t,e)),e}function Nn(t,e){let n=gt(e);n!==void 0&&t.set(n,e)}function Ho(t,e){let n=gt(e);n!==void 0&&t.delete(n)}function _t(t){return t.kind==="move"?t.to:t.index}function gt(t){if(typeof t!="object"||t===null)return;let e=t.id;if(typeof e=="string"||typeof e=="number")return String(e)}function Bo(t,e){return t.querySelector(`[${Yr}="${qr(e)}"]`)}function qr(t){let e=globalThis.CSS;return e?.escape?e.escape(t):t.replace(/[^a-zA-Z0-9_-]/g,"\\\\$&")}function _n(t,e,n){if(typeof document>"u")return null;let r=jo(t,e,n),o=z(r),s=document.createElement("template");s.innerHTML=o;let a=s.content.firstElementChild;if(!a)return null;let u=gt(e);return u!==void 0&&a.setAttribute(Yr,u),a}function jo(t,e,n){let r=t;if(typeof e=="object"&&e!==null)for(let[o,s]of Object.entries(e)){let a=new RegExp(`\\\\{\\\\{${Vo(o)}\\\\}\\\\}`,"g"),u=g(Wr(s));r=r.replace(a,()=>u)}else{let o=g(Wr(e));r=r.replace(/\\{\\{value\\}\\}/g,()=>o)}return r.replace(/\\{\\{index\\}\\}/g,String(n))}function Wr(t){return t==null?"":typeof t=="string"?t:typeof t=="number"||typeof t=="boolean"||typeof t=="bigint"?String(t):JSON.stringify(t)}function Vo(t){return t.replace(/[.*+?^${}()|[\\]\\\\]/g,"\\\\$&")}var Pn=new WeakMap,Kr=new WeakSet,Fn={name:"structural-array",render(t,e){if(!Array.isArray(e))return;let n=t.element,r=t.arrayTemplate;if(r===void 0||r.length===0){zo(n,t.fieldName);return}let o=Pn.get(n)??[],s=rt(o,e);if(s.length===0){Pn.set(n,e.slice());return}Vr(()=>{Ct({template:r,container:n,patches:s,nextItems:e})}),Pn.set(n,e.slice())}};function zo(t,e){Kr.has(t)||(Kr.add(t),console.warn(`[live-preview] Skipping structural update for "${e}" \\u2014 the <${t.tagName.toLowerCase()}> with data-payload-structural is missing data-payload-array-template. Add an inline template (e.g., data-payload-array-template="<li>{{label}}</li>") so the renderer can materialise new items.`))}y(Fn);var Go=[Tn,wn,xn,vn,ct,{...ct,name:"email"},En,kn,Sn,ft,{...ft,name:"radio"},An,Mn,In,ht,{...ht,name:"blocks"},Fn];function Xr(){return Or(Go)}function Wo(){if(typeof window>"u"||!Kt())return;let t=window.__livePreview;if(t!==void 0)return t;let e=Yo(),n=new Mt({additionalOrigins:e.additionalOrigins,enableReferrerDetection:!e.disableReferrerDetection,enableLocalhostMatching:!e.disableLocalhostMatching});n.isProductionUnconfigured?console.warn("[live-preview] No trusted origin could be detected. Set the PAYLOAD_ADMIN_ORIGIN env var or pass `allowedOrigins` to generateInlineScript()."):n.isReferrerOnlyTrust&&console.warn("[live-preview] Trusting the embedding page via document.referrer only \\u2014 any site that frames this page could post preview updates. Pass explicit `allowedOrigins` and serve a `frame-ancestors` CSP for production.");let r=new bt,o=Xr(),s=new Lt({renderers:o,originMatcher:u=>n.matches(u),readyTargets:n.enumerate(),emitter:r,...typeof e.serverURL=="string"&&e.serverURL!==""?{dataMerge:{serverURL:e.serverURL,...typeof e.apiRoute=="string"?{apiRoute:e.apiRoute}:{},...typeof e.mergeDepth=="number"?{depth:e.mergeDepth}:{}}}:{},debounceMs:e.debounceMs,heartbeatMs:e.heartbeatMs,intersectionRootMargin:e.intersectionRootMargin,disableVisibilityGate:e.disableVisibilityGate,visibilityGateThreshold:e.visibilityGateThreshold,enableA11y:e.enableA11y,onHeartbeatTimeout:()=>{n.unlockOrigin()},...e.debug?{log:(...u)=>{console.debug("[live-preview]",...u)}}:{}});r.on("connect",u=>{n.lockOrigin(u.origin)}),s.start();let a=Object.freeze({version:Rr,destroy:()=>{s.destroy()},refresh:()=>{s.refreshCache()},enumerateOrigins:()=>n.enumerate()});return Object.defineProperty(window,"__livePreview",{value:a,writable:!1,configurable:!0}),a}function Yo(){let t=typeof __LIVE_PREVIEW_CONFIG__>"u"?void 0:__LIVE_PREVIEW_CONFIG__;return t!==void 0?t:{additionalOrigins:[],serverURL:"",apiRoute:"/api",mergeDepth:1,debug:!1,debounceMs:50,enableA11y:!0,heartbeatMs:0,disableVisibilityGate:!1,visibilityGateThreshold:50,intersectionRootMargin:"200px",disableReferrerDetection:!1,disableLocalhostMatching:!1}}var qo=typeof __INLINE_BUILD__>"u"?!1:__INLINE_BUILD__;qo&&Wo();var Ol={isInIframe:dt,isInPopup:qt,isInPreviewContext:Kt};})();\n';
+var RUNTIME_BUILD_INFO = { generatedAt: "2026-07-11T16:51:06.280Z", size: 57982 };
+
+// src/inline/generator.ts
+var DEFAULT_DEBOUNCE_MS3 = 50;
+var DEFAULT_HEARTBEAT_MS = 0;
+var DEFAULT_VISIBILITY_GATE_THRESHOLD = 50;
+var DEFAULT_INTERSECTION_ROOT_MARGIN = "200px";
+function generateInlineScript(config = {}) {
+  if (RUNTIME_SOURCE.length === 0) {
+    throw new Error(
+      "[live-preview] runtime.generated.ts is empty. Run `npm run build:runtime` before bundling."
+    );
+  }
+  const configLiteral = JSON.stringify({
+    additionalOrigins: config.allowedOrigins ?? [],
+    serverURL: config.serverURL ?? "",
+    apiRoute: config.apiRoute ?? "/api",
+    mergeDepth: config.mergeDepth ?? 1,
+    debug: config.debug ?? false,
+    debounceMs: config.debounceMs ?? DEFAULT_DEBOUNCE_MS3,
+    enableA11y: config.enableA11y ?? true,
+    heartbeatMs: config.heartbeatMs ?? DEFAULT_HEARTBEAT_MS,
+    disableVisibilityGate: config.disableVisibilityGate ?? false,
+    visibilityGateThreshold: config.visibilityGateThreshold ?? DEFAULT_VISIBILITY_GATE_THRESHOLD,
+    intersectionRootMargin: config.intersectionRootMargin ?? DEFAULT_INTERSECTION_ROOT_MARGIN,
+    disableReferrerDetection: config.disableReferrerDetection ?? false,
+    disableLocalhostMatching: config.disableLocalhostMatching ?? false
+    // `<` must never appear literally inside an inline <script> body —
+    // a consumer-supplied string containing `</script>` would otherwise
+    // terminate the tag early.
+  }).replace(/</g, "\\u003C");
+  const generatedAt = RUNTIME_BUILD_INFO.generatedAt === "" ? "dev" : RUNTIME_BUILD_INFO.generatedAt;
+  return [
+    `/* payload-live-preview runtime ${generatedAt} */`,
+    `var __LIVE_PREVIEW_CONFIG__=${configLiteral};`,
+    `var __INLINE_BUILD__=true;`,
+    RUNTIME_SOURCE
+  ].join("\n");
+}
+function wrapWithScriptTag(body, options = {}) {
+  const nonceAttr = options.nonce !== void 0 ? ` nonce="${escapeNonce(options.nonce)}"` : "";
+  return `<script${nonceAttr}>${body}</script>`;
+}
+function runtimeBuildInfo() {
+  return RUNTIME_BUILD_INFO;
+}
+function escapeNonce(nonce) {
+  if (!/^[A-Za-z0-9+/=_-]+$/.test(nonce)) {
+    throw new RangeError("wrapWithScriptTag: nonce contains invalid characters");
+  }
+  return nonce;
+}
+
+// src/security/csp.ts
+var DEFAULT_NONCE_BYTES = 16;
+var cryptoOverride;
+function setCspCrypto(crypto) {
+  cryptoOverride = crypto ?? void 0;
+}
+function generateCspNonce(bytes = DEFAULT_NONCE_BYTES) {
+  if (!Number.isInteger(bytes) || bytes < 8) {
+    throw new RangeError(`generateCspNonce: bytes must be an integer >= 8, got ${String(bytes)}`);
+  }
+  const crypto = resolveCrypto();
+  if (!crypto) {
+    throw new Error(
+      "generateCspNonce: Web Crypto is unavailable. On Node 18 call setCspCrypto(webcrypto) once at startup, or run with --experimental-global-webcrypto. We won't fabricate a predictable nonce \u2014 that would silently defeat the entire CSP."
+    );
+  }
+  const buffer = new Uint8Array(bytes);
+  crypto.getRandomValues(buffer);
+  return base64UrlEncode(buffer);
+}
+function resolveCrypto() {
+  if (cryptoOverride?.getRandomValues) return cryptoOverride;
+  const fromGlobal = globalThis.crypto;
+  if (fromGlobal?.getRandomValues) return fromGlobal;
+  return void 0;
+}
+function base64UrlEncode(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  const base64 = typeof btoa === "function" ? btoa(binary) : Buffer.from(bytes).toString("base64");
+  return base64.replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function buildFrameAncestors(options = {}) {
+  const { self = true, origins = [], allowNone = false } = options;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  if (allowNone && !self && origins.length === 0) return "'none'";
+  if (self) {
+    out.push("'self'");
+    seen.add("'self'");
+  }
+  for (const origin of origins) {
+    const trimmed = origin.trim();
+    if (trimmed.length === 0 || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    out.push(trimmed);
+  }
+  return out.length > 0 ? out.join(" ") : "'none'";
+}
+function buildScriptSrcWithNonce(nonce, options = {}) {
+  if (nonce.length === 0) throw new RangeError("buildScriptSrcWithNonce: nonce is empty");
+  const { self = true, extra = [], strictDynamic = false } = options;
+  const parts = [];
+  if (self) parts.push("'self'");
+  parts.push(`'nonce-${nonce}'`);
+  if (strictDynamic) parts.push("'strict-dynamic'");
+  for (const e of extra) {
+    const trimmed = e.trim();
+    if (trimmed.length > 0) parts.push(trimmed);
+  }
+  return parts.join(" ");
+}
+function mergeCspHeader(existing, additions) {
+  const directives = /* @__PURE__ */ new Map();
+  for (const part of existing.split(";")) {
+    const trimmed = part.trim();
+    if (trimmed.length === 0) continue;
+    const spaceIndex = trimmed.indexOf(" ");
+    if (spaceIndex < 0) {
+      directives.set(trimmed.toLowerCase(), "");
+      continue;
+    }
+    directives.set(
+      trimmed.slice(0, spaceIndex).toLowerCase(),
+      trimmed.slice(spaceIndex + 1).trim()
+    );
+  }
+  for (const [rawName, rawAddition] of Object.entries(additions)) {
+    const name = rawName.toLowerCase();
+    const addition = typeof rawAddition === "string" ? { value: rawAddition } : rawAddition;
+    const mode = addition.mode ?? "union";
+    const current = directives.get(name);
+    if (mode === "replace" || current === void 0 || current.length === 0) {
+      directives.set(name, addition.value);
+      continue;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const token of [...current.split(/\s+/), ...addition.value.split(/\s+/)]) {
+      if (token.length === 0 || seen.has(token)) continue;
+      seen.add(token);
+      merged.push(token);
+    }
+    const withoutNone = merged.filter((token) => token !== "'none'");
+    directives.set(name, (withoutNone.length > 0 ? withoutNone : merged).join(" "));
+  }
+  const out = [];
+  for (const [name, value] of directives) {
+    out.push(value.length === 0 ? name : `${name} ${value}`);
+  }
+  return out.join("; ");
+}
+
+// src/adapters/shared/preview-request.ts
+var DEFAULT_QUERY_PARAMS = ["preview", "draft", "livePreview"];
+function isPreviewRequest(request, options = {}) {
+  const signals = new Set(options.signals ?? ["query", "fetch-dest", "referer"]);
+  const queryParams = options.queryParams ?? DEFAULT_QUERY_PARAMS;
+  const checkFetchDest = (options.checkFetchDest ?? true) && signals.has("fetch-dest");
+  if (signals.has("query")) {
+    let url;
+    try {
+      url = new URL(request.url);
+    } catch {
+      url = void 0;
+    }
+    if (url !== void 0) {
+      for (const param of queryParams) {
+        const value = url.searchParams.get(param);
+        if (value === "true" || value === "1") return true;
+      }
+    }
+  }
+  if (checkFetchDest && request.headers.get("sec-fetch-dest") === "iframe") {
+    return true;
+  }
+  const adminOrigins = signals.has("referer") ? options.adminOrigins ?? [] : [];
+  if (adminOrigins.length > 0) {
+    const referer = request.headers.get("referer");
+    if (referer !== null) {
+      try {
+        const refererOrigin = new URL(referer).origin;
+        for (const adminOrigin of adminOrigins) {
+          try {
+            if (new URL(adminOrigin).origin === refererOrigin) return true;
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+
+// src/preview-fetch.ts
+async function fetchPreviewDocument(options) {
+  const params = baseParams(options);
+  if (options.id !== void 0) {
+    const url2 = `${apiBase(options)}/${encodeURIComponent(options.collection)}/${encodeURIComponent(
+      String(options.id)
+    )}?${params.toString()}`;
+    return requestJson(url2, options);
+  }
+  if (options.where !== void 0) {
+    appendWhere(params, options.where, ["where"]);
+  }
+  params.set("limit", "1");
+  const url = `${apiBase(options)}/${encodeURIComponent(options.collection)}?${params.toString()}`;
+  const page = await requestJson(url, options);
+  const first = page?.docs?.[0];
+  return first ?? null;
+}
+async function fetchPreviewGlobal(options) {
+  const params = baseParams(options);
+  const url = `${apiBase(options)}/globals/${encodeURIComponent(options.global)}?${params.toString()}`;
+  return requestJson(url, options);
+}
+function apiBase(options) {
+  const origin = options.serverURL.replace(/\/+$/, "");
+  const route = options.apiRoute ?? "/api";
+  return `${origin}${route.startsWith("/") ? route : `/${route}`}`;
+}
+function baseParams(options) {
+  const params = new URLSearchParams();
+  params.set("depth", String(options.depth ?? 1));
+  if (options.draft ?? true) params.set("draft", "true");
+  if (options.locale !== void 0) params.set("locale", options.locale);
+  return params;
+}
+function appendWhere(params, node, path) {
+  for (const [key, value] of Object.entries(node)) {
+    const nextPath = [...path, key];
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      appendWhere(params, value, nextPath);
+      continue;
+    }
+    const name = nextPath.map((seg, i) => i === 0 ? seg : `[${seg}]`).join("");
+    if (Array.isArray(value)) {
+      params.set(name, value.map(String).join(","));
+    } else {
+      params.set(name, String(value));
+    }
+  }
+}
+async function requestJson(url, options) {
+  const fetchFn = options.fetchFn ?? (typeof fetch === "function" ? fetch : void 0);
+  if (fetchFn === void 0) return null;
+  try {
+    const response = await fetchFn(url, {
+      credentials: "include",
+      headers: {
+        Accept: "application/json",
+        ...options.headers ?? {}
+      }
+    });
+    if (!response.ok) return null;
+    const body = await response.json();
+    if (body === null || typeof body !== "object") return null;
+    return body;
+  } catch {
+    return null;
+  }
+}
+
+// src/plugins/built-in/highlight.ts
+var STYLE_ID = "payload-live-preview-highlight";
+var REDUCED_MOTION_CSS = ".lp-highlight{outline:2px solid rgba(0,102,204,0.85);outline-offset:2px;}";
+var ANIMATED_CSS = "@keyframes lp-highlight{0%{outline:2px solid rgba(0,102,204,0.85);outline-offset:2px}100%{outline:2px solid transparent;outline-offset:2px}}.lp-highlight{animation:lp-highlight 0.6s ease-out;}";
+var highlightPlugin = {
+  name: "highlight",
+  version: "1.0.0",
+  init: (ctx) => {
+    if (typeof document === "undefined") return;
+    const prefersReducedMotion = typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    if (!document.getElementById(STYLE_ID)) {
+      const style = document.createElement("style");
+      style.id = STYLE_ID;
+      style.textContent = prefersReducedMotion ? REDUCED_MOTION_CSS : ANIMATED_CSS;
+      document.head.appendChild(style);
+    }
+    const duration = prefersReducedMotion ? 1e3 : 600;
+    ctx.events.on("elementUpdate", (e) => {
+      const element = e.element;
+      element.classList.add("lp-highlight");
+      window.setTimeout(() => {
+        element.classList.remove("lp-highlight");
+      }, duration);
+    });
+  },
+  destroy: () => {
+    if (typeof document === "undefined") return;
+    document.getElementById(STYLE_ID)?.remove();
+  }
+};
+
+// src/plugins/built-in/debug.ts
+var debugPlugin = {
+  name: "debug",
+  version: "1.0.0",
+  init: (ctx) => {
+    ctx.events.on("init", () => {
+      ctx.log("init");
+    });
+    ctx.events.on("connect", (e) => {
+      ctx.log("connect \u2190", e.origin);
+    });
+    ctx.events.on("disconnect", (e) => {
+      ctx.log("disconnect (", e.reason, ")");
+    });
+    ctx.events.on("cacheRefresh", (e) => {
+      ctx.log("cacheRefresh", e.elementCount, "elements,", e.fieldCount, "fields");
+    });
+    ctx.events.on("beforeUpdate", (e) => {
+      ctx.log("beforeUpdate", Object.keys(e.data.fields).length, "fields");
+    });
+    ctx.events.on("afterUpdate", (e) => {
+      ctx.log("afterUpdate", e.updatedCount, "in", e.durationMs.toFixed(2), "ms");
+    });
+    ctx.events.on("error", (e) => {
+      ctx.log("error in", e.context, ":", e.error.message);
+    });
+  }
+};
+
+// src/plugins/built-in/analytics.ts
+function createAnalyticsPlugin() {
+  let updateCount = 0;
+  let totalElements = 0;
+  let totalDurationMs = 0;
+  return {
+    name: "analytics",
+    version: "1.0.0",
+    init: (ctx) => {
+      ctx.events.on("afterUpdate", (e) => {
+        updateCount += 1;
+        totalElements += e.updatedCount;
+        totalDurationMs += e.durationMs;
+      });
+    },
+    getStats: () => ({
+      updateCount,
+      totalElements,
+      totalDurationMs,
+      averageDurationMs: updateCount === 0 ? 0 : totalDurationMs / updateCount
+    })
+  };
+}
+
+// src/plugins/built-in/document-save.ts
+var SCROLL_KEY = "payload-live-preview:scroll";
+function saveScrollPosition() {
+  if (typeof window === "undefined") return;
+  try {
+    sessionStorage.setItem(
+      SCROLL_KEY,
+      JSON.stringify({ href: window.location.href, x: window.scrollX, y: window.scrollY })
+    );
+  } catch {
+  }
+}
+function restoreScrollPosition() {
+  if (typeof window === "undefined") return;
+  try {
+    const raw = sessionStorage.getItem(SCROLL_KEY);
+    if (raw === null) return;
+    sessionStorage.removeItem(SCROLL_KEY);
+    const saved = JSON.parse(raw);
+    if (saved.href !== window.location.href) return;
+    window.scrollTo(saved.x ?? 0, saved.y ?? 0);
+  } catch {
+  }
+}
+function reloadPreservingScroll() {
+  if (typeof window === "undefined") return;
+  saveScrollPosition();
+  window.location.reload();
+}
+var DEFAULT_REVALIDATE_URL = "/api/revalidate";
+function documentSavePlugin(options = {}) {
+  const strategy = options.strategy ?? "silent";
+  return {
+    name: "document-save",
+    version: "1.1.0",
+    init: (ctx) => {
+      restoreScrollPosition();
+      ctx.events.on("documentSave", () => {
+        run(strategy, options, ctx.log);
+      });
+    }
+  };
+}
+function run(strategy, options, log) {
+  if (strategy === "silent") return;
+  if (strategy === "reload") {
+    reloadPreservingScroll();
+    return;
+  }
+  if (strategy === "fetch") {
+    void runFetch(options, log);
+    return;
+  }
+  void runRevalidate(options, log);
+}
+async function runFetch(options, log) {
+  if (!options.handler) {
+    log("document-save: fetch strategy selected but no handler supplied");
+    return;
+  }
+  try {
+    await options.handler();
+  } catch (err) {
+    log("document-save handler threw:", err);
+  }
+}
+async function runRevalidate(options, log) {
+  if (typeof fetch === "undefined") {
+    log("document-save: revalidate strategy needs fetch \u2014 not available");
+    return;
+  }
+  const url = options.revalidateUrl ?? DEFAULT_REVALIDATE_URL;
+  let ok = false;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...options.revalidateHeaders ?? {}
+      },
+      body: JSON.stringify({ source: "payload-live-preview" })
+    });
+    ok = response.ok;
+    if (!ok) log("document-save revalidate non-2xx:", response.status);
+  } catch (err) {
+    log("document-save revalidate failed:", err);
+  }
+  if (!ok && options.onRevalidateFailure === "reload") {
+    reloadPreservingScroll();
+  }
+}
+
+// src/dsl/bind.ts
+function bind(field, options) {
+  return buildAttributes(field, options);
+}
+function bindByPath(picker, options) {
+  const path = recordPath(picker);
+  if (path.length === 0) {
+    throw new Error(
+      "bindByPath: the picker did not read any field \u2014 return data.<field> instead of a constant"
+    );
+  }
+  return buildAttributes(path.join("."), options);
+}
+function buildAttributes(field, options) {
+  if (field.length === 0) {
+    throw new Error("bind: field name must be a non-empty string");
+  }
+  const attrs = { "data-payload-field": field };
+  if (options?.attribute !== void 0) attrs["data-payload-attribute"] = options.attribute;
+  if (options?.type !== void 0) attrs["data-payload-type"] = options.type;
+  return attrs;
+}
+function recordPath(picker) {
+  const path = [];
+  const proxy = new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (typeof prop === "symbol") return void 0;
+        if (/^\d+$/.test(prop)) return proxy;
+        path.push(prop);
+        return proxy;
+      }
+    }
+  );
+  try {
+    picker(proxy);
+  } catch {
+  }
+  return path;
+}
+
+export { EventEmitter, LIBRARY_PROTOCOL_VERSION, LivePreviewClient, OriginDetector, VERSION, bind, bindByPath, buildBuiltinRenderers2 as buildBuiltinRenderers, buildFrameAncestors, buildScriptSrcWithNonce, createAnalyticsPlugin, debugPlugin, detectInitialLocale, documentSavePlugin, escapeHtml, escapeHtmlAttribute, fetchPreviewDocument, fetchPreviewGlobal, generateCspNonce, generateInlineScript, hasCapability, highlightPlugin, initLivePreview, isDevMode, isExternalHttpUrl, isInIframe, isInPopup, isInPreviewContext, isLexicalContent, isPreviewRequest, isSafeUrl, lexicalToHtml, lexicalToPlainText, mergeCspHeader, negotiateProtocol, registerBlockRenderer, registerBuiltinRenderer, runtimeBuildInfo, sanitizeHtml, setCspCrypto, setSanitizerDocument, wrapWithScriptTag };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map