@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/chunk-IUONB55J.js

@@ -0,0 +1,669 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  relinkSplitHalves
+} from "./chunk-6JR2XUEE.js";
+import {
+  EXCLUDED_TAGS,
+  ensureHfIds,
+  mintHfId,
+  walkCompositionDescendants
+} from "./chunk-RNV3DM4S.js";
+import {
+  isAllowedHtmlAttribute,
+  isSafeAttributeValue,
+  sanitizeRichTextChildren
+} from "./chunk-DLA44CMS.js";
+import {
+  decodedUrlPath,
+  removeElementWithGsapCascade
+} from "./chunk-B7RJV74O.js";
+import {
+  require_dist
+} from "./chunk-4P7NX5BM.js";
+import {
+  readClipTiming,
+  writeClipTiming
+} from "./chunk-MMQ52NIZ.js";
+import {
+  readMediaOffsetSeconds,
+  readPlaybackRate
+} from "./chunk-BSQ7XANM.js";
+import {
+  parseHTML
+} from "./chunk-SDYDNHEE.js";
+import {
+  __toESM
+} from "./chunk-M2WBOQ2Q.js";
+
+// ../core/dist/timelineAssetId.js
+function trimIdUnderscores(value) {
+  let start = 0;
+  let end = value.length;
+  while (value[start] === "_")
+    start += 1;
+  while (end > start && value[end - 1] === "_")
+    end -= 1;
+  return value.slice(start, end);
+}
+function buildTimelineAssetId(assetPath, existingIds) {
+  const baseName = assetPath.slice(assetPath.lastIndexOf("/") + 1);
+  const normalized = baseName.replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]+/g, "_").toLowerCase();
+  const baseId = trimIdUnderscores(normalized) || "asset";
+  const ids = new Set(existingIds);
+  if (!ids.has(baseId))
+    return baseId;
+  let suffix = 2;
+  while (ids.has(`${baseId}_${suffix}`))
+    suffix += 1;
+  return `${baseId}_${suffix}`;
+}
+function referenceChildren(element) {
+  if (element.children.length > 0)
+    return element.children;
+  if (element.tagName.toLowerCase() !== "template")
+    return [];
+  const content = element.content;
+  return content ? content.children : [];
+}
+function documentElements(document) {
+  const elements = [];
+  const visit = (element) => {
+    elements.push(element);
+    for (const child of referenceChildren(element))
+      visit(child);
+  };
+  if (document.documentElement)
+    visit(document.documentElement);
+  return elements;
+}
+function decodeIdEscape(original, hex) {
+  const codePoint = Number.parseInt(hex, 16);
+  return codePoint <= 1114111 ? String.fromCodePoint(codePoint) : original;
+}
+function referencesId(value, id) {
+  const decoded = value.replace(/\\x([0-9a-f]{2})/gi, (original, hex) => decodeIdEscape(original, hex)).replace(/\\u\{([0-9a-f]+)\}|\\u([0-9a-f]{4})/gi, (original, braced, fixed) => decodeIdEscape(original, braced ?? fixed)).replace(/\\([0-9a-f]{1,6})\s?/gi, (original, hex) => decodeIdEscape(original, hex)).replace(/\\([^\r\n])/g, "$1");
+  return decoded.includes(id);
+}
+function decodeFragment(value) {
+  const fragment = value.split("#").slice(1).join("#");
+  try {
+    return decodeURIComponent(fragment);
+  } catch {
+    return fragment;
+  }
+}
+function attributeReferencesId(attribute, id) {
+  if (["id", "data-hf-id"].includes(attribute.name))
+    return false;
+  if (attribute.name === "src")
+    return referencesId(decodeFragment(attribute.value), id);
+  return referencesId(attribute.value, id);
+}
+function elementReferencesId(element, id) {
+  const code = ["script", "style"].includes(element.tagName.toLowerCase());
+  if (code && referencesId(element.textContent ?? "", id))
+    return true;
+  return Array.from(element.attributes).some((attribute) => attributeReferencesId(attribute, id));
+}
+function readMediaIdentity(element) {
+  const media = ["video", "audio", "img"].includes(element.tagName.toLowerCase());
+  const src = element.getAttribute("src");
+  const id = element.getAttribute("id");
+  if (!media || !src || !id)
+    return null;
+  return { id, src };
+}
+function matchesGeneratedId({ id, src }) {
+  const base = buildTimelineAssetId(decodedUrlPath(src), []);
+  const suffix = id.slice(base.length);
+  return id === base || id.startsWith(base) && /^_(?:[2-9]\d*|1\d+)$/.test(suffix);
+}
+function canRenameMedia(element, identity, newSrc) {
+  const authored = ["data-timeline-label", "data-label", "aria-label"].some((name) => element.getAttribute(name)?.trim());
+  return !authored && identity.src !== newSrc && matchesGeneratedId(identity);
+}
+function replacementTimelineAssetId(document, element, newSrc) {
+  const identity = readMediaIdentity(element);
+  if (!identity || !canRenameMedia(element, identity, newSrc))
+    return null;
+  const elements = documentElements(document);
+  if (elements.some((other) => elementReferencesId(other, identity.id)))
+    return null;
+  const ids = elements.filter((other) => other !== element).map((other) => other.getAttribute("id")).filter((value) => value !== null);
+  return buildTimelineAssetId(decodedUrlPath(newSrc), ids);
+}
+
+// ../studio-server/dist/chunk-BYVZQTMW.js
+var import_postcss_selector_parser = __toESM(require_dist(), 1);
+import postcss from "postcss";
+function parseStyleDecls(style) {
+  const props = /* @__PURE__ */ new Map();
+  const order = [];
+  let i = 0;
+  while (i < style.length) {
+    let depth = 0;
+    let inSingle = false;
+    let inDouble = false;
+    const start = i;
+    while (i < style.length) {
+      const ch = style[i];
+      if (ch === "'" && !inDouble) inSingle = !inSingle;
+      else if (ch === '"' && !inSingle) inDouble = !inDouble;
+      else if (!inSingle && !inDouble) {
+        if (ch === "(") depth++;
+        else if (ch === ")") depth = Math.max(0, depth - 1);
+        else if (ch === ";" && depth === 0) break;
+      }
+      i++;
+    }
+    const decl = style.slice(start, i).trim();
+    i++;
+    if (!decl) continue;
+    const colon = decl.indexOf(":");
+    if (colon < 0) continue;
+    const key = decl.slice(0, colon).trim();
+    const val = decl.slice(colon + 1).trim();
+    if (!key) continue;
+    if (!props.has(key)) order.push(key);
+    props.set(key, val);
+  }
+  return { props, order };
+}
+function serializeStyleDecls(props, order) {
+  return order.map((k) => `${k}: ${props.get(k) ?? ""}`).filter((d) => d.trim()).join("; ");
+}
+function patchStyleAttrString(style, property, value) {
+  const { props, order } = parseStyleDecls(style);
+  if (value === null) {
+    props.delete(property);
+    const idx = order.indexOf(property);
+    if (idx >= 0) order.splice(idx, 1);
+  } else {
+    if (!props.has(property)) order.push(property);
+    props.set(property, value);
+  }
+  return serializeStyleDecls(props, order);
+}
+var pinnedInSource = /* @__PURE__ */ new WeakMap();
+function parseSourceDocument(raw) {
+  const source = ensureHfIds(raw);
+  const hasDocumentShell = /<!doctype|<html[\s>]/i.test(source);
+  const document = hasDocumentShell ? parseHTML(source).document : parseHTML(`<!DOCTYPE html><html><head></head><body>${source}</body></html>`).document;
+  pinnedInSource.set(
+    document,
+    new Set(Array.from(raw.matchAll(/\bdata-hf-id\s*=\s*["']?([^"'\s>]+)/gi), (m) => m[1]))
+  );
+  return { document, wrappedFragment: !hasDocumentShell };
+}
+function duplicateCssRulesForId(document, originalId, newId) {
+  const idToken = `#${originalId}`;
+  const transform = (0, import_postcss_selector_parser.default)((selectors) => {
+    selectors.walkIds((node) => {
+      if (node.value === originalId) node.value = newId;
+    });
+  });
+  for (const styleEl of document.querySelectorAll("style")) {
+    const css = styleEl.textContent ?? "";
+    let root;
+    try {
+      root = postcss.parse(css);
+    } catch {
+      continue;
+    }
+    const clones = [];
+    root.walkRules((rule) => {
+      if (!rule.selector.includes(idToken)) return;
+      const newSelector = transform.processSync(rule.selector);
+      if (newSelector === rule.selector) return;
+      const clone = rule.clone({ selector: newSelector });
+      clones.push(clone);
+    });
+    if (clones.length > 0) {
+      for (const c of clones) root.append(c);
+      styleEl.textContent = root.toString();
+    }
+  }
+}
+function querySelectorAllWithTemplates(root, selector) {
+  const matches = Array.from(root.querySelectorAll(selector));
+  if (matches.length > 0) return matches;
+  const templates = Array.from(root.querySelectorAll("template"));
+  for (const tmpl of templates) {
+    const inner = querySelectorAllWithTemplates(tmpl, selector);
+    if (inner.length > 0) return inner;
+  }
+  return [];
+}
+function escapeCssAttrValue(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function findByHfId(document, hfId) {
+  try {
+    const matches = querySelectorAllWithTemplates(
+      document,
+      `[data-hf-id="${escapeCssAttrValue(hfId)}"]`
+    );
+    if (matches.length > 1) {
+      console.warn(
+        `sourceMutation: data-hf-id "${hfId}" matched ${matches.length} elements; using the first. ids must be unique per document.`
+      );
+    }
+    return matches[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function findTargetElement(document, target) {
+  if (target.hfId) {
+    const el = findByHfId(document, target.hfId);
+    if (el) return el;
+  }
+  const pinned = pinnedInSource.get(document);
+  const unlessPinnedElsewhere = (el) => el && !(target.hfId && pinned?.has(el.getAttribute("data-hf-id") ?? "")) ? el : null;
+  if (target.id) {
+    const byId = unlessPinnedElsewhere(document.getElementById(target.id));
+    if (byId) return byId;
+  }
+  if (!target.selector) return null;
+  try {
+    const matches = querySelectorAllWithTemplates(document, target.selector);
+    return unlessPinnedElsewhere(matches[target.selectorIndex ?? 0]);
+  } catch {
+    return null;
+  }
+}
+function removeElementsFromHtml(source, targets) {
+  const { document, wrappedFragment } = parseSourceDocument(source);
+  let removed = false;
+  for (const target of targets) {
+    const element = findTargetElement(document, target);
+    if (!element) continue;
+    removeElementWithGsapCascade(document, element);
+    removed = true;
+  }
+  if (!removed) return source;
+  return wrappedFragment ? document.body.innerHTML || "" : document.toString();
+}
+function removeElementFromHtml(source, target) {
+  return removeElementsFromHtml(source, [target]);
+}
+function isHTMLElement(el) {
+  const HTMLEl = el.ownerDocument?.defaultView?.HTMLElement;
+  return HTMLEl ? el instanceof HTMLEl : el.nodeType === 1 && "style" in el;
+}
+function mountsComposition(document, host, compositionId) {
+  if (host.hasAttribute("data-composition-src")) return true;
+  return host.children.length === 0 && querySelectorAllWithTemplates(document, "template").some(
+    (template) => template.id === `${compositionId}-template`
+  );
+}
+function dedupeClonedCompositionId(document, clone) {
+  const compositionId = clone.getAttribute("data-composition-id");
+  if (!compositionId || mountsComposition(document, clone, compositionId)) return;
+  const usedCompositionIds = new Set(
+    querySelectorAllWithTemplates(document, "[data-composition-id]").map(
+      (node) => node.getAttribute("data-composition-id")
+    )
+  );
+  const base = `${compositionId}-split`;
+  let nextCompositionId = base;
+  let suffix = 2;
+  while (usedCompositionIds.has(nextCompositionId)) nextCompositionId = `${base}-${suffix++}`;
+  clone.setAttribute("data-composition-id", nextCompositionId);
+}
+function resolveOperationTarget(parent, op) {
+  if (op.childSelector === void 0) return parent;
+  try {
+    const child = parent.querySelectorAll(op.childSelector)[op.childIndex ?? 0] ?? null;
+    return child && isHTMLElement(child) ? child : null;
+  } catch {
+    return null;
+  }
+}
+function stampNewChildIds(parent) {
+  const assigned = /* @__PURE__ */ new Set();
+  const root = parent.ownerDocument?.body ?? parent;
+  walkCompositionDescendants(root, (el) => {
+    const id = el.getAttribute("data-hf-id");
+    if (id) assigned.add(id);
+  });
+  for (const el of parent.querySelectorAll("*")) {
+    if (el.getAttribute("data-hf-id")) continue;
+    if (EXCLUDED_TAGS.has(el.tagName.toLowerCase())) continue;
+    el.setAttribute("data-hf-id", mintHfId(el, assigned));
+  }
+}
+function patchElementInHtml(source, target, operations, takenIds) {
+  const { document, wrappedFragment } = parseSourceDocument(source);
+  const el = findTargetElement(document, target);
+  if (!el || !isHTMLElement(el)) return { html: source, matched: false };
+  const htmlEl = el;
+  const originalHtml = wrappedFragment ? document.body.innerHTML || "" : document.toString();
+  const resolved = [];
+  for (const op of operations) {
+    const opTarget = resolveOperationTarget(htmlEl, op);
+    if (!opTarget) return { html: source, matched: false };
+    resolved.push({ op, target: opTarget });
+  }
+  for (const { op, target: opTarget } of resolved) {
+    switch (op.type) {
+      case "inline-style":
+        {
+          const raw = opTarget.getAttribute("style") ?? "";
+          const patched = patchStyleAttrString(raw, op.property, op.value);
+          opTarget.setAttribute("style", patched);
+        }
+        break;
+      case "attribute":
+        {
+          const fullAttr = op.property.startsWith("data-") ? op.property : `data-${op.property}`;
+          if (op.value != null) {
+            opTarget.setAttribute(fullAttr, op.value);
+          } else {
+            opTarget.removeAttribute(fullAttr);
+          }
+        }
+        break;
+      case "html-attribute":
+        if (!isAllowedHtmlAttribute(op.property)) break;
+        if (op.value != null) {
+          if (!isSafeAttributeValue(op.property, op.value)) break;
+          const replacementId = op.property === "src" ? replacementTimelineAssetId(document, opTarget, op.value) : null;
+          if (replacementId !== null) opTarget.setAttribute("id", replacementId);
+          opTarget.setAttribute(op.property, op.value);
+        } else {
+          opTarget.removeAttribute(op.property);
+        }
+        break;
+      case "ensure-id":
+        if (opTarget.getAttribute("id") || !op.value) break;
+        opTarget.setAttribute("id", nextUniqueId(document, op.value, takenIds));
+        break;
+      case "text-content":
+        if (op.value != null) {
+          const inner = opTarget.children.length === 1 ? opTarget.firstElementChild : null;
+          const textTarget = inner && isHTMLElement(inner) ? inner : opTarget;
+          textTarget.textContent = op.value;
+        }
+        break;
+      // The one operation that can write markup, so the one that has to check
+      // it. Assigned first and sanitised after, rather than sanitising a
+      // string: parsing is what turns a payload into the tree the allowlist
+      // can actually judge, and linkedom never runs anything it parses.
+      case "rich-text":
+        if (op.value != null) {
+          opTarget.innerHTML = op.value;
+          sanitizeRichTextChildren(opTarget);
+          stampNewChildIds(opTarget);
+        }
+        break;
+    }
+  }
+  const html = wrappedFragment ? document.body.innerHTML || "" : document.toString();
+  const elementId = htmlEl.getAttribute("id");
+  if (html === originalHtml) return { html: source, matched: true, elementId };
+  return { html: ensureHfIds(html), matched: true, elementId };
+}
+function nextUniqueId(document, base, takenIds) {
+  let id = base;
+  let suffix = 2;
+  while (document.getElementById(id) || takenIds?.has(id)) id = `${base}-${suffix++}`;
+  return id;
+}
+function probeElementsInSource(source, targets) {
+  const { document } = parseSourceDocument(source);
+  return targets.map((target) => {
+    if (!target.id && !target.hfId && !target.selector) return false;
+    const el = findTargetElement(document, target);
+    return el != null && isHTMLElement(el);
+  });
+}
+function probeElementInSource(source, target) {
+  return probeElementsInSource(source, [target])[0] ?? false;
+}
+function resolveElementTiming(el) {
+  const timing = readClipTiming(el);
+  return { start: timing.start ?? 0, duration: timing.duration ?? 0 };
+}
+function setElementDuration(el, start, duration, trackIndex) {
+  writeClipTiming(el, {
+    start: Math.round(start * 1e3) / 1e3,
+    duration: Math.round(duration * 1e3) / 1e3,
+    ...trackIndex != null ? { trackIndex } : {}
+  });
+}
+function isWindowOf(media, row) {
+  if (media.duration <= 0) return false;
+  const near = (a, b) => Math.abs(a - b) < 1e-3;
+  return !row || near(media.start, row.start) && near(media.duration, row.duration);
+}
+function splitElementInHtml(source, target, splitTime, newId, fallbackTiming) {
+  const { document, wrappedFragment } = parseSourceDocument(source);
+  const el = findTargetElement(document, target);
+  if (!el || !isHTMLElement(el)) return { html: source, matched: false, newId: null };
+  const timedMediaSelector = "video[data-start], audio[data-start]";
+  const innerMedia = el.hasAttribute("data-start") || resolveElementTiming(el).duration > 0 || el.matches("[data-composition-src], [data-composition-id]") ? null : el.querySelector(timedMediaSelector);
+  const timedMedia = innerMedia && isWindowOf(resolveElementTiming(innerMedia), fallbackTiming) ? innerMedia : null;
+  const timed = timedMedia ?? el;
+  const timing = resolveElementTiming(timed);
+  let { start, duration } = timing;
+  if (duration <= 0 && fallbackTiming && fallbackTiming.duration > 0) {
+    start = fallbackTiming.start;
+    duration = fallbackTiming.duration;
+  }
+  if (duration <= 0 || splitTime <= start || splitTime >= start + duration) {
+    return { html: source, matched: false, newId: null };
+  }
+  newId = nextUniqueId(document, newId);
+  const firstDuration = splitTime - start;
+  const secondDuration = duration - firstDuration;
+  const clone = el.cloneNode(true);
+  if (!isHTMLElement(clone)) return { html: source, matched: false, newId: null };
+  clone.setAttribute("id", newId);
+  dedupeClonedCompositionId(document, clone);
+  clone.removeAttribute("data-hf-id");
+  for (const node of clone.querySelectorAll("[data-hf-id]")) node.removeAttribute("data-hf-id");
+  const clonedTimed = timedMedia ? clone.querySelector(timedMediaSelector) : clone;
+  if (timedMedia?.id) {
+    const mediaId = nextUniqueId(document, `${timedMedia.id}-split`, /* @__PURE__ */ new Set([newId]));
+    duplicateCssRulesForId(document, timedMedia.id, mediaId);
+    clonedTimed.setAttribute("id", mediaId);
+  }
+  setElementDuration(clonedTimed, splitTime, secondDuration, fallbackTiming?.track);
+  const playbackStartAttr = timed.hasAttribute("data-playback-start") ? "data-playback-start" : timed.hasAttribute("data-media-start") ? "data-media-start" : timed.matches("[data-composition-src], [data-composition-id]") ? "data-playback-start" : timed.matches("audio, video") ? "data-media-start" : null;
+  if (playbackStartAttr) {
+    const readAttr = (name) => timed.getAttribute(name);
+    const authoredTrim = timed.getAttribute(playbackStartAttr);
+    const currentTrim = authoredTrim !== null ? readMediaOffsetSeconds(readAttr) : fallbackTiming?.playbackStart ?? 0;
+    const rate = readPlaybackRate(readAttr, fallbackTiming?.playbackRate);
+    if (authoredTrim === null || Number(authoredTrim) !== currentTrim)
+      timed.setAttribute(playbackStartAttr, String(Math.round(currentTrim * 1e3) / 1e3));
+    clonedTimed.setAttribute(
+      playbackStartAttr,
+      String(Math.round((currentTrim + firstDuration * rate) * 1e3) / 1e3)
+    );
+  }
+  const originalId = el.getAttribute("id");
+  if (originalId) {
+    duplicateCssRulesForId(document, originalId, newId);
+  }
+  setElementDuration(timed, start, firstDuration, fallbackTiming?.track);
+  if (el.nextSibling) {
+    el.parentElement.insertBefore(clone, el.nextSibling);
+  } else {
+    el.parentElement.appendChild(clone);
+  }
+  const html = wrappedFragment ? document.body.innerHTML || "" : document.toString();
+  return {
+    // The split owns its new nodes' stable ids. Leaving the clone unstamped makes
+    // the next preview request persist different bytes after history is recorded.
+    html: ensureHfIds(html),
+    matched: true,
+    newId
+  };
+}
+function getInlineStylePx(el, property) {
+  const style = (isHTMLElement(el) ? el.getAttribute("style") : null) ?? "";
+  const { props } = parseStyleDecls(style);
+  const raw = props.get(property);
+  if (!raw) return 0;
+  const n = parseFloat(raw);
+  return Number.isFinite(n) ? n : 0;
+}
+function setInlineLeftTop(el, left, top) {
+  let style = el.getAttribute("style") ?? "";
+  style = patchStyleAttrString(style, "left", `${left}px`);
+  style = patchStyleAttrString(style, "top", `${top}px`);
+  el.setAttribute("style", style);
+}
+function uniqueGroupDomId(document, groupId) {
+  const base = groupId.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "group";
+  return nextUniqueId(document, base);
+}
+function wrapElementsInHtml(source, targets, groupId, bbox, rebases) {
+  const { document, wrappedFragment } = parseSourceDocument(source);
+  if (targets.length === 0) {
+    return { html: source, matched: false, groupId: null, error: "no targets" };
+  }
+  const els = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const target of targets) {
+    const el = findTargetElement(document, target);
+    if (!el || !isHTMLElement(el) || seen.has(el)) continue;
+    seen.add(el);
+    els.push(el);
+  }
+  if (els.length === 0) {
+    return { html: source, matched: false, groupId: null, error: "no targets matched" };
+  }
+  const parent = els[0]?.parentElement;
+  if (!parent || els.some((el) => el.parentElement !== parent)) {
+    return {
+      html: source,
+      matched: false,
+      groupId: null,
+      error: "grouped elements must share a single parent"
+    };
+  }
+  const memberSet = new Set(els);
+  const ordered = Array.from(parent.children).filter((c) => memberSet.has(c));
+  const rebaseByEl = /* @__PURE__ */ new Map();
+  for (const rebase of rebases) {
+    const el = findTargetElement(document, rebase.target);
+    if (el) rebaseByEl.set(el, { left: rebase.left, top: rebase.top, track: rebase.track });
+  }
+  const wrapper = document.createElement("div");
+  wrapper.setAttribute("data-hf-group", groupId);
+  wrapper.setAttribute("id", uniqueGroupDomId(document, groupId));
+  const memberZIndexes = ordered.map(
+    (el) => Number.parseInt(
+      parseStyleDecls(el.getAttribute("style") ?? "").props.get("z-index") ?? "",
+      10
+    )
+  ).filter((z) => Number.isFinite(z));
+  const maxZ = memberZIndexes.length > 0 ? Math.max(...memberZIndexes) : null;
+  wrapper.setAttribute(
+    "style",
+    `position: absolute; left: ${bbox.left}px; top: ${bbox.top}px; width: ${bbox.width}px; height: ${bbox.height}px` + (maxZ !== null ? `; z-index: ${maxZ}` : "")
+  );
+  parent.insertBefore(wrapper, ordered[ordered.length - 1] ?? null);
+  for (const el of ordered) {
+    const rebase = rebaseByEl.get(el);
+    if (rebase) setInlineLeftTop(el, rebase.left, rebase.top);
+    if (rebase?.track != null) writeClipTiming(el, { trackIndex: Math.round(rebase.track) });
+    wrapper.appendChild(el);
+  }
+  return {
+    html: wrappedFragment ? document.body.innerHTML || "" : document.toString(),
+    matched: true,
+    groupId
+  };
+}
+function buildChildTrackMap(document, group, childTracks) {
+  const trackByEl = /* @__PURE__ */ new Map();
+  for (const entry of childTracks) {
+    const el = findTargetElement(document, entry.target);
+    if (el && group.contains(el) && entry.track != null) trackByEl.set(el, entry.track);
+  }
+  return trackByEl;
+}
+function relocateGroupChildren(group, parent, wLeft, wTop, trackByEl) {
+  const members = [];
+  for (const child of Array.from(group.children)) {
+    if (isHTMLElement(child)) {
+      const newLeft = getInlineStylePx(child, "left") + wLeft;
+      const newTop = getInlineStylePx(child, "top") + wTop;
+      setInlineLeftTop(child, newLeft, newTop);
+      const track = trackByEl.get(child);
+      if (track != null) writeClipTiming(child, { trackIndex: Math.round(track) });
+      if (child.id) {
+        members.push({
+          id: child.id,
+          cx: newLeft + getInlineStylePx(child, "width") / 2,
+          cy: newTop + getInlineStylePx(child, "height") / 2
+        });
+      }
+    }
+    parent.insertBefore(child, group);
+  }
+  return members;
+}
+function unwrapElementsFromHtml(source, groupTarget, childTracks = []) {
+  const { document, wrappedFragment } = parseSourceDocument(source);
+  const group = findTargetElement(document, groupTarget);
+  if (!group || !isHTMLElement(group)) return { html: source, unwrapped: false };
+  if (!group.hasAttribute("data-hf-group")) return { html: source, unwrapped: false };
+  const parent = group.parentElement;
+  if (!parent) return { html: source, unwrapped: false };
+  const trackByEl = buildChildTrackMap(document, group, childTracks);
+  const wLeft = getInlineStylePx(group, "left");
+  const wTop = getInlineStylePx(group, "top");
+  const groupCenter = {
+    cx: wLeft + getInlineStylePx(group, "width") / 2,
+    cy: wTop + getInlineStylePx(group, "height") / 2
+  };
+  const members = relocateGroupChildren(group, parent, wLeft, wTop, trackByEl);
+  const groupId = group.id || void 0;
+  group.remove();
+  return {
+    html: wrappedFragment ? document.body.innerHTML || "" : document.toString(),
+    unwrapped: true,
+    unwrappedGroupId: groupId,
+    members,
+    groupCenter
+  };
+}
+function relinkSplitHalvesInHtml(source, rightHalfIds) {
+  const { document, wrappedFragment } = parseSourceDocument(source);
+  const carriesPairing = (id) => {
+    const el = document.getElementById(id);
+    return Boolean(el?.hasAttribute("data-link") || el?.hasAttribute("data-sync-origin"));
+  };
+  if (!rightHalfIds.some(carriesPairing)) {
+    return source;
+  }
+  relinkSplitHalves(document, rightHalfIds);
+  return wrappedFragment ? document.body.innerHTML || "" : document.toString();
+}
+
+export {
+  parseSourceDocument,
+  findTargetElement,
+  removeElementsFromHtml,
+  removeElementFromHtml,
+  isHTMLElement,
+  dedupeClonedCompositionId,
+  patchElementInHtml,
+  nextUniqueId,
+  probeElementsInSource,
+  probeElementInSource,
+  splitElementInHtml,
+  wrapElementsInHtml,
+  unwrapElementsFromHtml,
+  relinkSplitHalvesInHtml
+};