npm - starry-slides - Versions diffs - 0.1.0 - Mend

starry-slides 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (160) hide show

package/LICENSE +10 -0
package/README.md +131 -0
package/dist/assets/index---ub3Dty.css +1 -0
package/dist/assets/index-7Xs_Dyp0.js +354 -0
package/dist/assets/index-8ul7coaw.js +451 -0
package/dist/assets/index-B4_bJa9t.js +412 -0
package/dist/assets/index-B9p6L9Wx.js +324 -0
package/dist/assets/index-BF-Vi1Nh.js +413 -0
package/dist/assets/index-BKvVbgXz.css +1 -0
package/dist/assets/index-BNZJ_Wz-.js +417 -0
package/dist/assets/index-BO2gtiKn.js +413 -0
package/dist/assets/index-BYpD8kgo.js +456 -0
package/dist/assets/index-BaZRfz_9.css +1 -0
package/dist/assets/index-BlsWm4PI.js +412 -0
package/dist/assets/index-BnUIBFtw.js +393 -0
package/dist/assets/index-BvhCbfCi.js +412 -0
package/dist/assets/index-BxEkxfy1.js +412 -0
package/dist/assets/index-BzrA7O0L.js +422 -0
package/dist/assets/index-C0xGkdRg.js +413 -0
package/dist/assets/index-C1Rjncf1.js +456 -0
package/dist/assets/index-CCgb2gqc.js +413 -0
package/dist/assets/index-CDFJQRFx.js +413 -0
package/dist/assets/index-CEOai0RW.js +456 -0
package/dist/assets/index-CG2uWTey.css +1 -0
package/dist/assets/index-CLe3_iTu.js +412 -0
package/dist/assets/index-CS_optob.js +324 -0
package/dist/assets/index-CXgwXOZH.css +1 -0
package/dist/assets/index-CcBvAcE2.js +408 -0
package/dist/assets/index-CllmR_MT.js +408 -0
package/dist/assets/index-CnMy6wxq.js +412 -0
package/dist/assets/index-CoWNjYgb.js +422 -0
package/dist/assets/index-CtfA3BPy.css +1 -0
package/dist/assets/index-D-JiuJIv.js +324 -0
package/dist/assets/index-D2uEYXyQ.css +1 -0
package/dist/assets/index-D70beOHW.js +456 -0
package/dist/assets/index-D8xuxnF1.js +456 -0
package/dist/assets/index-DKAtkRd8.css +1 -0
package/dist/assets/index-DU3l9_k0.css +1 -0
package/dist/assets/index-DaLY98jk.js +456 -0
package/dist/assets/index-DkNHJHQl.js +412 -0
package/dist/assets/index-DmFnifK8.js +456 -0
package/dist/assets/index-DndZR7Ds.css +1 -0
package/dist/assets/index-DuRa7Y6g.js +324 -0
package/dist/assets/index-EnDjTeHF.js +451 -0
package/dist/assets/index-J3nQgjqJ.js +451 -0
package/dist/assets/index-wD_iWTBn.js +413 -0
package/dist/chunk-AK5J4CXH.js +1671 -0
package/dist/chunk-ARFDESSF.js +1583 -0
package/dist/chunk-DHWTBXGS.js +985 -0
package/dist/chunk-FCRRFL7N.js +1571 -0
package/dist/chunk-J7W4Y7WJ.js +1620 -0
package/dist/chunk-OCJULB7Z.js +1140 -0
package/dist/chunk-WCJWV5SO.js +36 -0
package/dist/cli/index.d.ts +2 -0
package/dist/cli/index.js +1119 -0
package/dist/cli/index.test.d.ts +1 -0
package/dist/core/deck-slide-operations.d.ts +5 -0
package/dist/core/generated-deck.d.ts +8 -0
package/dist/core/generated-deck.test.d.ts +1 -0
package/dist/core/group-operations.d.ts +24 -0
package/dist/core/history.d.ts +20 -0
package/dist/core/history.test.d.ts +1 -0
package/dist/core/html-export.d.ts +20 -0
package/dist/core/index.d.ts +11 -0
package/dist/core/layout.d.ts +36 -0
package/dist/core/layout.test.d.ts +1 -0
package/dist/core/pdf-export.d.ts +20 -0
package/dist/core/presentation.d.ts +7 -0
package/dist/core/slide-contract.d.ts +41 -0
package/dist/core/slide-document.d.ts +5 -0
package/dist/core/slide-document.test.d.ts +1 -0
package/dist/core/slide-html-document.d.ts +3 -0
package/dist/core/slide-operation-reducer.d.ts +4 -0
package/dist/core/slide-operation-reducer.test.d.ts +1 -0
package/dist/core/slide-operation-types.d.ts +123 -0
package/dist/core/slide-operations-helpers.d.ts +14 -0
package/dist/core/slide-operations.d.ts +5 -0
package/dist/core/slide-operations.test.d.ts +1 -0
package/dist/core/verify-deck.d.ts +48 -0
package/dist/core/verify-deck.test.d.ts +1 -0
package/dist/editor/app/App.d.ts +2 -0
package/dist/editor/app/main.d.ts +1 -0
package/dist/editor/app/use-slides-data.d.ts +14 -0
package/dist/editor/components/block-manipulation-overlay.d.ts +32 -0
package/dist/editor/components/color-picker.d.ts +10 -0
package/dist/editor/components/context-menu.d.ts +26 -0
package/dist/editor/components/editor-header.d.ts +18 -0
package/dist/editor/components/floating-toolbar-feature.d.ts +8 -0
package/dist/editor/components/floating-toolbar-parts.d.ts +46 -0
package/dist/editor/components/floating-toolbar.d.ts +27 -0
package/dist/editor/components/presenter-view.d.ts +13 -0
package/dist/editor/components/slide-sidebar.d.ts +18 -0
package/dist/editor/components/stage-canvas.d.ts +77 -0
package/dist/editor/components/ui/accordion.d.ts +7 -0
package/dist/editor/components/ui/button.d.ts +10 -0
package/dist/editor/components/ui/context-menu.d.ts +25 -0
package/dist/editor/components/ui/dialog.d.ts +10 -0
package/dist/editor/components/ui/input.d.ts +3 -0
package/dist/editor/components/ui/popover.d.ts +10 -0
package/dist/editor/components/ui/scroll-area.d.ts +5 -0
package/dist/editor/components/ui/select.d.ts +15 -0
package/dist/editor/components/ui/separator.d.ts +4 -0
package/dist/editor/components/ui/tabs.d.ts +11 -0
package/dist/editor/components/ui/textarea.d.ts +3 -0
package/dist/editor/components/ui/toggle-group.d.ts +9 -0
package/dist/editor/components/ui/toggle.d.ts +9 -0
package/dist/editor/components/ui/tooltip.d.ts +7 -0
package/dist/editor/editor-operations.d.ts +15 -0
package/dist/editor/hooks/block-manipulation-geometry.d.ts +16 -0
package/dist/editor/hooks/block-manipulation-operations.d.ts +10 -0
package/dist/editor/hooks/block-manipulation-overlay.d.ts +11 -0
package/dist/editor/hooks/block-manipulation-types.d.ts +73 -0
package/dist/editor/hooks/editor-keyboard-geometry.d.ts +22 -0
package/dist/editor/hooks/editor-keyboard-operations.d.ts +10 -0
package/dist/editor/hooks/editor-keyboard-types.d.ts +35 -0
package/dist/editor/hooks/iframe-editing-session.d.ts +10 -0
package/dist/editor/hooks/iframe-text-editing-dom.d.ts +6 -0
package/dist/editor/hooks/iframe-text-editing-types.d.ts +38 -0
package/dist/editor/hooks/object-clipboard-commands.d.ts +28 -0
package/dist/editor/hooks/use-block-manipulation.d.ts +3 -0
package/dist/editor/hooks/use-editor-keyboard-shortcuts.d.ts +3 -0
package/dist/editor/hooks/use-iframe-text-editing.d.ts +3 -0
package/dist/editor/hooks/use-slide-history.d.ts +17 -0
package/dist/editor/hooks/use-slide-inspector.d.ts +24 -0
package/dist/editor/hooks/use-slide-thumbnails.d.ts +2 -0
package/dist/editor/hooks/use-stage-viewport.d.ts +13 -0
package/dist/editor/index.d.ts +13 -0
package/dist/editor/index.js +8260 -0
package/dist/editor/lib/block-snap-constants.d.ts +8 -0
package/dist/editor/lib/block-snap-guides.d.ts +6 -0
package/dist/editor/lib/block-snap-targets.d.ts +13 -0
package/dist/editor/lib/block-snap-types.d.ts +30 -0
package/dist/editor/lib/block-snapping.d.ts +17 -0
package/dist/editor/lib/collect-css-properties.d.ts +5 -0
package/dist/editor/lib/element-tool-commit.d.ts +18 -0
package/dist/editor/lib/element-tool-model.d.ts +16 -0
package/dist/editor/lib/element-tool-types.d.ts +35 -0
package/dist/editor/lib/element-tool-values.d.ts +23 -0
package/dist/editor/lib/motion.d.ts +8 -0
package/dist/editor/lib/selection-overlay.d.ts +4 -0
package/dist/editor/lib/style-controls.d.ts +17 -0
package/dist/editor/lib/thumbnail-renderer.d.ts +2 -0
package/dist/editor/lib/utils.d.ts +3 -0
package/dist/index.html +13 -0
package/dist/node/deck-runtime-middleware.d.ts +8 -0
package/dist/node/deck-source.d.ts +1 -0
package/dist/node/html-export.d.ts +16 -0
package/dist/node/open-browser.d.ts +1 -0
package/dist/node/pdf-export.d.ts +20 -0
package/dist/node/ports.d.ts +1 -0
package/dist/node/view-renderer.d.ts +31 -0
package/dist/runtime/deck-source.d.ts +1 -0
package/dist/runtime/html-export.d.ts +16 -0
package/dist/runtime/open-browser.d.ts +1 -0
package/dist/runtime/pdf-export.d.ts +20 -0
package/dist/runtime/ports.d.ts +1 -0
package/dist/runtime/view-renderer.d.ts +31 -0
package/dist/runtime/view-renderer.test.d.ts +1 -0
package/dist/test/deck-fixtures.d.ts +14 -0
package/package.json +94 -0

