ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/chunk-7JBQPQ6G.mjs

@@ -0,0 +1,226 @@
+// src/pptx/export/canvas-color-fix.ts
+function extractBlobUrl(cssValue) {
+  const startIndex = cssValue.indexOf("blob:");
+  if (startIndex === -1) {
+    return null;
+  }
+  const match = /^[^"')]+/.exec(cssValue.slice(startIndex));
+  return match ? match[0] : null;
+}
+async function blobUrlToDataUrl(blobUrl) {
+  try {
+    const response = await fetch(blobUrl);
+    const blob = await response.blob();
+    return await new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => resolve(reader.result);
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  } catch {
+    return null;
+  }
+}
+async function convertBlobUrlsToDataUrls(root) {
+  const promises = [];
+  const images = root.querySelectorAll('img[src^="blob:"]');
+  for (const img of images) {
+    const blobUrl = img.src;
+    promises.push(
+      blobUrlToDataUrl(blobUrl).then((dataUrl) => {
+        if (!dataUrl) {
+          return void 0;
+        }
+        const replacement = img.ownerDocument.createElement("img");
+        for (const attr of Array.from(img.attributes)) {
+          if (attr.name !== "src") {
+            replacement.setAttribute(attr.name, attr.value);
+          }
+        }
+        replacement.src = dataUrl;
+        replacement.style.cssText = img.style.cssText;
+        img.parentNode?.replaceChild(replacement, img);
+        return void 0;
+      })
+    );
+  }
+  const allElements = root.querySelectorAll("*");
+  for (const el of allElements) {
+    const htmlEl = el;
+    const bg = htmlEl.style.backgroundImage;
+    if (bg && bg.includes("blob:")) {
+      const blobUrl = extractBlobUrl(bg);
+      if (blobUrl) {
+        promises.push(
+          blobUrlToDataUrl(blobUrl).then((dataUrl) => {
+            if (dataUrl) {
+              htmlEl.style.backgroundImage = bg.replace(blobUrl, dataUrl);
+            }
+            return void 0;
+          })
+        );
+      }
+    }
+  }
+  const rootBg = root.style.backgroundImage;
+  if (rootBg && rootBg.includes("blob:")) {
+    const blobUrl = extractBlobUrl(rootBg);
+    if (blobUrl) {
+      promises.push(
+        blobUrlToDataUrl(blobUrl).then((dataUrl) => {
+          if (dataUrl) {
+            root.style.backgroundImage = rootBg.replace(blobUrl, dataUrl);
+          }
+          return void 0;
+        })
+      );
+    }
+  }
+  await Promise.all(promises);
+}
+var UNSUPPORTED_COLOR_RE = /oklch|oklab|lch\(|lab\(|color\(/iu;
+var UNSUPPORTED_COLOR_FN_RE = /(?:oklch|oklab|lch|lab|color)\([^)]*(?:\([^)]*\)[^)]*)*\)/giu;
+var _scratchCtx;
+function getScratchCtx() {
+  if (_scratchCtx === void 0) {
+    _scratchCtx = document.createElement("canvas").getContext("2d");
+  }
+  return _scratchCtx;
+}
+function resolveColorToSrgb(value) {
+  const ctx = getScratchCtx();
+  if (!ctx) {
+    return value;
+  }
+  const SENTINEL = "#020304";
+  ctx.fillStyle = SENTINEL;
+  ctx.fillStyle = value.trim();
+  const result = ctx.fillStyle;
+  return result === SENTINEL ? value : result;
+}
+function replaceUnsupportedColors(value) {
+  if (!UNSUPPORTED_COLOR_RE.test(value)) {
+    return value;
+  }
+  return value.replace(UNSUPPORTED_COLOR_FN_RE, (match) => resolveColorToSrgb(match));
+}
+var COLOR_PROPERTIES = [
+  "color",
+  "background-color",
+  "border-top-color",
+  "border-right-color",
+  "border-bottom-color",
+  "border-left-color",
+  "outline-color",
+  "text-decoration-color",
+  "column-rule-color",
+  "caret-color",
+  "accent-color",
+  "text-emphasis-color",
+  "fill",
+  "stroke",
+  "stop-color",
+  "flood-color",
+  "lighting-color"
+];
+var COMPLEX_COLOR_PROPERTIES = [
+  "box-shadow",
+  "text-shadow",
+  "background-image",
+  "background",
+  "border-image"
+];
+function resolveUnsupportedColours(root) {
+  const elements = root.querySelectorAll("*");
+  const resolve = (el) => {
+    const htmlEl = el;
+    if (!htmlEl.style) {
+      return;
+    }
+    const computed = window.getComputedStyle(htmlEl);
+    for (const prop of COLOR_PROPERTIES) {
+      const value = computed.getPropertyValue(prop);
+      if (value && UNSUPPORTED_COLOR_RE.test(value)) {
+        htmlEl.style.setProperty(prop, resolveColorToSrgb(value));
+      }
+    }
+    for (const prop of COMPLEX_COLOR_PROPERTIES) {
+      const value = computed.getPropertyValue(prop);
+      if (value && UNSUPPORTED_COLOR_RE.test(value)) {
+        htmlEl.style.setProperty(prop, replaceUnsupportedColors(value));
+      }
+    }
+    const inlineStyle = htmlEl.style;
+    for (let i = 0; i < inlineStyle.length; i++) {
+      const prop = inlineStyle[i];
+      if (!prop.startsWith("--")) {
+        continue;
+      }
+      const value = inlineStyle.getPropertyValue(prop);
+      if (value && UNSUPPORTED_COLOR_RE.test(value)) {
+        inlineStyle.setProperty(prop, replaceUnsupportedColors(value));
+      }
+    }
+  };
+  resolve(root);
+  elements.forEach(resolve);
+}
+function resolveRootCustomProperties(doc) {
+  const targets = [doc.documentElement, doc.body];
+  for (const target of targets) {
+    if (!target) {
+      continue;
+    }
+    const inlineStyle = target.style;
+    for (let i = 0; i < inlineStyle.length; i++) {
+      const prop = inlineStyle[i];
+      if (!prop.startsWith("--")) {
+        continue;
+      }
+      const value = inlineStyle.getPropertyValue(prop);
+      if (value && UNSUPPORTED_COLOR_RE.test(value)) {
+        inlineStyle.setProperty(prop, replaceUnsupportedColors(value));
+      }
+    }
+  }
+}
+function patchStylesheets(doc) {
+  const styles = doc.querySelectorAll("style");
+  for (const style of styles) {
+    const text = style.textContent ?? "";
+    if (!UNSUPPORTED_COLOR_RE.test(text)) {
+      continue;
+    }
+    style.textContent = text.replace(UNSUPPORTED_COLOR_FN_RE, (match) => resolveColorToSrgb(match));
+  }
+}
+async function normalizeColorsForCapture(doc, clonedEl) {
+  await convertBlobUrlsToDataUrls(clonedEl);
+  patchStylesheets(doc);
+  resolveRootCustomProperties(doc);
+  resolveUnsupportedColours(clonedEl);
+}
+var _testing = {
+  UNSUPPORTED_COLOR_RE,
+  UNSUPPORTED_COLOR_FN_RE,
+  resolveColorToSrgb,
+  replaceUnsupportedColors,
+  resolveUnsupportedColours,
+  resolveRootCustomProperties,
+  patchStylesheets,
+  convertBlobUrlsToDataUrls,
+  blobUrlToDataUrl,
+  extractBlobUrl,
+  COLOR_PROPERTIES,
+  COMPLEX_COLOR_PROPERTIES,
+  /** Reset the lazily-cached scratch context (useful in tests). */
+  resetScratchCtx() {
+    _scratchCtx = void 0;
+  },
+  /** Override the scratch context with a mock (useful in tests). */
+  setScratchCtx(ctx) {
+    _scratchCtx = ctx;
+  }
+};
+
+export { _testing, convertBlobUrlsToDataUrls, normalizeColorsForCapture };

package/dist/pptx/chunk-7KPDES3X.mjs

@@ -0,0 +1,285 @@
+// src/pptx/render/animation-direction-options.ts
+var DIRECTION_VALUES = [
+  "fromTop",
+  "fromBottom",
+  "fromLeft",
+  "fromRight",
+  "fromTopLeft",
+  "fromTopRight",
+  "fromBottomLeft",
+  "fromBottomRight"
+];
+var ANIMATION_DIRECTION_LABEL_KEYS = {
+  fromTop: "pptx.animation.direction.fromTop",
+  fromBottom: "pptx.animation.direction.fromBottom",
+  fromLeft: "pptx.animation.direction.fromLeft",
+  fromRight: "pptx.animation.direction.fromRight",
+  fromTopLeft: "pptx.animation.direction.fromTopLeft",
+  fromTopRight: "pptx.animation.direction.fromTopRight",
+  fromBottomLeft: "pptx.animation.direction.fromBottomLeft",
+  fromBottomRight: "pptx.animation.direction.fromBottomRight"
+};
+var EDGES = DIRECTION_VALUES.slice(0, 4);
+var PRESET_DIRECTIONS = {
+  flyIn: DIRECTION_VALUES,
+  flyOut: DIRECTION_VALUES,
+  crawlIn: DIRECTION_VALUES,
+  crawlOut: DIRECTION_VALUES,
+  wipeIn: EDGES,
+  wipeOut: EDGES,
+  peekIn: EDGES,
+  peekOut: EDGES,
+  stretchIn: EDGES
+};
+var DIRECTIONAL_PRESETS = new Set(Object.keys(PRESET_DIRECTIONS));
+function directionValuesForPreset(preset) {
+  return preset && PRESET_DIRECTIONS[preset] || [];
+}
+function effectiveDirection(entry, values) {
+  if (entry?.direction && values.includes(entry.direction)) {
+    return entry.direction;
+  }
+  return values.includes("fromBottom") ? "fromBottom" : values[0];
+}
+function directionValuesFor(slideAnimations, elementId) {
+  const entry = slideAnimations.find((a) => a.elementId === elementId);
+  if (!entry) {
+    return [];
+  }
+  const entrance = directionValuesForPreset(entry.entrance);
+  return entrance.length > 0 ? entrance : directionValuesForPreset(entry.exit);
+}
+
+// src/pptx/render/animation-authoring.ts
+var ENTRANCE_PRESET_VALUES = [
+  "appear",
+  "fadeIn",
+  "flyIn",
+  "zoomIn",
+  "bounceIn",
+  "wipeIn",
+  "splitIn",
+  "dissolveIn",
+  "floatIn",
+  "growTurnIn"
+];
+var EXIT_PRESET_VALUES = [
+  "fadeOut",
+  "flyOut",
+  "zoomOut",
+  "bounceOut",
+  "wipeOut",
+  "shrinkOut",
+  "dissolveOut",
+  "disappear"
+];
+var EMPHASIS_PRESET_VALUES = [
+  "spin",
+  "pulse",
+  "colorWave",
+  "bounce",
+  "flash",
+  "growShrink",
+  "teeter",
+  "wave",
+  "boldFlash"
+];
+var TRIGGER_VALUES = [
+  "onClick",
+  "onShapeClick",
+  "onHover",
+  "afterPrevious",
+  "withPrevious",
+  "afterDelay",
+  // "On bookmark": starts when a media element reaches a bookmark. Pairs with
+  // the bookmark picker from `animation-bookmark-trigger`.
+  "onMediaBookmark"
+];
+var TRIGGER_OPTIONS = TRIGGER_VALUES.map((value) => ({ value, labelKey: `pptx.animation.trigger.${value}` }));
+var TIMING_CURVE_VALUES = [
+  "ease",
+  "ease-in",
+  "ease-out",
+  "linear"
+];
+var REPEAT_MODE_VALUES = [
+  "none",
+  "untilNextClick",
+  "untilEndOfSlide"
+];
+var SEQUENCE_VALUES = [
+  "asOne",
+  "byParagraph",
+  "byWord",
+  "byLetter"
+];
+var DEFAULT_DURATION_MS = 500;
+var DEFAULT_TRIGGER = "onClick";
+function animationFor(slideAnimations, elementId) {
+  return slideAnimations.find((a) => a.elementId === elementId);
+}
+function hasAnimation(slideAnimations, elementId) {
+  const entry = animationFor(slideAnimations, elementId);
+  return Boolean(entry && (entry.entrance || entry.exit || entry.emphasis || entry.motionPath));
+}
+function showDirectionPicker(slideAnimations, elementId) {
+  return directionValuesFor(slideAnimations, elementId).length > 0;
+}
+function upsert(anims, elementId, updater) {
+  const idx = anims.findIndex((a) => a.elementId === elementId);
+  if (idx >= 0) {
+    const updated2 = updater({ ...anims[idx] });
+    if (updated2 === null) {
+      return anims.filter((a) => a.elementId !== elementId);
+    }
+    return anims.map((a, i) => i === idx ? updated2 : a);
+  }
+  const created = {
+    elementId,
+    durationMs: DEFAULT_DURATION_MS,
+    order: anims.length,
+    trigger: DEFAULT_TRIGGER
+  };
+  const updated = updater(created);
+  if (updated === null) {
+    return [...anims];
+  }
+  return [...anims, updated];
+}
+function setEffect(anims, elementId, group, preset) {
+  const value = preset === "none" ? void 0 : preset;
+  return upsert(anims, elementId, (cur) => {
+    const next = { ...cur, [group]: value };
+    if (!next.entrance && !next.exit && !next.emphasis && !next.motionPath) {
+      return null;
+    }
+    return next;
+  });
+}
+function setAnimationEntrance(anims, elementId, preset) {
+  return setEffect(anims, elementId, "entrance", preset);
+}
+function setAnimationExit(anims, elementId, preset) {
+  return setEffect(anims, elementId, "exit", preset);
+}
+function setAnimationEmphasis(anims, elementId, preset) {
+  return setEffect(anims, elementId, "emphasis", preset);
+}
+function setTrigger(anims, elementId, trigger) {
+  return upsert(anims, elementId, (cur) => ({ ...cur, ...triggerChangePatch(cur, trigger) }));
+}
+function triggerChangePatch(current, trigger) {
+  const keepsTarget = trigger === current?.trigger && (trigger === "onShapeClick" || trigger === "onMediaBookmark");
+  return keepsTarget ? {
+    trigger,
+    triggerShapeId: current?.triggerShapeId,
+    triggerBookmark: current?.triggerBookmark
+  } : { trigger, triggerShapeId: void 0, triggerBookmark: void 0 };
+}
+function setTriggerShapeId(anims, elementId, triggerShapeId) {
+  return upsert(anims, elementId, (cur) => ({ ...cur, triggerShapeId }));
+}
+function setDuration(anims, elementId, durationMs) {
+  const clamped = Math.max(100, Math.min(1e4, durationMs));
+  return upsert(anims, elementId, (cur) => ({ ...cur, durationMs: clamped }));
+}
+function setDelay(anims, elementId, delayMs) {
+  const clamped = Math.max(0, Math.min(1e4, delayMs));
+  return upsert(anims, elementId, (cur) => ({ ...cur, delayMs: clamped }));
+}
+function setTimingCurve(anims, elementId, timingCurve) {
+  return upsert(anims, elementId, (cur) => ({ ...cur, timingCurve }));
+}
+function setDirection(anims, elementId, direction) {
+  return upsert(anims, elementId, (cur) => ({ ...cur, direction }));
+}
+function setSequence(anims, elementId, sequence) {
+  return upsert(anims, elementId, (cur) => ({ ...cur, sequence }));
+}
+function setRepeatCount(anims, elementId, repeatCount) {
+  const clamped = Math.max(1, Math.min(100, repeatCount));
+  return upsert(anims, elementId, (cur) => ({ ...cur, repeatCount: clamped }));
+}
+function setRepeatMode(anims, elementId, repeatMode) {
+  const value = repeatMode === "none" ? void 0 : repeatMode;
+  return upsert(anims, elementId, (cur) => ({ ...cur, repeatMode: value }));
+}
+function removeAnimation(anims, elementId) {
+  const idx = anims.findIndex((a) => a.elementId === elementId);
+  if (idx < 0) {
+    return [...anims];
+  }
+  const result = anims.filter((a) => a.elementId !== elementId);
+  return reindexOrder(result);
+}
+function reorderAnimationUp(anims, elementId) {
+  return reorderByDelta(anims, elementId, -1);
+}
+function reorderAnimationDown(anims, elementId) {
+  return reorderByDelta(anims, elementId, 1);
+}
+function reorderAnimationTo(animations, source, targetIndex) {
+  const sorted = [...animations].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  const sourceIndex = typeof source === "number" ? source : sorted.findIndex((a) => a.elementId === source.elementId);
+  if (sourceIndex < 0 || sourceIndex >= sorted.length || targetIndex < 0 || targetIndex >= sorted.length || sourceIndex === targetIndex) {
+    return reindexOrder(sorted);
+  }
+  const [moved] = sorted.splice(sourceIndex, 1);
+  sorted.splice(targetIndex, 0, moved);
+  return reindexOrder(sorted);
+}
+function applyAnimationPreset(animations, elementId, group, preset) {
+  const exists = animations.some((a) => a.elementId === elementId);
+  if (exists) {
+    return animations.map((a) => a.elementId === elementId ? { ...a, [group]: preset } : a);
+  }
+  return [
+    ...animations,
+    {
+      elementId,
+      [group]: preset,
+      durationMs: DEFAULT_DURATION_MS,
+      order: animations.length,
+      trigger: DEFAULT_TRIGGER
+    }
+  ];
+}
+function removeElementAnimation(animations, elementId) {
+  return animations.filter((a) => a.elementId !== elementId);
+}
+var MIN_TIMELINE_BAR_WIDTH_PERCENT = 2;
+function buildAnimationTimelineBars(animations) {
+  const sorted = [...animations].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  const total = Math.max(
+    1,
+    ...sorted.map((animation) => (animation.delayMs ?? 0) + (animation.durationMs ?? 500))
+  );
+  return sorted.map((animation) => ({
+    elementId: animation.elementId,
+    leftPercent: (animation.delayMs ?? 0) / total * 100,
+    widthPercent: Math.max(
+      (animation.durationMs ?? 500) / total * 100,
+      MIN_TIMELINE_BAR_WIDTH_PERCENT
+    )
+  }));
+}
+function reorderByDelta(anims, elementId, delta) {
+  const sorted = [...anims].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  const idx = sorted.findIndex((a) => a.elementId === elementId);
+  if (idx < 0) {
+    return [...anims];
+  }
+  const swapIdx = idx + delta;
+  if (swapIdx < 0 || swapIdx >= sorted.length) {
+    return [...anims];
+  }
+  const tmp = sorted[idx];
+  sorted[idx] = sorted[swapIdx];
+  sorted[swapIdx] = tmp;
+  return reindexOrder(sorted);
+}
+function reindexOrder(anims) {
+  return anims.map((a, i) => ({ ...a, order: i }));
+}
+
+export { ANIMATION_DIRECTION_LABEL_KEYS, DIRECTIONAL_PRESETS, DIRECTION_VALUES, EMPHASIS_PRESET_VALUES, ENTRANCE_PRESET_VALUES, EXIT_PRESET_VALUES, REPEAT_MODE_VALUES, SEQUENCE_VALUES, TIMING_CURVE_VALUES, TRIGGER_OPTIONS, TRIGGER_VALUES, animationFor, applyAnimationPreset, buildAnimationTimelineBars, directionValuesFor, directionValuesForPreset, effectiveDirection, hasAnimation, removeAnimation, removeElementAnimation, reorderAnimationDown, reorderAnimationTo, reorderAnimationUp, setAnimationEmphasis, setAnimationEntrance, setAnimationExit, setDelay, setDirection, setDuration, setRepeatCount, setRepeatMode, setSequence, setTimingCurve, setTrigger, setTriggerShapeId, showDirectionPicker, triggerChangePatch, upsert };

package/dist/pptx/chunk-A5MANNJR.cjs

@@ -0,0 +1,136 @@
+'use strict';
+
+// src/pptx/ai/chat-history-store.ts
+function toChatSummary(chat) {
+  return {
+    id: chat.id,
+    title: chat.title,
+    deckId: chat.deckId,
+    createdAt: chat.createdAt,
+    updatedAt: chat.updatedAt,
+    messageCount: chat.messages.length
+  };
+}
+function getLocalStorage() {
+  const ls = typeof localStorage !== "undefined" ? localStorage : void 0;
+  if (!ls) {
+    throw new Error("localStorage is not available in this environment.");
+  }
+  return ls;
+}
+function createLocalStorageBackend(namespace) {
+  const indexKey = `${namespace}:index`;
+  const chatKey = (id) => `${namespace}:chat:${id}`;
+  const readIndex = (ls) => {
+    const raw = ls.getItem(indexKey);
+    if (!raw) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  };
+  const readChat = (ls, id) => {
+    const raw = ls.getItem(chatKey(id));
+    if (!raw) {
+      return null;
+    }
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  };
+  return {
+    async list(deckId) {
+      const ls = getLocalStorage();
+      const summaries = [];
+      for (const id of readIndex(ls)) {
+        const chat = readChat(ls, id);
+        if (chat && (deckId === void 0 || chat.deckId === deckId)) {
+          summaries.push(toChatSummary(chat));
+        }
+      }
+      return summaries.sort((a, b) => b.updatedAt - a.updatedAt);
+    },
+    async load(id) {
+      return readChat(getLocalStorage(), id);
+    },
+    async save(chat) {
+      const ls = getLocalStorage();
+      const ids = readIndex(ls);
+      if (!ids.includes(chat.id)) {
+        ids.push(chat.id);
+        ls.setItem(indexKey, JSON.stringify(ids));
+      }
+      ls.setItem(chatKey(chat.id), JSON.stringify(chat));
+    },
+    async remove(id) {
+      const ls = getLocalStorage();
+      const ids = readIndex(ls).filter((existing) => existing !== id);
+      ls.setItem(indexKey, JSON.stringify(ids));
+      ls.removeItem(chatKey(id));
+    },
+    async clear(deckId) {
+      const ls = getLocalStorage();
+      const ids = readIndex(ls);
+      const keep = [];
+      for (const id of ids) {
+        const chat = readChat(ls, id);
+        if (deckId !== void 0 && chat && chat.deckId !== deckId) {
+          keep.push(id);
+        } else {
+          ls.removeItem(chatKey(id));
+        }
+      }
+      ls.setItem(indexKey, JSON.stringify(keep));
+    }
+  };
+}
+async function resolveBackend(dbName, namespace) {
+  try {
+    const { openChatDb, createIdbBackend } = await import('./chat-history-idb-PGLJPVOI.cjs');
+    const db = await openChatDb(dbName);
+    return createIdbBackend(db);
+  } catch {
+    return createLocalStorageBackend(namespace);
+  }
+}
+function createChatHistoryStore(options) {
+  const dbName = options?.dbName ?? "pptx-ai-chats";
+  const namespace = options?.namespace ?? dbName;
+  let backendPromise = null;
+  const backend = () => {
+    backendPromise ??= resolveBackend(dbName, namespace);
+    return backendPromise;
+  };
+  return {
+    async listChats(opts) {
+      return (await backend()).list(opts?.deckId);
+    },
+    async loadChat(id) {
+      return (await backend()).load(id);
+    },
+    async saveChat(chat) {
+      const now = Date.now();
+      const normalized = {
+        ...structuredClone(chat),
+        createdAt: chat.createdAt || now,
+        updatedAt: now
+      };
+      await (await backend()).save(normalized);
+    },
+    async deleteChat(id) {
+      await (await backend()).remove(id);
+    },
+    async clearChats(opts) {
+      await (await backend()).clear(opts?.deckId);
+    }
+  };
+}
+
+exports.createChatHistoryStore = createChatHistoryStore;
+exports.toChatSummary = toChatSummary;

package/dist/pptx/chunk-A62C6PSL.mjs

@@ -0,0 +1,21 @@
+// src/pptx/export/pdf-page-size.ts
+var A4_PT_W = 841.89;
+var A4_PT_H = 595.28;
+function pdfOrientation(w, h) {
+  return w > h ? "landscape" : "portrait";
+}
+function pdfPageSize(w, h) {
+  const orientation = pdfOrientation(w, h);
+  if (orientation === "landscape") {
+    return { width: A4_PT_W, height: A4_PT_H, orientation };
+  }
+  return { width: A4_PT_H, height: A4_PT_W, orientation };
+}
+function sanitizeFileName(name) {
+  return name.replace(/[\\/:*?"<>|\x00-\x1F]/gu, "_");
+}
+function slideFileName(baseName, index, ext) {
+  return `${baseName}-${index}.${ext}`;
+}
+
+export { pdfOrientation, pdfPageSize, sanitizeFileName, slideFileName };