@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/studio/chunk-7UQWVN52.js

@@ -0,0 +1,938 @@
+import {
+  buildElementLabel,
+  buildProjectApiPath,
+  buildStableSelector,
+  escapeCssString,
+  findClosestByAttribute,
+  getCompositionSourceMapRevision,
+  getCuratedComputedStyles,
+  getDataAttributes,
+  getInlineStyles,
+  getSelectorIndex,
+  getSourceFileForElement,
+  isAudibleVideoNode,
+  isEditableTextLeaf,
+  isElementVisibleThroughAncestors,
+  isHtmlElement,
+  normalizeTimelineCompositionSource,
+  parsePx,
+  querySelectorAllSafely,
+  withSelectorIndexPass
+} from "./chunk-TDWGXBUT.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/components/editor/manualEditingAvailability.ts
+var manualEditingAvailability_exports = {};
+__export(manualEditingAvailability_exports, {
+  STUDIO_API_SAME_ORIGIN_CREDENTIALS: () => STUDIO_API_SAME_ORIGIN_CREDENTIALS,
+  STUDIO_FLAT_INSPECTOR_ENABLED: () => STUDIO_FLAT_INSPECTOR_ENABLED,
+  STUDIO_SDK_CUTOVER_ENABLED: () => STUDIO_SDK_CUTOVER_ENABLED,
+  STUDIO_SDK_CUTOVER_FAMILIES: () => STUDIO_SDK_CUTOVER_FAMILIES,
+  STUDIO_SDK_RESOLVER_SHADOW_ENABLED: () => STUDIO_SDK_RESOLVER_SHADOW_ENABLED,
+  resolveStudioBooleanEnvFlag: () => resolveStudioBooleanEnvFlag
+});
+
+// src/utils/sdkCutoverPolicy.ts
+var STUDIO_SDK_OPERATION_FAMILIES = [
+  "dom",
+  "timing",
+  "gsap-animation",
+  "gsap-keyframe",
+  "lifecycle"
+];
+function resolveEnabledSdkFamilies(env2, masterEnabled) {
+  if (!masterEnabled) return /* @__PURE__ */ new Set();
+  const raw = env2["VITE_STUDIO_SDK_CUTOVER_FAMILIES"];
+  if (typeof raw !== "string" || raw.trim() === "") return new Set(STUDIO_SDK_OPERATION_FAMILIES);
+  const requested = raw.split(",").map((family) => family.trim()).filter(Boolean);
+  const known = new Set(STUDIO_SDK_OPERATION_FAMILIES);
+  const unknown = requested.filter((family) => !known.has(family));
+  if (unknown.length > 0) {
+    throw new Error(`Unknown Studio SDK cutover families: ${unknown.join(", ")}`);
+  }
+  return new Set(requested);
+}
+function isSdkFamilyEnabled(masterEnabled, configured, family) {
+  return masterEnabled && (configured?.has(family) ?? true);
+}
+
+// src/components/editor/manualEditingAvailability.ts
+var TRUTHY_ENV_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on", "enabled"]);
+var FALSY_ENV_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off", "disabled"]);
+function resolveStudioBooleanEnvFlag(env2, names, fallback) {
+  for (const name of names) {
+    const value = env2[name];
+    if (typeof value === "boolean") return value;
+    if (typeof value !== "string") continue;
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) continue;
+    if (TRUTHY_ENV_VALUES.has(normalized)) return true;
+    if (FALSY_ENV_VALUES.has(normalized)) return false;
+  }
+  return fallback;
+}
+var runtimeEnv = typeof window !== "undefined" ? window.__HF_STUDIO_ENV__ ?? {} : {};
+var env = { ...import.meta.env ?? {}, ...runtimeEnv };
+var STUDIO_SDK_CUTOVER_ENABLED = resolveStudioBooleanEnvFlag(
+  env,
+  ["VITE_STUDIO_SDK_CUTOVER_ENABLED"],
+  true
+);
+var STUDIO_SDK_CUTOVER_FAMILIES = resolveEnabledSdkFamilies(
+  env,
+  STUDIO_SDK_CUTOVER_ENABLED
+);
+var STUDIO_SDK_RESOLVER_SHADOW_ENABLED = resolveStudioBooleanEnvFlag(
+  env,
+  ["VITE_STUDIO_SDK_RESOLVER_SHADOW_ENABLED"],
+  true
+);
+var STUDIO_FLAT_INSPECTOR_ENABLED = resolveStudioBooleanEnvFlag(
+  env,
+  ["VITE_STUDIO_ENABLE_FLAT_INSPECTOR", "VITE_STUDIO_FLAT_INSPECTOR_ENABLED"],
+  true
+);
+var STUDIO_API_SAME_ORIGIN_CREDENTIALS = resolveStudioBooleanEnvFlag(
+  env,
+  ["VITE_STUDIO_API_SAME_ORIGIN_CREDENTIALS"],
+  false
+);
+
+// src/utils/studioApiFetch.ts
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function studioApiCredentials() {
+  if (STUDIO_API_SAME_ORIGIN_CREDENTIALS) return "same-origin";
+  const host = globalThis.location?.hostname;
+  return !host || LOOPBACK_HOSTS.has(host) ? "omit" : "same-origin";
+}
+function studioApiFetch(input, init) {
+  return globalThis.fetch(input, { ...init, credentials: studioApiCredentials() });
+}
+
+// src/components/editor/probeSourceElement.ts
+function knownSourceAnswer(previous, element, sourceFile, target) {
+  if (!previous || previous.element !== element || previous.sourceFile !== sourceFile) return;
+  const same = previous.id === target.id && previous.hfId === target.hfId && previous.selector === target.selector && previous.selectorIndex === target.selectorIndex;
+  return same ? previous.existsInSource : void 0;
+}
+var pending = /* @__PURE__ */ new Map();
+async function sendBatch(projectId, sourceFile, probes) {
+  let exists = [];
+  try {
+    const response = await studioApiFetch(
+      buildProjectApiPath(
+        projectId,
+        `/file-mutations/probe-elements/${encodeURIComponent(sourceFile)}`
+      ),
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ targets: probes.map((probe) => probe.target) })
+      }
+    );
+    if (response.ok) {
+      const data = await response.json();
+      if (Array.isArray(data?.exists)) exists = data.exists;
+    }
+  } catch {
+  }
+  probes.forEach((probe, index) => probe.resolve(exists[index] !== false));
+}
+function probeSourceElement(projectId, sourceFile, target) {
+  return new Promise((resolve) => {
+    const key = `${projectId}\0${sourceFile}`;
+    let probes = pending.get(key);
+    if (!probes) {
+      const batch = [];
+      probes = batch;
+      pending.set(key, batch);
+      setTimeout(() => {
+        pending.delete(key);
+        void sendBatch(projectId, sourceFile, batch);
+      }, 0);
+    }
+    probes.push({ target, resolve });
+  });
+}
+
+// src/components/editor/domEditingLayers.ts
+import {
+  resolveEditingAffordances,
+  resolveEditingSections
+} from "@hyperframes/core/editing";
+
+// src/components/editor/domEditingGroups.ts
+function groupScopedLayerRoots(root, activeGroupElement) {
+  const els = activeGroupElement?.isConnected ? Array.from(activeGroupElement.children) : [root];
+  return els.filter(isHtmlElement);
+}
+function resolveGroupCapture(startEl, activeGroupElement) {
+  const groups = [];
+  for (let n = startEl; n; n = n.parentElement) {
+    if (n.hasAttribute("data-hf-group")) groups.push(n);
+  }
+  const result = (() => {
+    if (!activeGroupElement) {
+      const outermost = groups[groups.length - 1];
+      return outermost ? { kind: "unit", element: outermost } : { kind: "child" };
+    }
+    const idx = groups.indexOf(activeGroupElement);
+    if (idx === -1) return { kind: "out-of-scope" };
+    const nestedInside = groups[idx - 1];
+    return nestedInside ? { kind: "unit", element: nestedInside } : { kind: "child" };
+  })();
+  return result;
+}
+
+// src/components/editor/domEditingElement.ts
+function isElementComputedVisible(el, memo) {
+  return isElementVisibleThroughAncestors(el, memo);
+}
+var VISUAL_LEAF_TAGS = /* @__PURE__ */ new Set(["img", "video", "canvas", "svg", "audio"]);
+function hasVisualPresence(el) {
+  const win = el.ownerDocument.defaultView;
+  if (!win) return false;
+  const cs = win.getComputedStyle(el);
+  if (cs.backgroundImage !== "none") return true;
+  if (cs.backgroundColor && cs.backgroundColor !== "transparent" && cs.backgroundColor !== "rgba(0, 0, 0, 0)")
+    return true;
+  if (cs.borderWidth && parseFloat(cs.borderWidth) > 0 && cs.borderStyle !== "none") return true;
+  if (cs.boxShadow && cs.boxShadow !== "none") return true;
+  return false;
+}
+function isEmptyVisualContainer(el) {
+  const tag = el.tagName.toLowerCase();
+  if (VISUAL_LEAF_TAGS.has(tag)) return false;
+  if (hasVisualPresence(el)) return false;
+  const { children } = el;
+  if (children.length === 0) {
+    return (el.textContent ?? "").trim().length === 0;
+  }
+  for (let i = 0; i < children.length; i += 1) {
+    const child = children[i];
+    if (!isHtmlElement(child)) continue;
+    if (VISUAL_LEAF_TAGS.has(child.tagName.toLowerCase())) return false;
+    if (isElementComputedVisible(child)) return false;
+  }
+  return true;
+}
+function hasRenderedBox(el) {
+  const rect = el.getBoundingClientRect();
+  if (rect.width <= 1 || rect.height <= 1) return false;
+  if (!isElementComputedVisible(el)) return false;
+  if (isEmptyVisualContainer(el)) return false;
+  return true;
+}
+var DOM_LAYER_IGNORED_TAGS = /* @__PURE__ */ new Set([
+  "base",
+  "br",
+  "canvas",
+  "link",
+  "meta",
+  "script",
+  "source",
+  "style",
+  "template",
+  "track",
+  "wbr"
+]);
+function isInspectableLayerElement(el) {
+  const tagName = el.tagName.toLowerCase();
+  if (DOM_LAYER_IGNORED_TAGS.has(tagName)) return false;
+  const computed = el.ownerDocument.defaultView?.getComputedStyle(el);
+  if (computed?.display === "none" || computed?.visibility === "hidden") return false;
+  return true;
+}
+function resolveLayerSelector(el) {
+  if (el.hasAttribute("data-composition-id")) return void 0;
+  return buildStableSelector(el);
+}
+function resolveDomLayerIdentity(el, activeCompositionPath) {
+  const selector = resolveLayerSelector(el);
+  if (!selector) return null;
+  const { sourceFile } = getSourceFileForElement(el, activeCompositionPath);
+  return {
+    id: el.id || void 0,
+    hfId: el.getAttribute("data-hf-id") || void 0,
+    selector,
+    selectorIndex: getSelectorIndex(
+      el.ownerDocument,
+      el,
+      selector,
+      sourceFile,
+      activeCompositionPath
+    ),
+    sourceFile
+  };
+}
+function getDomLayerPatchTarget(el, activeCompositionPath) {
+  return isInspectableLayerElement(el) ? resolveDomLayerIdentity(el, activeCompositionPath) : null;
+}
+function isDomLayerElement(el) {
+  return isInspectableLayerElement(el) && resolveLayerSelector(el) !== void 0;
+}
+function getPreferredClipAncestor(startEl) {
+  let current = startEl;
+  while (current) {
+    if (current.classList.contains("clip")) {
+      const isCompositionHost = current.hasAttribute("data-composition-src") || current.hasAttribute("data-composition-file");
+      if (!isCompositionHost || current === startEl) return current;
+    }
+    current = current.parentElement;
+  }
+  return null;
+}
+function getSelectionCandidate(startEl, options) {
+  if (options.preferClipAncestor) {
+    const clipAncestor = getPreferredClipAncestor(startEl);
+    if (clipAncestor) {
+      return clipAncestor;
+    }
+  }
+  return startEl;
+}
+function resolveAllVisualDomEditTargets(elementsFromPoint, options) {
+  const raw = [];
+  for (const entry of elementsFromPoint) {
+    if (!isHtmlElement(entry)) continue;
+    if (hasRenderedBox(entry) && getDomLayerPatchTarget(entry, options.activeCompositionPath)) {
+      raw.push(entry);
+    }
+  }
+  if (raw.length === 0) return [];
+  const layers = [];
+  let best = raw[0];
+  for (let i = 1; i < raw.length; i++) {
+    const el = raw[i];
+    if (best.contains(el)) {
+      best = el;
+    } else {
+      layers.push(best);
+      best = el;
+    }
+  }
+  layers.push(best);
+  return layers;
+}
+function findElementForSelection(doc, selection, activeCompositionPath = null) {
+  const sourceMatches = (candidate) => isHtmlElement(candidate) && (!selection.sourceFile || getSourceFileForElement(candidate, activeCompositionPath).sourceFile === selection.sourceFile);
+  const findAll = (selector) => querySelectorAllSafely(doc, selector).filter(sourceMatches);
+  if (selection.hfId) {
+    const byHfId = findAll(`[data-hf-id="${escapeCssString(selection.hfId)}"]`)[0];
+    if (byHfId) return byHfId;
+  }
+  if (selection.id) {
+    const byId = findAll(`[id="${escapeCssString(selection.id)}"]`)[0];
+    if (byId) return byId;
+  }
+  if (!selection.selector) return null;
+  return findAll(selection.selector)[selection.selectorIndex ?? 0] ?? null;
+}
+function findPreviewNode(doc, el) {
+  if (!doc) return null;
+  if (el.element?.isConnected && el.element.ownerDocument === doc) return el.element;
+  return findElementForSelection(doc, el) ?? findElementForSelection(doc, { ...el, sourceFile: void 0 });
+}
+function findElementForTimelineElement(doc, element, options) {
+  const elementId = typeof element.id === "string" ? element.id : "";
+  const compositionSource = normalizeTimelineCompositionSource(element.compositionSrc) ?? options.compIdToSrc?.get(elementId);
+  const sourceFile = compositionSource ?? normalizeTimelineCompositionSource(element.sourceFile) ?? options.activeCompositionPath ?? "index.html";
+  const escapedElementId = escapeCssString(elementId);
+  const escapedCompositionSource = compositionSource ? escapeCssString(compositionSource) : null;
+  const selector = element.selector ?? (compositionSource ? `[data-composition-src="${escapedCompositionSource}"],[data-composition-file="${escapedCompositionSource}"],[data-composition-id="${escapedElementId}"]` : escapedElementId ? `[data-composition-id="${escapedElementId}"]` : void 0);
+  if (selector || element.domId) {
+    const targetElement = findElementForSelection(
+      doc,
+      {
+        id: element.domId ?? void 0,
+        selector,
+        selectorIndex: element.selectorIndex,
+        sourceFile
+      },
+      options.activeCompositionPath
+    );
+    if (targetElement) return targetElement;
+  }
+  const hasExplicitDomTarget = Boolean(element.domId || element.selector || compositionSource);
+  if (options.isMasterView || hasExplicitDomTarget || !options.activeCompositionPath) {
+    return null;
+  }
+  const root = doc.querySelector("[data-composition-id]");
+  if (!isHtmlElement(root)) return null;
+  return getSourceFileForElement(root, options.activeCompositionPath).sourceFile === sourceFile ? root : null;
+}
+function getDirectLayerChildren(el) {
+  return Array.from(el.children).filter(
+    (child) => isHtmlElement(child) && isDomLayerElement(child)
+  );
+}
+
+// src/components/editor/domEditingRootLayer.ts
+var COMPOSITION_ROOT_LAYER_EPSILON_PX = 1;
+function readPositiveDimension(value) {
+  if (!value) return null;
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+function approximatelyEqual(a, b) {
+  return Math.abs(a - b) <= COMPOSITION_ROOT_LAYER_EPSILON_PX;
+}
+function getCompositionRootBounds(doc) {
+  const root = doc.querySelector("[data-composition-id]") ?? doc.documentElement ?? null;
+  const rootWidth = readPositiveDimension(root?.getAttribute("data-width") ?? null);
+  const rootHeight = readPositiveDimension(root?.getAttribute("data-height") ?? null);
+  if (!root || !rootWidth || !rootHeight) return null;
+  return { rect: root.getBoundingClientRect(), width: rootWidth, height: rootHeight };
+}
+function getRenderedLayerSize(element, computedStyles) {
+  const rect = element.getBoundingClientRect();
+  const width = rect.width || parsePx(computedStyles.width);
+  const height = rect.height || parsePx(computedStyles.height);
+  return width && height ? { width, height } : null;
+}
+function matchesCompositionRootBounds(elementRect, elementSize, rootBounds) {
+  return approximatelyEqual(elementRect.left, rootBounds.rect.left) && approximatelyEqual(elementRect.top, rootBounds.rect.top) && approximatelyEqual(elementSize.width, rootBounds.width) && approximatelyEqual(elementSize.height, rootBounds.height);
+}
+function isExplicitFullBleedLayer(computedStyles) {
+  return computedStyles.position === "absolute" || computedStyles.position === "fixed";
+}
+function isCompositionRootLayer(element, doc, computedStyles) {
+  if (element.parentElement !== doc.body) return false;
+  if (element.hasAttribute("data-hf-allow-root-edit")) return false;
+  if (isExplicitFullBleedLayer(computedStyles)) return false;
+  const rootBounds = getCompositionRootBounds(doc);
+  const elementSize = getRenderedLayerSize(element, computedStyles);
+  return Boolean(
+    rootBounds && elementSize && matchesCompositionRootBounds(element.getBoundingClientRect(), elementSize, rootBounds)
+  );
+}
+
+// src/components/editor/domEditLayerWalkCache.ts
+var SELECTOR_IDENTITY_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "id",
+  "class",
+  "data-hf-group",
+  "data-composition-id",
+  "data-composition-file",
+  "data-composition-src",
+  "data-hf-original-composition-id"
+]);
+var DOM_EDIT_LAYER_OBSERVER_INIT = {
+  attributes: true,
+  characterData: true,
+  childList: true,
+  subtree: true
+};
+var lastInlineVisibility = /* @__PURE__ */ new WeakMap();
+function inlineVisibilityChanged(el) {
+  const next = el.style.visibility;
+  if (lastInlineVisibility.get(el) === next) return false;
+  lastInlineVisibility.set(el, next);
+  return true;
+}
+function createDomEditLayerWalkCache() {
+  let presence = /* @__PURE__ */ new WeakMap();
+  let identities = /* @__PURE__ */ new WeakMap();
+  let scope = null;
+  const invalidateAll = () => {
+    presence = /* @__PURE__ */ new WeakMap();
+    identities = /* @__PURE__ */ new WeakMap();
+  };
+  const drop = (el) => {
+    if (el) presence.delete(el);
+  };
+  const dropSubtree = (el) => {
+    for (const descendant of el.querySelectorAll("*")) {
+      if (isHtmlElement(descendant)) presence.delete(descendant);
+    }
+  };
+  const ingestOne = (record) => {
+    if (record.type === "childList") return false;
+    if (record.type === "characterData") {
+      for (let ancestor = record.target.parentElement; ancestor; ancestor = ancestor.parentElement) {
+        identities.delete(ancestor);
+      }
+      return true;
+    }
+    const target = record.target;
+    if (!isHtmlElement(target)) return true;
+    if (record.attributeName && SELECTOR_IDENTITY_ATTRIBUTES.has(record.attributeName))
+      return false;
+    drop(target);
+    drop(target.parentElement);
+    if (record.attributeName === "style" && inlineVisibilityChanged(target)) dropSubtree(target);
+    return true;
+  };
+  return {
+    beginWalk(activeCompositionPath) {
+      const nextScope = `${activeCompositionPath ?? ""}|${getCompositionSourceMapRevision()}`;
+      if (nextScope === scope) return;
+      scope = nextScope;
+      invalidateAll();
+    },
+    readInspectable(el, compute) {
+      const memo = presence.get(el) ?? {};
+      if (memo.inspectable === void 0) {
+        memo.inspectable = compute();
+        presence.set(el, memo);
+      }
+      return memo.inspectable;
+    },
+    readChildCount(el, compute) {
+      const memo = presence.get(el) ?? {};
+      if (memo.childCount === void 0) {
+        memo.childCount = compute();
+        presence.set(el, memo);
+      }
+      return memo.childCount;
+    },
+    readIdentity(el, compute) {
+      const memo = identities.get(el) ?? {};
+      if (memo.identity === void 0) {
+        memo.identity = compute();
+        identities.set(el, memo);
+      }
+      return memo.identity;
+    },
+    readLabel(el, compute) {
+      const memo = identities.get(el) ?? {};
+      if (memo.label === void 0) {
+        memo.label = compute();
+        identities.set(el, memo);
+      }
+      return memo.label;
+    },
+    ingest(records) {
+      for (const record of records) {
+        if (!ingestOne(record)) {
+          invalidateAll();
+          return;
+        }
+      }
+    },
+    invalidateAll
+  };
+}
+function readDomEditLayerWalkEntry(el, activeCompositionPath, cache) {
+  const inspectable = cache ? cache.readInspectable(el, () => isInspectableLayerElement(el)) : isInspectableLayerElement(el);
+  if (!inspectable) return null;
+  const identity = () => resolveDomLayerIdentity(el, activeCompositionPath);
+  const target = cache ? cache.readIdentity(el, identity) : identity();
+  if (!target) return null;
+  const label = () => buildElementLabel(el);
+  const childCount = () => getDirectLayerChildren(el).length;
+  return {
+    target,
+    label: cache ? cache.readLabel(el, label) : label(),
+    childCount: cache ? cache.readChildCount(el, childCount) : childCount()
+  };
+}
+function drainPendingLayerMutations(observer, cache) {
+  if (!observer) return;
+  cache.ingest(observer.takeRecords());
+}
+
+// src/components/editor/domEditingLayers.ts
+function sameTagChildIndex(el) {
+  let index = 0;
+  let sibling = el.previousElementSibling;
+  while (sibling) {
+    if (sibling.tagName === el.tagName) index += 1;
+    sibling = sibling.previousElementSibling;
+  }
+  return index;
+}
+function getTextFieldLabel(_tagName, index, total, source) {
+  if (source === "self" || total === 1) return "Content";
+  return `Text ${index + 1}`;
+}
+function buildTextField(el, index, total, source, sourceChildIndex) {
+  const tagName = el.tagName.toLowerCase();
+  const key = el.getAttribute("data-hf-text-key") ?? `${source}:${index}:${tagName}`;
+  return {
+    key,
+    label: getTextFieldLabel(tagName, index, total, source),
+    value: el.textContent ?? "",
+    tagName,
+    attributes: Array.from(el.attributes).filter((attribute) => attribute.name !== "style").map((attribute) => ({
+      name: attribute.name,
+      value: attribute.value
+    })),
+    inlineStyles: getInlineStyles(el),
+    computedStyles: getCuratedComputedStyles(el),
+    source,
+    ...sourceChildIndex == null ? {} : { sourceChildIndex }
+  };
+}
+function collectDomEditTextFields(el) {
+  const childElements = Array.from(el.children).filter(isHtmlElement).filter(isEditableTextLeaf);
+  if (childElements.length > 0) {
+    const hasMixedContent = Array.from(el.childNodes).some(
+      (node) => node.nodeType === 3 && node.textContent?.trim()
+    );
+    if (hasMixedContent) {
+      const fields = [];
+      let childIdx = 0;
+      for (const node of el.childNodes) {
+        if (node.nodeType === 3) {
+          const text = node.textContent ?? "";
+          if (!text.trim()) continue;
+          fields.push({
+            key: `text-node:${childIdx}`,
+            label: `Text ${childIdx + 1}`,
+            value: text,
+            tagName: "#text",
+            attributes: [],
+            inlineStyles: {},
+            computedStyles: {},
+            source: "text-node"
+          });
+          childIdx++;
+        } else if (isHtmlElement(node) && isEditableTextLeaf(node)) {
+          fields.push(
+            buildTextField(node, childIdx, childElements.length, "child", sameTagChildIndex(node))
+          );
+          childIdx++;
+        }
+      }
+      return fields;
+    }
+    return childElements.map(
+      (child, index) => buildTextField(child, index, childElements.length, "child", sameTagChildIndex(child))
+    );
+  }
+  if (isEditableTextLeaf(el)) {
+    return [buildTextField(el, 0, 1, "self")];
+  }
+  return [];
+}
+function escapeHtmlText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function serializeTextFieldStyle(field) {
+  const entries = Object.entries(field.inlineStyles).filter(([, value]) => Boolean(value));
+  if (entries.length === 0) return "";
+  return entries.map(([key, value]) => `${key}: ${value}`).join("; ");
+}
+function serializeDomEditTextFields(fields) {
+  return fields.filter((field) => field.source === "child" || field.source === "text-node").map((field) => {
+    if (field.source === "text-node") {
+      return escapeHtmlText(field.value);
+    }
+    const attrs = [
+      ...field.attributes.filter((attribute) => attribute.name !== "data-hf-text-key"),
+      { name: "data-hf-text-key", value: field.key }
+    ].map((attribute) => ` ${attribute.name}="${attribute.value.replace(/"/g, "&quot;")}"`).join("");
+    const style = serializeTextFieldStyle(field);
+    const styleAttr = style ? ` style="${style.replace(/"/g, "&quot;")}"` : "";
+    return `<${field.tagName}${attrs}${styleAttr}>${escapeHtmlText(field.value)}</${field.tagName}>`;
+  }).join("");
+}
+function buildDefaultDomEditTextField(base) {
+  return {
+    key: `child:new:${Date.now()}`,
+    label: "Text",
+    value: "New text",
+    tagName: "span",
+    attributes: [],
+    inlineStyles: {
+      "font-family": base?.computedStyles?.["font-family"] ?? "inherit",
+      "font-size": base?.computedStyles?.["font-size"] ?? "16px",
+      "font-weight": base?.computedStyles?.["font-weight"] ?? "400",
+      color: base?.computedStyles?.color ?? "inherit"
+    },
+    computedStyles: {},
+    source: "child"
+  };
+}
+function buildTextFieldChildLocator(fields, fieldKey) {
+  const field = fields.find((candidate) => candidate.key === fieldKey);
+  if (!field || field.source !== "child") return null;
+  if (field.sourceChildIndex == null) return null;
+  return {
+    childSelector: `:scope > ${field.tagName}`,
+    childIndex: field.sourceChildIndex
+  };
+}
+function capabilityFacts(geometry) {
+  return {
+    ...geometry,
+    hasEditableText: false,
+    hasTimingStart: false,
+    animationCount: 0
+  };
+}
+function domEditSelectionToFacts(selection, animationCount = selection.gsapAnimations?.length ?? 0) {
+  return {
+    hasStableTarget: Boolean(selection.selector || selection.hfId),
+    tag: selection.tagName,
+    inlineStyles: selection.inlineStyles,
+    computedStyles: selection.computedStyles,
+    isCompositionHost: selection.isCompositionHost,
+    isCompositionRoot: false,
+    isInsideLockedComposition: selection.isInsideLockedComposition,
+    isMasterView: false,
+    existsInSource: true,
+    hasEditableText: selection.textFields.length > 0,
+    hasTimingStart: selection.dataAttributes.start != null,
+    animationCount,
+    hasAudio: isAudibleVideoNode(selection.element)
+  };
+}
+function resolveDomEditCapabilities(args) {
+  return resolveEditingAffordances(
+    capabilityFacts({
+      hasStableTarget: Boolean(args.selector || args.hfId),
+      tag: (args.tagName ?? "div").toLowerCase(),
+      inlineStyles: args.inlineStyles,
+      computedStyles: args.computedStyles,
+      isCompositionHost: args.isCompositionHost,
+      isCompositionRoot: args.isCompositionRoot ?? false,
+      isInsideLockedComposition: args.isInsideLockedComposition ?? false,
+      isMasterView: args.isMasterView,
+      existsInSource: args.existsInSource ?? true
+    })
+  ).capabilities;
+}
+async function resolveDomEditSelection(startEl, options) {
+  if (!startEl) return null;
+  const doc = startEl.ownerDocument;
+  let capture = options.exactTarget ? { kind: "unit", element: startEl } : resolveGroupCapture(startEl, options.activeGroupElement ?? null);
+  if (capture.kind === "out-of-scope") {
+    capture = resolveGroupCapture(startEl, null);
+  }
+  let current = capture.kind === "unit" ? capture.element : getSelectionCandidate(startEl, options);
+  while (current && current !== doc.body && current !== doc.documentElement) {
+    const selector = buildStableSelector(current);
+    const hfId = readHfId(current);
+    if (!selector && !hfId) {
+      current = current.parentElement;
+      continue;
+    }
+    const { sourceFile, compositionPath } = getSourceFileForElement(
+      current,
+      options.activeCompositionPath
+    );
+    const selectorIndex = selector ? getSelectorIndex(doc, current, selector, sourceFile, options.activeCompositionPath) : void 0;
+    const compositionSrc = current.getAttribute("data-composition-src") ?? current.getAttribute("data-composition-file") ?? void 0;
+    const inlineStyles = getInlineStyles(current);
+    const computedStyles = getCuratedComputedStyles(current);
+    const isCompositionRoot = current.hasAttribute("data-composition-id") && !compositionSrc || isCompositionRootLayer(current, doc, computedStyles);
+    const textFields = collectDomEditTextFields(current);
+    const isInsideLocked = Boolean(findClosestByAttribute(current, ["data-timeline-locked"]));
+    const probeTarget = {};
+    if (current.id) probeTarget.id = current.id;
+    if (hfId) probeTarget.hfId = hfId;
+    if (selector) probeTarget.selector = selector;
+    if (selectorIndex != null) probeTarget.selectorIndex = selectorIndex;
+    let existsInSource = knownSourceAnswer(options.previous, current, sourceFile, probeTarget);
+    const probe = existsInSource === void 0 && !options.skipSourceProbe;
+    if (probe && options.projectId && (current.id || selector || hfId)) {
+      existsInSource = await probeSourceElement(options.projectId, sourceFile, probeTarget);
+    }
+    const capabilities = resolveEditingAffordances(
+      capabilityFacts({
+        hasStableTarget: Boolean(selector || hfId),
+        tag: current.tagName.toLowerCase(),
+        inlineStyles,
+        computedStyles,
+        isCompositionHost: Boolean(compositionSrc),
+        isCompositionRoot,
+        isInsideLockedComposition: isInsideLocked,
+        isMasterView: options.isMasterView,
+        existsInSource: existsInSource ?? true
+      })
+    ).capabilities;
+    const rect = current.getBoundingClientRect();
+    return {
+      element: current,
+      id: current.id || void 0,
+      hfId,
+      selector,
+      selectorIndex,
+      sourceFile,
+      compositionPath,
+      compositionSrc,
+      isCompositionHost: Boolean(compositionSrc),
+      isInsideLockedComposition: isInsideLocked,
+      label: buildElementLabel(current),
+      tagName: current.tagName.toLowerCase(),
+      boundingBox: {
+        x: rect.left,
+        y: rect.top,
+        width: rect.width,
+        height: rect.height
+      },
+      textContent: current.textContent?.trim() || null,
+      dataAttributes: getDataAttributes(current),
+      inlineStyles,
+      computedStyles,
+      textFields,
+      capabilities,
+      existsInSource
+    };
+  }
+  return null;
+}
+async function refreshDomEditSelection(selection, activeCompositionPath) {
+  const doc = selection.element.ownerDocument;
+  const nextElement = findElementForSelection(doc, selection, activeCompositionPath);
+  return nextElement ? resolveDomEditSelection(nextElement, {
+    activeCompositionPath,
+    isMasterView: !activeCompositionPath || activeCompositionPath === "index.html"
+  }) : null;
+}
+function getDomEditLayerKey(target) {
+  const selectorIndex = target.selectorIndex ?? 0;
+  return `${target.sourceFile}:${target.id ?? target.selector ?? "layer"}:${selectorIndex}`;
+}
+function countDomEditChildLayers(root, options, maxCount = 99) {
+  if (!root) return 0;
+  let count = 0;
+  const visit = (el) => {
+    for (const child of Array.from(el.children)) {
+      if (!isHtmlElement(child)) continue;
+      if (isDomLayerElement(child)) {
+        count += 1;
+        if (count >= maxCount) return;
+      }
+      visit(child);
+      if (count >= maxCount) return;
+    }
+  };
+  visit(root);
+  return count;
+}
+function collectDomEditLayerItems(root, options, maxItems = Number.POSITIVE_INFINITY, cache) {
+  if (!root) return [];
+  cache?.beginWalk(options.activeCompositionPath);
+  const items = [];
+  const visit = (el, depth) => {
+    if (items.length >= maxItems) return;
+    const entry = readDomEditLayerWalkEntry(el, options.activeCompositionPath, cache);
+    if (entry) {
+      const { target } = entry;
+      items.push({
+        key: getDomEditLayerKey(target),
+        element: el,
+        label: entry.label,
+        tagName: el.tagName.toLowerCase(),
+        depth,
+        childCount: entry.childCount,
+        id: target.id ?? void 0,
+        hfId: target.hfId ?? void 0,
+        selector: target.selector ?? void 0,
+        selectorIndex: target.selectorIndex,
+        sourceFile: target.sourceFile
+      });
+    }
+    const nextDepth = entry ? depth + 1 : depth;
+    for (const child of Array.from(el.children)) {
+      if (!isHtmlElement(child)) continue;
+      visit(child, nextDepth);
+      if (items.length >= maxItems) return;
+    }
+  };
+  withSelectorIndexPass(root.ownerDocument, () => {
+    for (const el of groupScopedLayerRoots(root, options.activeGroupElement ?? null)) visit(el, 0);
+  });
+  return items;
+}
+function liveLayerElement(layer, doc, activeCompositionPath) {
+  if (layer.element.isConnected || !doc) return layer.element;
+  return findElementForSelection(doc, layer, activeCompositionPath) ?? layer.element;
+}
+function buildDomEditStylePatchOperation(property, value, childLocator) {
+  return {
+    type: "inline-style",
+    property,
+    value,
+    ...childLocator
+  };
+}
+function buildDomEditTextPatchOperation(value, childLocator) {
+  return { type: "text-content", property: "text", value, ...childLocator };
+}
+function buildDomEditRichTextPatchOperation(value) {
+  return { type: "rich-text", property: "", value };
+}
+function hasSupportedDirectEdit(capabilities) {
+  return capabilities.canEditStyles || capabilities.canMove || capabilities.canResize || capabilities.canApplyManualOffset || capabilities.canApplyManualSize || capabilities.canApplyManualRotation;
+}
+function getDomEditNonEditableReason(element, selection) {
+  if (!selection) {
+    return "No stable source target";
+  }
+  if (selection.element !== element) {
+    return selection.isCompositionHost ? "Nested composition boundary" : `Selection resolves to ${selection.label}`;
+  }
+  if (!hasSupportedDirectEdit(selection.capabilities)) {
+    return selection.capabilities.reasonIfDisabled ?? "No supported direct edits";
+  }
+  return null;
+}
+function getDomEditTargetKey(selection) {
+  return [
+    selection.sourceFile || "index.html",
+    selection.hfId ?? "",
+    selection.id ?? "",
+    selection.selector ?? "",
+    selection.selectorIndex ?? ""
+  ].join("|");
+}
+function isTextEditableSelection(selection) {
+  return resolveEditingSections(domEditSelectionToFacts(selection)).text;
+}
+function readHfId(element) {
+  return element.getAttribute("data-hf-id")?.trim() || void 0;
+}
+function buildDomEditPatchTarget(selection) {
+  return {
+    id: selection.id,
+    hfId: selection.hfId,
+    selector: selection.selector,
+    selectorIndex: selection.selectorIndex
+  };
+}
+
+export {
+  isSdkFamilyEnabled,
+  STUDIO_SDK_CUTOVER_ENABLED,
+  STUDIO_SDK_CUTOVER_FAMILIES,
+  STUDIO_SDK_RESOLVER_SHADOW_ENABLED,
+  STUDIO_FLAT_INSPECTOR_ENABLED,
+  manualEditingAvailability_exports,
+  studioApiFetch,
+  isElementComputedVisible,
+  getDomLayerPatchTarget,
+  resolveAllVisualDomEditTargets,
+  findElementForSelection,
+  findPreviewNode,
+  findElementForTimelineElement,
+  DOM_EDIT_LAYER_OBSERVER_INIT,
+  createDomEditLayerWalkCache,
+  drainPendingLayerMutations,
+  collectDomEditTextFields,
+  serializeDomEditTextFields,
+  buildDefaultDomEditTextField,
+  buildTextFieldChildLocator,
+  domEditSelectionToFacts,
+  resolveDomEditCapabilities,
+  resolveDomEditSelection,
+  refreshDomEditSelection,
+  getDomEditLayerKey,
+  countDomEditChildLayers,
+  collectDomEditLayerItems,
+  liveLayerElement,
+  buildDomEditStylePatchOperation,
+  buildDomEditTextPatchOperation,
+  buildDomEditRichTextPatchOperation,
+  getDomEditNonEditableReason,
+  getDomEditTargetKey,
+  isTextEditableSelection,
+  readHfId,
+  buildDomEditPatchTarget
+};
+//# sourceMappingURL=chunk-7UQWVN52.js.map