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-DHWTBXGS.js ADDED Viewed

@@ -0,0 +1,985 @@
+// 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 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 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;
+  }
+  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 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 = {},
+  timestamp = Date.now()
+}) {
+  const doc = parseHtmlDocument2(html);
+  if (!doc) {
+    return null;
+  }
+  const groupNode = querySlideElement(doc, groupElementId);
+  if (!groupNode || groupNode.getAttribute("data-group") !== "true" || !groupNode.parentElement) {
+    return null;
+  }
+  const parent = groupNode.parentElement;
+  const parentRect = getEditableAncestorRect(groupNode, elementRects);
+  const children = childEditableElements(groupNode);
+  if (!children.length) {
+    return null;
+  }
+  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
+    });
+    parent.insertBefore(child, groupNode);
+  }
+  groupNode.remove();
+  const nextHtmlSource = serializeHtmlDocument2(doc);
+  if (nextHtmlSource === html) {
+    return null;
+  }
+  return {
+    type: "group.ungroup",
+    slideId,
+    groupElementId,
+    childElementIds,
+    previousHtmlSource: html,
+    nextHtmlSource,
+    timestamp
+  };
+}
+// src/core/slide-operation-reducer.ts
+function preserveSlideSource(sourceSlide, nextSlide) {
+  return {
+    ...nextSlide,
+    sourceFile: sourceSlide.sourceFile
+  };
+}
+function applySlideOperation(slide, operation) {
+  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
+      };
+  }
+}
+// src/core/history.ts
+function applyOperationToSlides(slides, operation) {
+  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,
+        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);
+}
+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,
+  createHistoryState,
+  reduceHistory,
+  loadSlidesFromManifest,
+  planPdfExport,
+  planPdfExportSlides
+};