package/dist/chunk-FCRRFL7N.js ADDED Viewed

@@ -0,0 +1,1571 @@
+// src/core/slide-contract.ts
+var SELECTOR_ATTR = "data-editor-id";
+var SLIDE_ROOT_ATTR = "data-slide-root";
+var DEFAULT_SLIDE_WIDTH = 1920;
+var DEFAULT_SLIDE_HEIGHT = 1080;
+function getSlideElementSelector(elementId) {
+  return `[${SELECTOR_ATTR}="${elementId}"]`;
+}
+function getSlideRootSelector(rootId) {
+  return `[${SELECTOR_ATTR}="${rootId}"]`;
+}
+function slugify(value) {
+  return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "slide";
+}
+function createElementId(index, type) {
+  return `${type}-${index + 1}`;
+}
+function parseDimension(value, fallback) {
+  const numericValue = Number.parseInt(value || "", 10);
+  return Number.isFinite(numericValue) && numericValue > 0 ? numericValue : fallback;
+}
+function normalizeSlideId(slideId) {
+  return slugify(slideId);
+}
+// src/core/slide-document.ts
+function parseHtmlDocument(html) {
+  if (typeof DOMParser === "undefined") {
+    return null;
+  }
+  const parser = new DOMParser();
+  return parser.parseFromString(html, "text/html");
+}
+function ensureSlideRoot(doc) {
+  const existingRoot = doc.querySelector(`[${SLIDE_ROOT_ATTR}]`);
+  if (existingRoot) {
+    if (!existingRoot.getAttribute("data-slide-width")) {
+      existingRoot.setAttribute("data-slide-width", String(DEFAULT_SLIDE_WIDTH));
+    }
+    if (!existingRoot.getAttribute("data-slide-height")) {
+      existingRoot.setAttribute("data-slide-height", String(DEFAULT_SLIDE_HEIGHT));
+    }
+    return existingRoot;
+  }
+  const container = doc.querySelector(".slide-container");
+  if (container) {
+    container.setAttribute(SLIDE_ROOT_ATTR, "true");
+    if (!container.getAttribute("data-slide-width")) {
+      container.setAttribute("data-slide-width", String(DEFAULT_SLIDE_WIDTH));
+    }
+    if (!container.getAttribute("data-slide-height")) {
+      container.setAttribute("data-slide-height", String(DEFAULT_SLIDE_HEIGHT));
+    }
+    return container;
+  }
+  return null;
+}
+function serializeHtmlDocument(doc) {
+  return `<!DOCTYPE html>
+${doc.documentElement.outerHTML}`;
+}
+function ensureEditableSelectors(html) {
+  const doc = parseHtmlDocument(html);
+  if (!doc) {
+    return html;
+  }
+  const root = ensureSlideRoot(doc);
+  const editableNodes = Array.from(doc.querySelectorAll("[data-editable]"));
+  if (root && !root.getAttribute(SELECTOR_ATTR)) {
+    root.setAttribute(SELECTOR_ATTR, "slide-root");
+  }
+  editableNodes.forEach((node, index) => {
+    if (!node.getAttribute(SELECTOR_ATTR)) {
+      const type = node.getAttribute("data-editable") || "block";
+      node.setAttribute(SELECTOR_ATTR, createElementId(index, type));
+    }
+  });
+  return serializeHtmlDocument(doc);
+}
+function parseSlide(html, slideId = "slide-1") {
+  const doc = parseHtmlDocument(html);
+  if (!doc) {
+    return {
+      id: slideId,
+      title: "Untitled Slide",
+      htmlSource: html,
+      rootSelector: `[${SLIDE_ROOT_ATTR}]`,
+      width: DEFAULT_SLIDE_WIDTH,
+      height: DEFAULT_SLIDE_HEIGHT,
+      elements: []
+    };
+  }
+  const normalizedHtml = ensureEditableSelectors(html);
+  const normalizedDoc = parseHtmlDocument(normalizedHtml);
+  if (!normalizedDoc) {
+    return {
+      id: slideId,
+      title: "Untitled Slide",
+      htmlSource: normalizedHtml,
+      rootSelector: `[${SLIDE_ROOT_ATTR}]`,
+      width: DEFAULT_SLIDE_WIDTH,
+      height: DEFAULT_SLIDE_HEIGHT,
+      elements: []
+    };
+  }
+  const root = ensureSlideRoot(normalizedDoc);
+  const editableNodes = Array.from(normalizedDoc.querySelectorAll("[data-editable]"));
+  const rootSelector = root?.getAttribute(SELECTOR_ATTR) ? `[${SELECTOR_ATTR}="${root.getAttribute(SELECTOR_ATTR)}"]` : `[${SLIDE_ROOT_ATTR}]`;
+  const width = parseDimension(root?.getAttribute("data-slide-width") ?? null, DEFAULT_SLIDE_WIDTH);
+  const height = parseDimension(
+    root?.getAttribute("data-slide-height") ?? null,
+    DEFAULT_SLIDE_HEIGHT
+  );
+  const elements = editableNodes.map((node, index) => {
+    const type = node.getAttribute("data-editable") || "block";
+    const selectorValue = node.getAttribute(SELECTOR_ATTR) || createElementId(index, type);
+    return {
+      id: selectorValue,
+      selector: getSlideElementSelector(selectorValue),
+      type: type === "block" && node.getAttribute("data-group") === "true" ? "group" : type,
+      content: node instanceof HTMLImageElement ? node.src : node.textContent || "",
+      tagName: node.tagName.toLowerCase()
+    };
+  });
+  const firstHeading = normalizedDoc.querySelector("h1, h2, title");
+  const title = firstHeading?.textContent?.trim() || `Slide ${slideId}`;
+  return {
+    id: normalizeSlideId(slideId),
+    title,
+    htmlSource: normalizedHtml,
+    rootSelector,
+    width,
+    height,
+    elements
+  };
+}
+function querySlideElement(doc, elementId) {
+  return doc.querySelector(getSlideElementSelector(elementId));
+}
+function getSlideInlineStyleValue(slide, elementId, propertyName) {
+  const doc = parseHtmlDocument(slide.htmlSource);
+  if (!doc) {
+    return "";
+  }
+  const node = querySlideElement(doc, elementId);
+  return node?.style.getPropertyValue(propertyName).trim() || "";
+}
+// src/core/slide-html-document.ts
+function parseHtmlDocument2(html) {
+  if (typeof DOMParser === "undefined") {
+    return null;
+  }
+  const parser = new DOMParser();
+  return parser.parseFromString(html, "text/html");
+}
+function serializeHtmlDocument2(doc) {
+  return `<!DOCTYPE html>
+${doc.documentElement.outerHTML}`;
+}
+function updateHtmlSource(html, updater) {
+  const doc = parseHtmlDocument2(html);
+  if (!doc) {
+    return html;
+  }
+  updater(doc);
+  return serializeHtmlDocument2(doc);
+}
+// src/core/layout.ts
+var ELEMENT_LAYOUT_STYLE_KEYS = [
+  "position",
+  "left",
+  "top",
+  "width",
+  "height",
+  "transform",
+  "transformOrigin",
+  "margin",
+  "zIndex"
+];
+function createEmptyElementLayoutStyleSnapshot() {
+  return {
+    position: null,
+    left: null,
+    top: null,
+    width: null,
+    height: null,
+    transform: null,
+    transformOrigin: null,
+    margin: null,
+    zIndex: null
+  };
+}
+function captureElementLayoutStyleSnapshot(node) {
+  const snapshot = createEmptyElementLayoutStyleSnapshot();
+  for (const key of ELEMENT_LAYOUT_STYLE_KEYS) {
+    const value = node.style[key];
+    snapshot[key] = value ? value : null;
+  }
+  return snapshot;
+}
+function normalizeElementLayoutStyleSnapshot(snapshot) {
+  return {
+    ...createEmptyElementLayoutStyleSnapshot(),
+    ...snapshot
+  };
+}
+function parseTransformParts(transformValue) {
+  const rawValue = transformValue || "";
+  const translateMatch = rawValue.match(/translate\(([-\d.]+)px,\s*([-\d.]+)px\)/i);
+  const rotateMatch = rawValue.match(/rotate\(([-\d.]+)deg\)/i);
+  return {
+    translateX: translateMatch ? Number.parseFloat(translateMatch[1] || "0") || 0 : 0,
+    translateY: translateMatch ? Number.parseFloat(translateMatch[2] || "0") || 0 : 0,
+    rotate: rotateMatch ? Number.parseFloat(rotateMatch[1] || "0") || 0 : 0
+  };
+}
+function roundNumber(value) {
+  return Math.round(value * 100) / 100;
+}
+function composeTransform(translateX, translateY, rotate) {
+  const parts = [];
+  if (Math.abs(translateX) > 0.01 || Math.abs(translateY) > 0.01) {
+    parts.push(`translate(${roundNumber(translateX)}px, ${roundNumber(translateY)}px)`);
+  }
+  if (Math.abs(rotate) > 0.01) {
+    parts.push(`rotate(${roundNumber(rotate)}deg)`);
+  }
+  return parts.length ? parts.join(" ") : null;
+}
+function elementRectToStageRect(elementRect, rootRect, geometry) {
+  return {
+    x: geometry.offsetX + (elementRect.left - rootRect.left) * geometry.scale,
+    y: geometry.offsetY + (elementRect.top - rootRect.top) * geometry.scale,
+    width: elementRect.width * geometry.scale,
+    height: elementRect.height * geometry.scale
+  };
+}
+function stageDeltaToSlideDelta(deltaX, deltaY, geometry) {
+  return {
+    x: deltaX / geometry.scale,
+    y: deltaY / geometry.scale
+  };
+}
+// src/core/slide-operations.ts
+function numericStyleValue(value) {
+  const parsed = Number.parseFloat(value || "");
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function getNodeRect(node) {
+  const transform = parseTransformParts(node.style.transform);
+  return {
+    x: numericStyleValue(node.style.left) + transform.translateX,
+    y: numericStyleValue(node.style.top) + transform.translateY,
+    width: numericStyleValue(node.style.width) || DEFAULT_SLIDE_WIDTH,
+    height: numericStyleValue(node.style.height) || DEFAULT_SLIDE_HEIGHT
+  };
+}
+function getAbsoluteNodeRect(node, elementRects = {}) {
+  let current = node;
+  let x = 0;
+  let y = 0;
+  const ownElementId = node.getAttribute(SELECTOR_ATTR) ?? "";
+  const ownRect = elementRects[ownElementId] ?? getNodeRect(node);
+  const width = ownRect.width;
+  const height = ownRect.height;
+  while (current) {
+    const elementId = current.getAttribute(SELECTOR_ATTR) ?? "";
+    const rect = elementRects[elementId] ?? getNodeRect(current);
+    x += rect.x;
+    y += rect.y;
+    const parent = current.parentElement;
+    if (!parent || !parent.hasAttribute("data-editable")) {
+      break;
+    }
+    current = parent;
+  }
+  return { x, y, width, height };
+}
+function getEditableAncestorRect(node, elementRects = {}) {
+  const parent = node.parentElement;
+  if (!parent || !parent.hasAttribute("data-editable")) {
+    return { x: 0, y: 0 };
+  }
+  const rect = getAbsoluteNodeRect(parent, elementRects);
+  return { x: rect.x, y: rect.y };
+}
+function setNodeRect(node, rect) {
+  node.style.position = node.style.position || "absolute";
+  node.style.left = `${Math.round(rect.x * 100) / 100}px`;
+  node.style.top = `${Math.round(rect.y * 100) / 100}px`;
+  node.style.width = `${Math.round(rect.width * 100) / 100}px`;
+  node.style.height = `${Math.round(rect.height * 100) / 100}px`;
+  const transform = parseTransformParts(node.style.transform);
+  const nextTransform = composeTransform(0, 0, transform.rotate);
+  if (nextTransform) {
+    node.style.transform = nextTransform;
+  } else {
+    node.style.removeProperty("transform");
+  }
+}
+function applyPresentationStyleSnapshot(node, snapshot) {
+  if (!snapshot) {
+    return;
+  }
+  if (snapshot.color) {
+    node.style.color = snapshot.color;
+  }
+  if (snapshot.fontSize) {
+    node.style.fontSize = snapshot.fontSize;
+  }
+  if (snapshot.fontWeight) {
+    node.style.fontWeight = snapshot.fontWeight;
+  }
+  if (snapshot.fontStyle) {
+    node.style.fontStyle = snapshot.fontStyle;
+  }
+  if (snapshot.lineHeight) {
+    node.style.lineHeight = snapshot.lineHeight;
+  }
+  if (snapshot.textAlign) {
+    node.style.textAlign = snapshot.textAlign;
+  }
+  if (snapshot.paddingTop) {
+    node.style.paddingTop = snapshot.paddingTop;
+  }
+  if (snapshot.paddingRight) {
+    node.style.paddingRight = snapshot.paddingRight;
+  }
+  if (snapshot.paddingBottom) {
+    node.style.paddingBottom = snapshot.paddingBottom;
+  }
+  if (snapshot.paddingLeft) {
+    node.style.paddingLeft = snapshot.paddingLeft;
+  }
+  if (snapshot.listStylePosition) {
+    node.style.listStylePosition = snapshot.listStylePosition;
+  }
+  if (snapshot.listStyleType) {
+    node.style.listStyleType = snapshot.listStyleType;
+  }
+}
+function getDirectEditableOwner(node) {
+  const parent = node.parentElement;
+  if (!parent) {
+    return null;
+  }
+  if (parent.hasAttribute(SLIDE_ROOT_ATTR) || parent.hasAttribute("data-editable")) {
+    return parent;
+  }
+  return null;
+}
+function childEditableElements(node) {
+  return Array.from(node.children).filter(
+    (child) => child instanceof HTMLElement && child.hasAttribute("data-editable")
+  );
+}
+function isListWrapperWithEditableItems(node) {
+  const tagName = node.tagName.toLowerCase();
+  if (tagName !== "ul" && tagName !== "ol") {
+    return false;
+  }
+  return Array.from(node.children).some(
+    (child) => child.tagName.toLowerCase() === "li" && child.hasAttribute("data-editable")
+  );
+}
+function createUniqueElementIdInDocument(doc, preferredId) {
+  const existingIds = new Set(
+    Array.from(doc.querySelectorAll(`[${SELECTOR_ATTR}]`)).map((node) => node.getAttribute(SELECTOR_ATTR)).filter((value) => Boolean(value))
+  );
+  if (!existingIds.has(preferredId)) {
+    return preferredId;
+  }
+  const match = preferredId.match(/^(.*?)(?:-(\d+))?$/);
+  const base = match?.[1] || preferredId;
+  let index = Number.parseInt(match?.[2] || "1", 10) + 1;
+  while (existingIds.has(`${base}-${index}`)) {
+    index += 1;
+  }
+  return `${base}-${index}`;
+}
+function flattenableBlockChildElements(node, doc) {
+  return Array.from(node.children).filter((child) => {
+    if (!(child instanceof HTMLElement)) {
+      return false;
+    }
+    if (child.hasAttribute("data-editable")) {
+      return true;
+    }
+    if (!isListWrapperWithEditableItems(child)) {
+      return false;
+    }
+    child.setAttribute("data-editable", "block");
+    if (!child.getAttribute(SELECTOR_ATTR)) {
+      child.setAttribute(SELECTOR_ATTR, createUniqueElementIdInDocument(doc, "block-1"));
+    }
+    return true;
+  });
+}
+function updateSlideText(html, elementId, value) {
+  return updateHtmlSource(html, (doc) => {
+    const node = querySlideElement(doc, elementId);
+    if (node) {
+      node.textContent = value;
+    }
+  });
+}
+function updateSlideStyle(html, elementId, propertyName, value) {
+  return updateHtmlSource(html, (doc) => {
+    const node = querySlideElement(doc, elementId);
+    if (!node) {
+      return;
+    }
+    if (value.trim().length === 0) {
+      node.style.removeProperty(propertyName);
+    } else {
+      node.style.setProperty(propertyName, value);
+    }
+    if (!node.getAttribute("style")?.trim()) {
+      node.removeAttribute("style");
+    }
+  });
+}
+function updateSlideAttribute(html, elementId, attributeName, value) {
+  return updateHtmlSource(html, (doc) => {
+    const node = querySlideElement(doc, elementId);
+    if (!node) {
+      return;
+    }
+    if (value.trim().length === 0) {
+      node.removeAttribute(attributeName);
+    } else {
+      node.setAttribute(attributeName, value);
+    }
+  });
+}
+function duplicateSlideElement(html, sourceElementId, nextElementId) {
+  return updateHtmlSource(html, (doc) => {
+    const sourceNode = querySlideElement(doc, sourceElementId);
+    if (!sourceNode) {
+      return;
+    }
+    const clonedNode = sourceNode.cloneNode(true);
+    if (!(clonedNode instanceof HTMLElement)) {
+      return;
+    }
+    clonedNode.setAttribute(SELECTOR_ATTR, nextElementId);
+    clonedNode.removeAttribute("data-hse-editing");
+    sourceNode.insertAdjacentElement("afterend", clonedNode);
+  });
+}
+function applyElementLayoutStyleSnapshot(node, snapshot) {
+  for (const key of ELEMENT_LAYOUT_STYLE_KEYS) {
+    const value = snapshot[key];
+    if (value === null) {
+      node.style[key] = "";
+      continue;
+    }
+    node.style[key] = value;
+  }
+  if (!node.getAttribute("style")?.trim()) {
+    node.removeAttribute("style");
+  }
+}
+function updateSlideElementLayout(html, elementId, snapshot) {
+  return updateHtmlSource(html, (doc) => {
+    const node = querySlideElement(doc, elementId);
+    if (!node) {
+      return;
+    }
+    applyElementLayoutStyleSnapshot(node, snapshot);
+  });
+}
+function createElementPlacement(html, elementId) {
+  const doc = parseHtmlDocument2(html);
+  if (!doc) {
+    return null;
+  }
+  const node = querySlideElement(doc, elementId);
+  if (!node || !(node.parentElement instanceof HTMLElement)) {
+    return null;
+  }
+  const previousSiblingElementId = node.previousElementSibling instanceof HTMLElement ? node.previousElementSibling.getAttribute(SELECTOR_ATTR) : null;
+  const nextSiblingElementId = node.nextElementSibling instanceof HTMLElement ? node.nextElementSibling.getAttribute(SELECTOR_ATTR) : null;
+  return {
+    parentElementId: node.parentElement.getAttribute(SELECTOR_ATTR),
+    previousSiblingElementId,
+    nextSiblingElementId
+  };
+}
+function getSlideElementHtml(html, elementId) {
+  const doc = parseHtmlDocument2(html);
+  if (!doc) {
+    return null;
+  }
+  return querySlideElement(doc, elementId)?.outerHTML ?? null;
+}
+function updateSlideElementHtmlIds(elementHtml, idMap) {
+  const doc = parseHtmlDocument2(`<template>${elementHtml}</template>`);
+  const root = doc?.querySelector("template")?.content.firstElementChild;
+  if (!(root instanceof HTMLElement)) {
+    return elementHtml;
+  }
+  const nodes = [root, ...Array.from(root.querySelectorAll(`[${SELECTOR_ATTR}]`))];
+  for (const node of nodes) {
+    const currentId = node.getAttribute(SELECTOR_ATTR);
+    if (currentId && idMap[currentId]) {
+      node.setAttribute(SELECTOR_ATTR, idMap[currentId]);
+    }
+  }
+  return root.outerHTML;
+}
+function createUniqueElementId(html, preferredId) {
+  const doc = parseHtmlDocument2(html);
+  if (!doc) {
+    return preferredId;
+  }
+  return createUniqueElementIdInDocument(doc, preferredId);
+}
+function insertSlideElement(html, operation) {
+  return updateHtmlSource(html, (doc) => {
+    if (querySlideElement(doc, operation.elementId)) {
+      return;
+    }
+    const fragmentDoc = parseHtmlDocument2(`<template>${operation.html}</template>`);
+    const node = fragmentDoc?.querySelector("template")?.content.firstElementChild;
+    if (!(node instanceof HTMLElement)) {
+      return;
+    }
+    const parent = (operation.parentElementId ? querySlideElement(doc, operation.parentElementId) : null) ?? doc.querySelector(`[${SLIDE_ROOT_ATTR}]`) ?? doc.body;
+    const nextSibling = operation.nextSiblingElementId ? querySlideElement(doc, operation.nextSiblingElementId) : null;
+    const previousSibling = operation.previousSiblingElementId ? querySlideElement(doc, operation.previousSiblingElementId) : null;
+    if (nextSibling?.parentElement === parent) {
+      parent.insertBefore(doc.importNode(node, true), nextSibling);
+    } else if (previousSibling?.parentElement === parent) {
+      previousSibling.after(doc.importNode(node, true));
+    } else {
+      parent.appendChild(doc.importNode(node, true));
+    }
+  });
+}
+function removeSlideElement(html, elementId) {
+  return updateHtmlSource(html, (doc) => {
+    querySlideElement(doc, elementId)?.remove();
+  });
+}
+function updateSlideElementTransform(html, elementId, deltaX, deltaY) {
+  return updateHtmlSource(html, (doc) => {
+    const node = querySlideElement(doc, elementId);
+    if (!node) {
+      return;
+    }
+    const currentTransform = parseTransformParts(node.style.transform);
+    const nextTransform = composeTransform(
+      currentTransform.translateX + deltaX,
+      currentTransform.translateY + deltaY,
+      currentTransform.rotate
+    );
+    if (nextTransform) {
+      node.style.transform = nextTransform;
+    } else {
+      node.style.removeProperty("transform");
+    }
+    if (!node.style.position) {
+      node.style.position = "relative";
+    }
+  });
+}
+function createGroupCreateOperation({
+  html,
+  slideId,
+  groupElementId,
+  elementIds,
+  elementRects = {},
+  timestamp = Date.now()
+}) {
+  const doc = parseHtmlDocument2(html);
+  if (!doc || !elementIds.length) {
+    return null;
+  }
+  const selectedNodes = elementIds.map((elementId) => querySlideElement(doc, elementId)).filter((node) => Boolean(node));
+  if (selectedNodes.length !== elementIds.length) {
+    return null;
+  }
+  const flattenedNodes = selectedNodes.flatMap(
+    (node) => node.getAttribute("data-group") === "true" ? childEditableElements(node) : [node]
+  );
+  const uniqueNodes = flattenedNodes.filter(
+    (node, index, nodes) => nodes.findIndex((candidate) => candidate === node) === index
+  );
+  if (uniqueNodes.length < 2) {
+    return null;
+  }
+  const parent = getDirectEditableOwner(selectedNodes[0]);
+  if (!parent || selectedNodes.some((node) => getDirectEditableOwner(node) !== parent)) {
+    return null;
+  }
+  if (querySlideElement(doc, groupElementId)) {
+    return null;
+  }
+  const selectedGroups = selectedNodes.filter((node) => node.getAttribute("data-group") === "true");
+  const rects = uniqueNodes.map((node) => getAbsoluteNodeRect(node, elementRects));
+  const left = Math.min(...rects.map((rect) => rect.x));
+  const top = Math.min(...rects.map((rect) => rect.y));
+  const right = Math.max(...rects.map((rect) => rect.x + rect.width));
+  const bottom = Math.max(...rects.map((rect) => rect.y + rect.height));
+  const parentRect = getEditableAncestorRect(selectedNodes[0], elementRects);
+  const groupNode = doc.createElement("div");
+  groupNode.setAttribute("data-editable", "block");
+  groupNode.setAttribute("data-group", "true");
+  groupNode.setAttribute(SELECTOR_ATTR, groupElementId);
+  setNodeRect(groupNode, {
+    x: left - parentRect.x,
+    y: top - parentRect.y,
+    width: right - left,
+    height: bottom - top
+  });
+  const orderedNodes = Array.from(parent.children).flatMap((child) => {
+    if (!(child instanceof HTMLElement)) {
+      return [];
+    }
+    if (selectedGroups.includes(child)) {
+      return childEditableElements(child).filter((node) => uniqueNodes.includes(node));
+    }
+    return uniqueNodes.includes(child) ? [child] : [];
+  });
+  const insertionAnchor = selectedNodes.find((node) => getDirectEditableOwner(node) === parent) ?? null;
+  if (insertionAnchor?.parentElement === parent) {
+    parent.insertBefore(groupNode, insertionAnchor);
+  } else {
+    parent.appendChild(groupNode);
+  }
+  for (const node of orderedNodes) {
+    const rect = getAbsoluteNodeRect(node, elementRects);
+    setNodeRect(node, {
+      x: rect.x - left,
+      y: rect.y - top,
+      width: rect.width,
+      height: rect.height
+    });
+    groupNode.appendChild(node);
+  }
+  for (const group of selectedGroups) {
+    if (!group.children.length) {
+      group.remove();
+    }
+  }
+  const nextHtmlSource = serializeHtmlDocument2(doc);
+  if (nextHtmlSource === html) {
+    return null;
+  }
+  return {
+    type: "group.create",
+    slideId,
+    groupElementId,
+    elementIds: orderedNodes.map((node) => node.getAttribute(SELECTOR_ATTR)).filter((elementId) => Boolean(elementId)),
+    previousHtmlSource: html,
+    nextHtmlSource,
+    timestamp
+  };
+}
+function createGroupUngroupOperation({
+  html,
+  slideId,
+  groupElementId,
+  elementRects = {},
+  elementPresentationStyles = {},
+  timestamp = Date.now()
+}) {
+  const doc = parseHtmlDocument2(html);
+  if (!doc) {
+    return null;
+  }
+  const groupNode = querySlideElement(doc, groupElementId);
+  if (!groupNode || !groupNode.parentElement) {
+    return null;
+  }
+  const parent = groupNode.parentElement;
+  const parentRect = getEditableAncestorRect(groupNode, elementRects);
+  const isGroup = groupNode.getAttribute("data-group") === "true";
+  const children = isGroup ? childEditableElements(groupNode) : flattenableBlockChildElements(groupNode, doc);
+  if (!children.length) {
+    return null;
+  }
+  const selectedElementId = groupNode.getAttribute(SELECTOR_ATTR);
+  const insertionAnchor = isGroup ? groupNode : groupNode.nextSibling;
+  const childElementIds = children.map((child) => child.getAttribute(SELECTOR_ATTR)).filter((elementId) => Boolean(elementId));
+  for (const child of children) {
+    const rect = getAbsoluteNodeRect(child, elementRects);
+    setNodeRect(child, {
+      x: rect.x - parentRect.x,
+      y: rect.y - parentRect.y,
+      width: rect.width,
+      height: rect.height
+    });
+    if (!isGroup) {
+      const childElementId = child.getAttribute(SELECTOR_ATTR) ?? "";
+      applyPresentationStyleSnapshot(child, elementPresentationStyles[childElementId]);
+      if (isListWrapperWithEditableItems(child)) {
+        child.style.margin = "0px";
+      }
+      for (const descendant of Array.from(
+        child.querySelectorAll(`[data-editable][${SELECTOR_ATTR}]`)
+      )) {
+        const descendantElementId = descendant.getAttribute(SELECTOR_ATTR) ?? "";
+        applyPresentationStyleSnapshot(descendant, elementPresentationStyles[descendantElementId]);
+      }
+    }
+    parent.insertBefore(child, insertionAnchor);
+  }
+  if (isGroup) {
+    groupNode.remove();
+  }
+  const nextHtmlSource = serializeHtmlDocument2(doc);
+  if (nextHtmlSource === html) {
+    return null;
+  }
+  return {
+    type: "group.ungroup",
+    slideId,
+    groupElementId,
+    childElementIds: isGroup || !selectedElementId ? childElementIds : [selectedElementId, ...childElementIds],
+    previousHtmlSource: html,
+    nextHtmlSource,
+    timestamp
+  };
+}
+// src/core/slide-operation-reducer.ts
+function preserveSlideSource(sourceSlide, nextSlide) {
+  return {
+    ...nextSlide,
+    hidden: sourceSlide.hidden,
+    sourceFile: sourceSlide.sourceFile
+  };
+}
+function applySlideOperation(slide, operation) {
+  if (operation.type === "slide.visibility.update") {
+    if (slide.id !== operation.slideId) {
+      return slide;
+    }
+    return { ...slide, hidden: operation.nextHidden };
+  }
+  if (!("slideId" in operation) || operation.type === "slide.reorder") {
+    return slide;
+  }
+  if (slide.id !== operation.slideId) {
+    return slide;
+  }
+  switch (operation.type) {
+    case "operation.batch":
+      return operation.operations.reduce(
+        (currentSlide, childOperation) => applySlideOperation(currentSlide, childOperation),
+        slide
+      );
+    case "text.update":
+      return preserveSlideSource(
+        slide,
+        parseSlide(
+          updateSlideText(slide.htmlSource, operation.elementId, operation.nextText),
+          slide.id
+        )
+      );
+    case "style.update":
+      return preserveSlideSource(
+        slide,
+        parseSlide(
+          updateSlideStyle(
+            slide.htmlSource,
+            operation.elementId,
+            operation.propertyName,
+            operation.nextValue
+          ),
+          slide.id
+        )
+      );
+    case "attribute.update":
+      return preserveSlideSource(
+        slide,
+        parseSlide(
+          updateSlideAttribute(
+            slide.htmlSource,
+            operation.elementId,
+            operation.attributeName,
+            operation.nextValue
+          ),
+          slide.id
+        )
+      );
+    case "element.layout.update":
+      return preserveSlideSource(
+        slide,
+        parseSlide(
+          updateSlideElementLayout(slide.htmlSource, operation.elementId, operation.nextStyle),
+          slide.id
+        )
+      );
+    case "element.insert":
+      return preserveSlideSource(
+        slide,
+        parseSlide(insertSlideElement(slide.htmlSource, operation), slide.id)
+      );
+    case "element.remove":
+      return preserveSlideSource(
+        slide,
+        parseSlide(removeSlideElement(slide.htmlSource, operation.elementId), slide.id)
+      );
+    case "group.create":
+    case "group.ungroup":
+      return preserveSlideSource(slide, parseSlide(operation.nextHtmlSource, slide.id));
+  }
+}
+function invertSlideOperation(operation) {
+  switch (operation.type) {
+    case "operation.batch":
+      return {
+        type: "operation.batch",
+        slideId: operation.slideId,
+        operations: operation.operations.map((childOperation) => invertSlideOperation(childOperation)).reverse(),
+        timestamp: operation.timestamp
+      };
+    case "text.update":
+      return {
+        ...operation,
+        previousText: operation.nextText,
+        nextText: operation.previousText
+      };
+    case "style.update":
+      return {
+        ...operation,
+        previousValue: operation.nextValue,
+        nextValue: operation.previousValue
+      };
+    case "attribute.update":
+      return {
+        ...operation,
+        previousValue: operation.nextValue,
+        nextValue: operation.previousValue
+      };
+    case "element.layout.update":
+      return {
+        ...operation,
+        previousStyle: operation.nextStyle,
+        nextStyle: operation.previousStyle
+      };
+    case "element.insert":
+      return {
+        type: "element.remove",
+        slideId: operation.slideId,
+        elementId: operation.elementId,
+        parentElementId: operation.parentElementId,
+        previousSiblingElementId: operation.previousSiblingElementId,
+        nextSiblingElementId: operation.nextSiblingElementId,
+        html: operation.html,
+        timestamp: operation.timestamp
+      };
+    case "element.remove":
+      return {
+        type: "element.insert",
+        slideId: operation.slideId,
+        elementId: operation.elementId,
+        parentElementId: operation.parentElementId,
+        previousSiblingElementId: operation.previousSiblingElementId,
+        nextSiblingElementId: operation.nextSiblingElementId,
+        html: operation.html,
+        timestamp: operation.timestamp
+      };
+    case "group.create":
+      return {
+        type: "group.ungroup",
+        slideId: operation.slideId,
+        groupElementId: operation.groupElementId,
+        childElementIds: operation.elementIds,
+        previousHtmlSource: operation.nextHtmlSource,
+        nextHtmlSource: operation.previousHtmlSource,
+        timestamp: operation.timestamp
+      };
+    case "group.ungroup":
+      return {
+        type: "group.create",
+        slideId: operation.slideId,
+        groupElementId: operation.groupElementId,
+        elementIds: operation.childElementIds,
+        previousHtmlSource: operation.nextHtmlSource,
+        nextHtmlSource: operation.previousHtmlSource,
+        timestamp: operation.timestamp
+      };
+    case "slide.create":
+      return {
+        type: "slide.delete",
+        slide: operation.slide,
+        index: operation.index,
+        timestamp: operation.timestamp
+      };
+    case "slide.delete":
+      return {
+        type: "slide.create",
+        slide: operation.slide,
+        index: operation.index,
+        timestamp: operation.timestamp
+      };
+    case "slide.duplicate":
+      return {
+        type: "slide.delete",
+        slide: operation.slide,
+        index: operation.index,
+        timestamp: operation.timestamp
+      };
+    case "slide.reorder":
+      return {
+        ...operation,
+        fromIndex: operation.toIndex,
+        toIndex: operation.fromIndex
+      };
+    case "slide.visibility.update":
+      return {
+        ...operation,
+        previousHidden: operation.nextHidden,
+        nextHidden: operation.previousHidden
+      };
+  }
+}
+// src/core/deck-slide-operations.ts
+var DEFAULT_NEW_SLIDE_HTML = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Untitled Slide</title>
+  </head>
+  <body>
+    <main
+      data-slide-root="true"
+      data-slide-width="1920"
+      data-slide-height="1080"
+      data-editor-id="slide-root"
+      style="position: relative; width: 1920px; height: 1080px; overflow: hidden; background: #ffffff;"
+    >
+      <h1 data-editable="text" data-editor-id="text-1" style="position: absolute; left: 160px; top: 160px; width: 1200px; margin: 0; font-size: 96px; line-height: 1.05;">
+        Untitled Slide
+      </h1>
+    </main>
+  </body>
+</html>`;
+function createUniqueSlideId(slides, preferredId) {
+  const existingIds = new Set(slides.map((slide) => slide.id));
+  if (!existingIds.has(preferredId)) {
+    return preferredId;
+  }
+  let index = 2;
+  while (existingIds.has(`${preferredId}-${index}`)) {
+    index += 1;
+  }
+  return `${preferredId}-${index}`;
+}
+function createUniqueSlideSourceFile(slides, preferredFile) {
+  const existingFiles = new Set(slides.map((slide) => slide.sourceFile).filter(Boolean));
+  if (!existingFiles.has(preferredFile)) {
+    return preferredFile;
+  }
+  const extensionIndex = preferredFile.lastIndexOf(".");
+  const base = extensionIndex >= 0 ? preferredFile.slice(0, extensionIndex) : preferredFile;
+  const extension = extensionIndex >= 0 ? preferredFile.slice(extensionIndex) : "";
+  let index = 2;
+  while (existingFiles.has(`${base}-${index}${extension}`)) {
+    index += 1;
+  }
+  return `${base}-${index}${extension}`;
+}
+function createBlankSlide(slides, insertIndex) {
+  const position = Math.max(insertIndex + 1, 1);
+  const slideId = createUniqueSlideId(slides, `generated-slide-${position}`);
+  const sourceFile = createUniqueSlideSourceFile(
+    slides,
+    `${String(position).padStart(2, "0")}-untitled.html`
+  );
+  return {
+    ...parseSlide(DEFAULT_NEW_SLIDE_HTML, slideId),
+    hidden: false,
+    sourceFile,
+    title: "Untitled Slide"
+  };
+}
+function createDuplicatedSlide(slides, sourceSlide) {
+  const slideId = createUniqueSlideId(slides, `${sourceSlide.id}-copy`);
+  const sourceFile = createUniqueSlideSourceFile(
+    slides,
+    sourceSlide.sourceFile ? appendFileSuffix(sourceSlide.sourceFile, "copy") : `${slideId}.html`
+  );
+  return {
+    ...parseSlide(sourceSlide.htmlSource, slideId),
+    hidden: sourceSlide.hidden === true,
+    sourceFile,
+    title: sourceSlide.title
+  };
+}
+function appendFileSuffix(file, suffix) {
+  const extensionIndex = file.lastIndexOf(".");
+  if (extensionIndex < 0) {
+    return `${file}-${suffix}`;
+  }
+  return `${file.slice(0, extensionIndex)}-${suffix}${file.slice(extensionIndex)}`;
+}
+// src/core/history.ts
+function clampInsertIndex(index, length) {
+  return Math.min(Math.max(index, 0), length);
+}
+function applyOperationToSlides(slides, operation) {
+  switch (operation.type) {
+    case "slide.create":
+    case "slide.duplicate": {
+      const index = clampInsertIndex(operation.index, slides.length);
+      return [...slides.slice(0, index), operation.slide, ...slides.slice(index)];
+    }
+    case "slide.delete":
+      return slides.filter((slide) => slide.id !== operation.slide.id);
+    case "slide.reorder": {
+      const fromIndex = slides.findIndex((slide2) => slide2.id === operation.slideId);
+      if (fromIndex < 0) {
+        return slides;
+      }
+      const nextSlides = [...slides];
+      const [slide] = nextSlides.splice(fromIndex, 1);
+      if (!slide) {
+        return slides;
+      }
+      nextSlides.splice(clampInsertIndex(operation.toIndex, nextSlides.length), 0, slide);
+      return nextSlides;
+    }
+    default:
+      return slides.map((slide) => applySlideOperation(slide, operation));
+  }
+}
+function createHistoryState(slides) {
+  return {
+    slides,
+    undoStack: [],
+    redoStack: []
+  };
+}
+function reduceHistory(state, action) {
+  switch (action.type) {
+    case "history.reset":
+      return createHistoryState(action.slides);
+    case "history.commit":
+      return {
+        slides: applyOperationToSlides(state.slides, action.operation),
+        undoStack: [...state.undoStack, action.operation],
+        redoStack: []
+      };
+    case "history.undo": {
+      const operation = state.undoStack[state.undoStack.length - 1];
+      if (!operation) {
+        return state;
+      }
+      return {
+        slides: applyOperationToSlides(state.slides, invertSlideOperation(operation)),
+        undoStack: state.undoStack.slice(0, -1),
+        redoStack: [...state.redoStack, operation]
+      };
+    }
+    case "history.redo": {
+      const operation = state.redoStack[state.redoStack.length - 1];
+      if (!operation) {
+        return state;
+      }
+      return {
+        slides: applyOperationToSlides(state.slides, operation),
+        undoStack: [...state.undoStack, operation],
+        redoStack: state.redoStack.slice(0, -1)
+      };
+    }
+  }
+}
+// src/core/generated-deck.ts
+async function loadSlidesFromManifest({
+  manifestUrl,
+  fetchImpl,
+  requestInit,
+  slideIdPrefix = "generated-slide-"
+}) {
+  const activeFetch = fetchImpl ?? globalThis.fetch;
+  if (!activeFetch) {
+    throw new Error("loadSlidesFromManifest requires a fetch implementation.");
+  }
+  const effectiveRequestInit = {
+    cache: "no-store",
+    ...requestInit
+  };
+  const manifestResponse = await activeFetch(manifestUrl, effectiveRequestInit);
+  if (!manifestResponse.ok) {
+    return null;
+  }
+  const manifest = await manifestResponse.json();
+  if (!manifest.slides?.length) {
+    return null;
+  }
+  const manifestBaseUrl = manifestResponse.url || manifestUrl;
+  const manifestUrlObject = new URL(manifestBaseUrl);
+  const slides = await Promise.all(
+    manifest.slides.map(async (slide, index) => {
+      const slideUrl = new URL(slide.file, manifestBaseUrl);
+      for (const [key, value] of manifestUrlObject.searchParams) {
+        if (!slideUrl.searchParams.has(key)) {
+          slideUrl.searchParams.set(key, value);
+        }
+      }
+      const slideResponse = await activeFetch(slideUrl.toString(), effectiveRequestInit);
+      if (!slideResponse.ok) {
+        throw new Error(`Failed to load slide HTML: ${slide.file}`);
+      }
+      const html = await slideResponse.text();
+      const parsedSlide = parseSlide(html, `${slideIdPrefix}${index + 1}`);
+      return {
+        ...parsedSlide,
+        hidden: slide.hidden === true,
+        sourceFile: slide.file,
+        title: slide.title || parsedSlide.title
+      };
+    })
+  );
+  return {
+    manifest,
+    slides
+  };
+}
+// src/core/pdf-export.ts
+function planPdfExport({
+  slides,
+  selection
+}) {
+  const resolvedSelection = selection ?? { mode: "all" };
+  const mode = resolvedSelection.mode ?? "all";
+  if (mode === "all") {
+    return { mode: "all", slides: [...slides] };
+  }
+  if (mode === "slide") {
+    const slideFile = "slideFile" in resolvedSelection ? resolvedSelection.slideFile?.trim() : "";
+    if (!slideFile) {
+      throw new Error("--slide requires a manifest slide file value");
+    }
+    const slide = findSlide(slides, slideFile);
+    if (!slide) {
+      throw new Error(`--slide must match a manifest slide file exactly: ${slideFile}`);
+    }
+    return { mode: "single", slides: [slide] };
+  }
+  const slideFiles = "slideFiles" in resolvedSelection ? resolvedSelection.slideFiles ?? [] : [];
+  const requestedFiles = slideFiles.map((file) => file.trim()).filter(Boolean);
+  if (requestedFiles.length === 0) {
+    throw new Error("--slides requires at least one manifest slide file value");
+  }
+  const selectedSlides = [];
+  const missingFiles = [];
+  for (const slideFile of requestedFiles) {
+    const slide = findSlide(slides, slideFile);
+    if (!slide) {
+      missingFiles.push(slideFile);
+      continue;
+    }
+    selectedSlides.push(slide);
+  }
+  if (missingFiles.length > 0) {
+    throw new Error(`--slides must match manifest slide files exactly: ${missingFiles.join(", ")}`);
+  }
+  return { mode: "slides", slides: selectedSlides };
+}
+function planPdfExportSlides(slides, selection) {
+  return planPdfExport({ slides, selection }).slides;
+}
+function findSlide(slides, slideFile) {
+  return slides.find((slide) => slide.file === slideFile);
+}
+// src/core/html-export.ts
+function planHtmlExportSlides(slides) {
+  const visibleSlides = slides.filter((slide) => slide.hidden !== true);
+  return visibleSlides.length > 0 ? visibleSlides : [...slides];
+}
+function resolveHtmlExportSlides(slides) {
+  return planHtmlExportSlides(slides).map((slide) => {
+    const size = getSlideSize(slide);
+    return {
+      file: slide.file,
+      ...slide.title ? { title: slide.title } : {},
+      htmlSource: slide.htmlSource,
+      width: size.width,
+      height: size.height
+    };
+  });
+}
+function createSingleHtmlExportDocument({
+  title = "Starry Slides",
+  slides
+}) {
+  const resolvedSlides = resolveHtmlExportSlides(slides);
+  const deckPayload = {
+    title,
+    slides: resolvedSlides.map((slide) => ({
+      file: slide.file,
+      title: slide.title ?? slide.file,
+      htmlSource: slide.htmlSource,
+      width: slide.width,
+      height: slide.height
+    }))
+  };
+  return `<!DOCTYPE html>
+<html lang="en" data-starry-presenter="true">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(title)}</title>
+    <style>${STANDALONE_PRESENTER_CSS}</style>
+  </head>
+  <body>
+    <main id="starry-presenter" data-starry-presenter="true">
+      <section class="presenter-stage" data-testid="presenter-view">
+        <div class="presenter-slide-frame" data-testid="presenter-slide-frame">
+          <iframe title="Presented slide" data-testid="presenter-slide-iframe"></iframe>
+          <svg class="presenter-ink-layer" data-testid="presenter-ink-layer"></svg>
+        </div>
+        <div class="presenter-laser-cursor" data-testid="presenter-laser-cursor"></div>
+        <div class="presenter-colors" data-testid="presenter-pen-colors" aria-label="Pen colors"></div>
+        <nav class="presenter-toolbar" data-testid="presenter-toolbar" data-visible="false" aria-label="Presentation controls">
+          <button type="button" data-action="previous" aria-label="Previous slide">Prev</button>
+          <span class="presenter-pagination" data-role="pagination">1 / ${Math.max(resolvedSlides.length, 1)}</span>
+          <button type="button" data-action="next" aria-label="Next slide">Next</button>
+          <span class="presenter-divider"></span>
+          <button type="button" data-tool="laser" aria-label="Laser pointer" aria-pressed="false">Laser</button>
+          <button type="button" data-tool="pen" aria-label="Pen" aria-pressed="false">Pen</button>
+          <button type="button" data-action="fullscreen" aria-label="Enter fullscreen">Fullscreen</button>
+          <span class="presenter-divider"></span>
+          <button type="button" data-action="exit" aria-label="Exit presentation">Exit</button>
+        </nav>
+      </section>
+    </main>
+    <script>
+      window.starryPresenterDeck = ${safeJson(deckPayload)};
+      ${STANDALONE_PRESENTER_SCRIPT}
+    </script>
+  </body>
+</html>`;
+}
+function getSlideSize(slide) {
+  if (slide.width && slide.height) {
+    return { width: slide.width, height: slide.height };
+  }
+  return {
+    width: parseDimension(
+      matchAttribute(slide.htmlSource, "data-slide-width"),
+      DEFAULT_SLIDE_WIDTH
+    ),
+    height: parseDimension(
+      matchAttribute(slide.htmlSource, "data-slide-height"),
+      DEFAULT_SLIDE_HEIGHT
+    )
+  };
+}
+function matchAttribute(html, attributeName) {
+  const pattern = new RegExp(`${attributeName}\\s*=\\s*["']([^"']+)["']`, "i");
+  return pattern.exec(html)?.[1] ?? null;
+}
+function safeJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003C").replace(/>/g, "\\u003E");
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var STANDALONE_PRESENTER_CSS = `
+html,body{margin:0;width:100%;height:100%;overflow:hidden;background:#111;color:#f8fafc;font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}
+*{box-sizing:border-box}
+#starry-presenter{display:block;width:100vw;height:100vh}
+.presenter-stage{position:fixed;inset:0;display:grid;place-items:center;overflow:hidden;background:#111;cursor:default}
+.presenter-stage[data-tool="laser"]{cursor:none}
+.presenter-slide-frame{position:relative;overflow:hidden;background:#fff;box-shadow:0 18px 70px rgba(0,0,0,.42)}
+.presenter-slide-frame iframe{display:block;border:0;background:#fff;pointer-events:none;transform-origin:top left}
+.presenter-ink-layer{position:absolute;inset:0;width:100%;height:100%;pointer-events:none;overflow:visible}
+.presenter-ink-layer path{fill:none;stroke-linecap:round;stroke-linejoin:round;stroke-width:4}
+.presenter-laser-cursor{position:fixed;left:0;top:0;width:16px;height:16px;border-radius:999px;background:rgba(247,255,42,.92);box-shadow:0 0 0 1px rgba(17,24,39,.85),0 0 14px rgba(247,255,42,.9),0 0 24px rgba(34,211,238,.65);transform:translate(-50%,-50%);pointer-events:none;opacity:0}
+.presenter-stage[data-tool="laser"] .presenter-laser-cursor{opacity:1}
+.presenter-toolbar{position:fixed;left:50%;bottom:22px;z-index:20;display:flex;align-items:center;gap:7px;min-height:44px;padding:6px;border:1px solid rgba(255,255,255,.16);border-radius:10px;background:rgba(17,17,17,.84);box-shadow:0 18px 52px rgba(0,0,0,.38);backdrop-filter:blur(18px);transition:opacity .18s ease,transform .18s ease;transform:translate(-50%,0)}
+.presenter-toolbar[data-visible="false"]{opacity:0;transform:translate(-50%,16px);pointer-events:none}
+.presenter-toolbar button{height:32px;border:0;border-radius:6px;background:transparent;color:#f8fafc;padding:0 10px;font:600 12px/1 Inter,ui-sans-serif,system-ui;cursor:pointer}
+.presenter-toolbar button:hover,.presenter-toolbar button[aria-pressed="true"]{background:rgba(255,255,255,.14)}
+.presenter-toolbar button:disabled{opacity:.35;cursor:not-allowed}
+.presenter-pagination{min-width:56px;text-align:center;color:rgba(248,250,252,.78);font:600 12px/1 ui-monospace,SFMono-Regular,Menlo,monospace}
+.presenter-divider{width:1px;height:20px;background:rgba(255,255,255,.16)}
+.presenter-colors{position:fixed;left:50%;bottom:78px;z-index:20;display:none;align-items:center;gap:8px;padding:8px;border:1px solid rgba(255,255,255,.16);border-radius:8px;background:rgba(17,17,17,.9);box-shadow:0 14px 44px rgba(0,0,0,.32);backdrop-filter:blur(18px);transform:translateX(-50%)}
+.presenter-stage[data-tool="pen"] .presenter-colors{display:flex}
+.presenter-swatch{width:28px;height:28px;border:1px solid rgba(255,255,255,.25);border-radius:999px;box-shadow:0 0 0 1px rgba(0,0,0,.25);padding:0;cursor:pointer}
+.presenter-swatch[data-active="true"]{outline:2px solid rgba(255,255,255,.9);outline-offset:2px}
+`;
+var STANDALONE_PRESENTER_SCRIPT = `
+(() => {
+  const deck = window.starryPresenterDeck;
+  const stage = document.querySelector(".presenter-stage");
+  const frame = document.querySelector(".presenter-slide-frame");
+  const iframe = document.querySelector("[data-testid='presenter-slide-iframe']");
+  const inkLayer = document.querySelector("[data-testid='presenter-ink-layer']");
+  const toolbar = document.querySelector("[data-testid='presenter-toolbar']");
+  const pagination = document.querySelector("[data-role='pagination']");
+  const laser = document.querySelector("[data-testid='presenter-laser-cursor']");
+  const colorList = document.querySelector(".presenter-colors");
+  const penColors = ["#F59E0B", "#EF4444", "#10B981", "#3B82F6", "#8B5CF6", "#FFFFFF", "#0F172A"];
+  let index = 0;
+  let tool = "none";
+  let hideTimer = 0;
+  let drawing = null;
+  let penColor = penColors[0];
+  let lastWheelAt = 0;
+  function activeSlide() {
+    return deck.slides[Math.min(Math.max(index, 0), Math.max(deck.slides.length - 1, 0))];
+  }
+  function renderSlide() {
+    const slide = activeSlide();
+    if (!slide) return;
+    const viewportWidth = window.innerWidth;
+    const viewportHeight = window.innerHeight;
+    const scale = Math.min(viewportWidth / slide.width, viewportHeight / slide.height);
+    frame.style.width = Math.floor(slide.width * scale) + "px";
+    frame.style.height = Math.floor(slide.height * scale) + "px";
+    iframe.style.width = slide.width + "px";
+    iframe.style.height = slide.height + "px";
+    iframe.style.transform = "scale(" + scale + ")";
+    iframe.srcdoc = slide.htmlSource;
+    inkLayer.setAttribute("viewBox", "0 0 " + slide.width + " " + slide.height);
+    inkLayer.dataset.scale = String(scale);
+    inkLayer.replaceChildren();
+    pagination.textContent = String(index + 1) + " / " + String(deck.slides.length);
+    toolbar.querySelector("[data-action='previous']").disabled = index === 0;
+    toolbar.querySelector("[data-action='next']").disabled = index >= deck.slides.length - 1;
+  }
+  function setTool(nextTool) {
+    tool = tool === nextTool ? "none" : nextTool;
+    stage.dataset.tool = tool === "none" ? "" : tool;
+    for (const button of toolbar.querySelectorAll("[data-tool]")) {
+      button.setAttribute("aria-pressed", button.dataset.tool === tool ? "true" : "false");
+    }
+    drawing = null;
+    updateCursor();
+  }
+  function clearInk() {
+    inkLayer.replaceChildren();
+    drawing = null;
+  }
+  function renderPenColors() {
+    colorList.replaceChildren(...penColors.map((color) => {
+      const button = document.createElement("button");
+      button.type = "button";
+      button.className = "presenter-swatch";
+      button.setAttribute("aria-label", "Use pen color " + color);
+      button.dataset.active = color === penColor ? "true" : "false";
+      button.style.background = color;
+      button.addEventListener("click", () => {
+        penColor = color;
+        updateCursor();
+        renderPenColors();
+      });
+      return button;
+    }));
+  }
+  function createPenCursor(color) {
+    const svg = "<svg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'><circle cx='12' cy='12' r='6' fill='" + color + "' stroke='#111827' stroke-width='2'/></svg>";
+    return "url(\\"data:image/svg+xml," + encodeURIComponent(svg) + "\\") 12 12, auto";
+  }
+  function updateCursor() {
+    if (tool === "laser") {
+      stage.style.cursor = "none";
+    } else if (tool === "pen") {
+      stage.style.cursor = createPenCursor(penColor);
+    } else {
+      stage.style.cursor = "default";
+    }
+  }
+  function showToolbar() {
+    toolbar.dataset.visible = "true";
+    window.clearTimeout(hideTimer);
+    hideTimer = window.setTimeout(() => {
+      toolbar.dataset.visible = "false";
+    }, 1500);
+  }
+  function maybeShowToolbar(event) {
+    if (event.clientY >= window.innerHeight - 96) {
+      showToolbar();
+    }
+  }
+  function pointInFrame(event) {
+    const rect = frame.getBoundingClientRect();
+    const scale = Number(inkLayer.dataset.scale || "1");
+    return {
+      x: Math.min(Math.max(event.clientX - rect.left, 0), rect.width) / scale,
+      y: Math.min(Math.max(event.clientY - rect.top, 0), rect.height) / scale,
+      inside: event.clientX >= rect.left && event.clientX <= rect.right && event.clientY >= rect.top && event.clientY <= rect.bottom,
+    };
+  }
+  function beginInk(event) {
+    if (tool !== "pen") return;
+    if (!frame.contains(event.target)) return;
+    const point = pointInFrame(event);
+    if (!point.inside) return;
+    const path = document.createElementNS("http://www.w3.org/2000/svg", "path");
+    path.setAttribute("stroke", penColor);
+    path.setAttribute("d", "M " + point.x.toFixed(1) + " " + point.y.toFixed(1));
+    inkLayer.append(path);
+    drawing = { path, d: path.getAttribute("d") };
+  }
+  function extendInk(event) {
+    if (!drawing) return;
+    const point = pointInFrame(event);
+    drawing.d += " L " + point.x.toFixed(1) + " " + point.y.toFixed(1);
+    drawing.path.setAttribute("d", drawing.d);
+  }
+  function goToIndex(nextIndex) {
+    setTool("none");
+    index = Math.min(Math.max(nextIndex, 0), deck.slides.length - 1);
+    renderSlide();
+  }
+  function goNext() {
+    goToIndex(index + 1);
+  }
+  function updateFullscreenButton() {
+    const button = toolbar.querySelector("[data-action='fullscreen']");
+    const isFullscreen = Boolean(document.fullscreenElement);
+    button.setAttribute("aria-label", isFullscreen ? "Exit fullscreen" : "Enter fullscreen");
+    button.textContent = isFullscreen ? "Window" : "Fullscreen";
+    renderSlide();
+  }
+  toolbar.addEventListener("click", (event) => {
+    const button = event.target.closest("button");
+    if (!button) return;
+    showToolbar();
+    if (button.dataset.action === "previous") {
+      goToIndex(index - 1);
+    } else if (button.dataset.action === "next") {
+      goNext();
+    } else if (button.dataset.action === "fullscreen") {
+      if (document.fullscreenElement) {
+        document.exitFullscreen?.();
+      } else if (document.documentElement.requestFullscreen) {
+        document.documentElement.requestFullscreen();
+      }
+    } else if (button.dataset.action === "exit") {
+      window.close();
+    } else if (button.dataset.tool) {
+      setTool(button.dataset.tool);
+    }
+  });
+  toolbar.addEventListener("pointerenter", showToolbar);
+  toolbar.addEventListener("pointermove", showToolbar);
+  window.addEventListener("resize", renderSlide);
+  document.addEventListener("fullscreenchange", updateFullscreenButton);
+  window.addEventListener("pointermove", (event) => {
+    maybeShowToolbar(event);
+    if (tool === "laser") {
+      laser.style.transform = "translate(" + event.clientX + "px," + event.clientY + "px) translate(-50%,-50%)";
+    }
+    extendInk(event);
+  });
+  window.addEventListener("pointerdown", beginInk);
+  window.addEventListener("click", (event) => {
+    if (tool !== "none") return;
+    if (!frame.contains(event.target)) return;
+    goNext();
+  });
+  window.addEventListener("wheel", (event) => {
+    if (tool !== "none") return;
+    if (Math.abs(event.deltaY) < Math.abs(event.deltaX) || event.deltaY <= 8) return;
+    const now = Date.now();
+    if (now - lastWheelAt < 360) return;
+    lastWheelAt = now;
+    event.preventDefault();
+    goNext();
+  }, { passive: false });
+  window.addEventListener("pointerup", () => {
+    drawing = null;
+  });
+  window.addEventListener("keydown", (event) => {
+    if (event.key === "Escape") {
+      if (tool === "pen") {
+        setTool("none");
+        clearInk();
+      }
+      showToolbar();
+    } else if (event.key === "ArrowRight" || event.key === "ArrowDown" || event.key === "PageDown") {
+      goNext();
+    } else if (event.key === "ArrowLeft" || event.key === "ArrowUp" || event.key === "PageUp") {
+      goToIndex(index - 1);
+    }
+  });
+  renderPenColors();
+  updateCursor();
+  renderSlide();
+})();
+`;
+export {
+  SELECTOR_ATTR,
+  SLIDE_ROOT_ATTR,
+  DEFAULT_SLIDE_WIDTH,
+  DEFAULT_SLIDE_HEIGHT,
+  getSlideElementSelector,
+  getSlideRootSelector,
+  createElementId,
+  parseDimension,
+  normalizeSlideId,
+  ensureEditableSelectors,
+  parseSlide,
+  querySlideElement,
+  getSlideInlineStyleValue,
+  parseHtmlDocument2 as parseHtmlDocument,
+  serializeHtmlDocument2 as serializeHtmlDocument,
+  updateHtmlSource,
+  ELEMENT_LAYOUT_STYLE_KEYS,
+  createEmptyElementLayoutStyleSnapshot,
+  captureElementLayoutStyleSnapshot,
+  normalizeElementLayoutStyleSnapshot,
+  parseTransformParts,
+  composeTransform,
+  elementRectToStageRect,
+  stageDeltaToSlideDelta,
+  applySlideOperation,
+  invertSlideOperation,
+  updateSlideText,
+  updateSlideStyle,
+  updateSlideAttribute,
+  duplicateSlideElement,
+  updateSlideElementLayout,
+  createElementPlacement,
+  getSlideElementHtml,
+  updateSlideElementHtmlIds,
+  createUniqueElementId,
+  insertSlideElement,
+  removeSlideElement,
+  updateSlideElementTransform,
+  createGroupCreateOperation,
+  createGroupUngroupOperation,
+  createUniqueSlideId,
+  createUniqueSlideSourceFile,
+  createBlankSlide,
+  createDuplicatedSlide,
+  createHistoryState,
+  reduceHistory,
+  loadSlidesFromManifest,
+  planPdfExport,
+  planPdfExportSlides,
+  planHtmlExportSlides,
+  resolveHtmlExportSlides,
+  createSingleHtmlExportDocument
+};