@arcships/pptx-core 0.3.0

package/dist/chunk-YX5SL7A5.js

@@ -0,0 +1,709 @@
+// src/types.ts
+var PptxPreviewError = class extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "PptxPreviewError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+
+// src/playback/errors.ts
+var PptxPlaybackError = class extends Error {
+  code;
+  slideIndex;
+  objectKey;
+  sourceNodeId;
+  cause;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "PptxPlaybackError";
+    this.code = code;
+    this.slideIndex = details.slideIndex;
+    this.objectKey = details.objectKey;
+    this.sourceNodeId = details.sourceNodeId;
+    this.cause = details.cause;
+  }
+};
+
+// src/playback/capability.ts
+function createPptxCapabilityReport(features = []) {
+  const records = Object.freeze([...features]);
+  return Object.freeze({
+    discovered: records.length,
+    strict: records.filter((item) => item.disposition === "strict").length,
+    approximate: records.filter((item) => item.disposition === "approximate").length,
+    static: records.filter((item) => item.disposition === "static").length,
+    unparsed: records.filter((item) => item.disposition === "unparsed").length,
+    features: records
+  });
+}
+
+// src/playback/identity.ts
+function assertKeyPart(value, name) {
+  const normalized = value.trim();
+  if (!normalized || /[|/]/u.test(normalized)) {
+    throw new TypeError(`${name} \u4E0D\u80FD\u4E3A\u7A7A\uFF0C\u4E5F\u4E0D\u80FD\u5305\u542B\u201C|\u201D\u6216\u201C/\u201D\u3002`);
+  }
+  return normalized;
+}
+function createPptxObjectKey(parts) {
+  const slidePath = parts.slidePath.trim().replace(/^\/+|\/+$/gu, "");
+  if (!slidePath || slidePath.includes("|")) throw new TypeError("slidePath \u65E0\u6548\u3002");
+  const shapeId = assertKeyPart(parts.shapeId, "shapeId");
+  const groupPath = (parts.groupPath ?? []).map((id) => `group:${assertKeyPart(id, "groupPath")}`);
+  return `${slidePath}|${parts.source}|${[...groupPath, `shape:${shapeId}`].join("/")}`;
+}
+function uniqueIdentityMap(objects, value) {
+  const result = /* @__PURE__ */ new Map();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const object of objects) {
+    const key = value(object)?.trim();
+    if (!key || duplicates.has(key)) continue;
+    if (result.has(key)) {
+      result.delete(key);
+      duplicates.add(key);
+    } else result.set(key, object);
+  }
+  return result;
+}
+function matchPptxMorphObjects(fromObjects, toObjects) {
+  const matches = [];
+  const usedFrom = /* @__PURE__ */ new Set();
+  const usedTo = /* @__PURE__ */ new Set();
+  const appendMatches = (method, from, to) => {
+    for (const [identity, fromObject] of from) {
+      const toObject = to.get(identity);
+      if (!toObject || usedFrom.has(fromObject.key) || usedTo.has(toObject.key)) continue;
+      usedFrom.add(fromObject.key);
+      usedTo.add(toObject.key);
+      matches.push(Object.freeze({
+        from: fromObject.key,
+        to: toObject.key,
+        method,
+        confidence: "strong",
+        score: 1,
+        unique: true
+      }));
+    }
+  };
+  appendMatches(
+    "explicit-name",
+    uniqueIdentityMap(fromObjects, (object) => object.explicitMorphName),
+    uniqueIdentityMap(toObjects, (object) => object.explicitMorphName)
+  );
+  appendMatches(
+    "creation-id",
+    uniqueIdentityMap(fromObjects, (object) => object.creationId?.toLowerCase()),
+    uniqueIdentityMap(toObjects, (object) => object.creationId?.toLowerCase())
+  );
+  return Object.freeze(matches);
+}
+
+// src/playback/time-tree.ts
+function startCondition(node) {
+  return node.conditions.find((condition) => condition.source === "start" && condition.event !== "delay") ?? node.conditions.find((condition) => condition.source === "start");
+}
+function nodeTypeEvent(node) {
+  if (node.nodeType === "clickEffect") return "on-click";
+  if (node.nodeType === "withEffect") return "with-previous";
+  if (node.nodeType === "afterEffect") return "after-previous";
+  return void 0;
+}
+function effectiveDuration(node) {
+  if (node.durationMs === "indefinite" || node.repeatCount === "indefinite") return "indefinite";
+  const repeat = typeof node.repeatCount === "number" ? node.repeatCount : 1;
+  return node.durationMs * Math.max(repeat, 1) * (node.autoReverse ? 2 : 1);
+}
+function triggerForCondition(condition, event, clickBoundary) {
+  if (event === "on-click") return `click:${clickBoundary}`;
+  if (event === "on-shape-click" && condition?.targetObjectKey) return `shape:${condition.targetObjectKey}`;
+  if (event === "on-media-bookmark" && condition?.bookmarkName) return `bookmark:${condition.bookmarkName}`;
+  return void 0;
+}
+function executableTrigger(event) {
+  return [
+    "delay",
+    "on-click",
+    "with-previous",
+    "after-previous",
+    "on-shape-click",
+    "on-begin",
+    "on-end",
+    "on-media-bookmark"
+  ].includes(event);
+}
+function subtreeHasExplicitInteractiveTrigger(slide, nodeId, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(nodeId)) return false;
+  visited.add(nodeId);
+  const node = slide.nodes[nodeId];
+  if (!node) return false;
+  const event = startCondition(node)?.event ?? nodeTypeEvent(node);
+  if (["on-click", "on-shape-click", "on-media-bookmark"].includes(event ?? "")) return true;
+  if (node.effect) return false;
+  return node.childIds.some((childId) => subtreeHasExplicitInteractiveTrigger(slide, childId, visited));
+}
+function isMainSequenceAdvancedByClick(node) {
+  return node.nodeType === "mainSeq" && node.conditions.some((condition) => condition.source === "next" && condition.event === "on-next");
+}
+function compilePptxSlideSchedule(slide) {
+  if (!slide.rootNodeId || !slide.nodes[slide.rootNodeId]) {
+    return Object.freeze({ groups: Object.freeze([]), clickBoundaryCount: 0, unsupportedNodeIds: Object.freeze([]) });
+  }
+  const scheduled = [];
+  const unsupported = /* @__PURE__ */ new Set();
+  const previousByTrigger = /* @__PURE__ */ new Map();
+  const scheduledByNode = /* @__PURE__ */ new Map();
+  let clickBoundary = 0;
+  let order = 0;
+  let lastTrigger = "auto";
+  const visit = (nodeId, inherited) => {
+    const node = slide.nodes[nodeId];
+    if (!node) {
+      unsupported.add(nodeId);
+      return;
+    }
+    const condition = startCondition(node);
+    const explicitEvent = condition?.event ?? nodeTypeEvent(node);
+    const event = explicitEvent ?? inherited.triggerEvent ?? "delay";
+    let context = inherited;
+    if (explicitEvent && !executableTrigger(explicitEvent) && !node.effect) {
+      unsupported.add(node.id);
+      context = { triggerEvent: explicitEvent, clickBoundary: inherited.clickBoundary };
+    } else if (explicitEvent === "on-click" && !node.effect) {
+      clickBoundary += 1;
+      context = { triggerKey: `click:${clickBoundary}`, triggerEvent: event, clickBoundary };
+    } else if ((explicitEvent === "on-shape-click" || explicitEvent === "on-media-bookmark") && !node.effect) {
+      const key = triggerForCondition(condition, event, clickBoundary);
+      if (key) context = { triggerKey: key, triggerEvent: event, clickBoundary };
+      else unsupported.add(node.id);
+    }
+    if (node.effect) {
+      let boundary = context.clickBoundary;
+      let triggerKey = context.triggerKey;
+      if (event === "on-click" && context.triggerEvent !== "on-click") {
+        clickBoundary += 1;
+        boundary = clickBoundary;
+        triggerKey = `click:${boundary}`;
+      } else if (event === "on-shape-click" || event === "on-media-bookmark") {
+        triggerKey = triggerForCondition(condition, event, boundary) ?? context.triggerKey;
+      } else if (event === "with-previous" || event === "after-previous" || event === "on-begin" || event === "on-end") {
+        triggerKey ??= lastTrigger;
+      } else triggerKey ??= "auto";
+      if (!triggerKey || !executableTrigger(event)) {
+        unsupported.add(node.id);
+      } else {
+        const previous = previousByTrigger.get(triggerKey);
+        const delay = Math.max(0, condition?.delayMs ?? node.delayMs);
+        let startMs = delay;
+        if (event === "with-previous" && previous) startMs = previous.startMs + delay;
+        else if (event === "after-previous" && previous) {
+          startMs = previous.endMs === "indefinite" ? previous.startMs : previous.endMs + delay;
+        } else if ((event === "on-begin" || event === "on-end") && condition?.targetNodeId) {
+          const referenced = scheduledByNode.get(condition.targetNodeId);
+          if (referenced) {
+            const referenceTime = event === "on-begin" || referenced.endMs === "indefinite" ? referenced.startMs : referenced.endMs;
+            startMs = referenceTime + delay;
+          } else unsupported.add(node.id);
+        } else if (event === "delay" && node.container === "sequence" && previous) {
+          startMs = previous.endMs === "indefinite" ? previous.startMs : previous.endMs + delay;
+        }
+        const duration = effectiveDuration(node);
+        const item = Object.freeze({
+          nodeId: node.id,
+          effect: node.effect,
+          triggerKey,
+          triggerEvent: event,
+          clickBoundary: boundary,
+          startMs,
+          endMs: duration === "indefinite" ? "indefinite" : startMs + duration,
+          order: order++
+        });
+        scheduled.push(item);
+        previousByTrigger.set(triggerKey, item);
+        scheduledByNode.set(node.id, item);
+        lastTrigger = triggerKey;
+      }
+    }
+    if (isMainSequenceAdvancedByClick(node)) {
+      for (const childId of node.childIds) {
+        const child = slide.nodes[childId];
+        const childEvent = child ? startCondition(child)?.event ?? nodeTypeEvent(child) : void 0;
+        const followsPrevious = ["with-previous", "after-previous", "on-begin", "on-end"].includes(childEvent ?? "");
+        if (followsPrevious || subtreeHasExplicitInteractiveTrigger(slide, childId)) {
+          visit(childId, context);
+          continue;
+        }
+        clickBoundary += 1;
+        visit(childId, {
+          triggerKey: `click:${clickBoundary}`,
+          triggerEvent: "on-click",
+          clickBoundary
+        });
+      }
+    } else {
+      for (const childId of node.childIds) visit(childId, context);
+    }
+  };
+  visit(slide.rootNodeId, { triggerKey: "auto", triggerEvent: "delay", clickBoundary: 0 });
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const effect of scheduled) {
+    const group = groupMap.get(effect.triggerKey) ?? [];
+    group.push(effect);
+    groupMap.set(effect.triggerKey, group);
+  }
+  const groups = [...groupMap].map(([key, effects]) => {
+    const indefinite = effects.some((effect) => effect.endMs === "indefinite");
+    return Object.freeze({
+      key,
+      clickBoundary: effects[0]?.clickBoundary ?? 0,
+      durationMs: indefinite ? "indefinite" : Math.max(0, ...effects.map((effect) => effect.endMs)),
+      effects: Object.freeze([...effects].sort((left, right) => left.startMs - right.startMs || left.order - right.order))
+    });
+  }).sort((left, right) => {
+    if (left.key === "auto") return -1;
+    if (right.key === "auto") return 1;
+    return left.clickBoundary - right.clickBoundary;
+  });
+  return Object.freeze({
+    groups: Object.freeze(groups),
+    clickBoundaryCount: clickBoundary,
+    unsupportedNodeIds: Object.freeze([...unsupported])
+  });
+}
+
+// src/playback/track-compiler.ts
+var defaultValues = {
+  display: true,
+  opacity: 1,
+  "translate-x": 0,
+  "translate-y": 0,
+  "scale-x": 1,
+  "scale-y": 1,
+  rotate: 0,
+  "clip-path": "none",
+  filter: "none",
+  "fill-color": "",
+  "line-color": "",
+  "text-color": "",
+  "media-playback": "stopped",
+  "media-time": 0,
+  "media-volume": 1
+};
+function initialValue(initialState, objectKey, property, paragraphRange) {
+  const target = paragraphRange ? `${objectKey}#paragraph:${paragraphRange.start}-${paragraphRange.end}` : objectKey;
+  return initialState[target]?.[property] ?? defaultValues[property];
+}
+function numberValue(effect, name, fallback) {
+  const value = effect.values[name];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function motionEnd(effect) {
+  const path = effect.motionPath;
+  if (!path || !/^[\s\d.,+\-mlehvz]+$/iu.test(path)) return void 0;
+  const numbers = [...path.matchAll(/[+-]?(?:\d+(?:\.\d+)?|\.\d+)/gu)].map((match) => Number(match[0]));
+  if (numbers.length < 2) return void 0;
+  const rawX = numbers[numbers.length - 2];
+  const rawY = numbers[numbers.length - 1];
+  return {
+    x: rawX * (Math.abs(rawX) <= 10 ? numberValue(effect, "motionScaleX", 1) : 1),
+    y: rawY * (Math.abs(rawY) <= 10 ? numberValue(effect, "motionScaleY", 1) : 1)
+  };
+}
+function easingValue(node) {
+  return node.acceleration > 0 || node.deceleration > 0 ? `pptx(${node.acceleration},${node.deceleration})` : void 0;
+}
+function interpolateValue(from, to, progress) {
+  return typeof from === "number" && typeof to === "number" ? from + (to - from) * progress : progress >= 1 ? to : from;
+}
+function expandRepeats(fragments, node) {
+  if (!fragments.length || node.durationMs === "indefinite" || node.durationMs <= 0) return [...fragments];
+  const repeat = node.repeatCount === "indefinite" ? "indefinite" : Math.max(node.repeatCount ?? 1, 1);
+  const repeats = repeat === "indefinite" ? 1 : Math.ceil(repeat);
+  const period = node.durationMs * (node.autoReverse ? 2 : 1);
+  const result = [];
+  const effectStartMs = Math.min(...fragments.map((fragment) => fragment.startMs));
+  for (const source of fragments) {
+    if (source.startMs === source.endMs || ["display", "media-playback", "media-time", "media-volume"].includes(source.property)) {
+      if (source.startMs === source.endMs && source.startMs === effectStartMs && node.durationMs > 0) {
+        result.push({
+          ...source,
+          endMs: source.startMs + (repeat === "indefinite" ? period : repeat * period),
+          from: source.to,
+          repeatStartMs: repeat === "indefinite" ? source.startMs : void 0,
+          repeatPeriodMs: repeat === "indefinite" ? period : void 0,
+          repeatIndefinite: repeat === "indefinite" || void 0
+        });
+      } else result.push(source);
+      continue;
+    }
+    for (let cycle = 0; cycle < repeats; cycle += 1) {
+      const remaining = repeat === "indefinite" ? 1 : Math.min(1, repeat - cycle);
+      if (remaining <= 0) break;
+      const start = source.startMs + cycle * period;
+      const forwardEnd = start + node.durationMs * remaining;
+      const forwardTo = interpolateValue(source.from, source.to, remaining);
+      result.push({
+        ...source,
+        startMs: start,
+        endMs: forwardEnd,
+        to: forwardTo,
+        repeatStartMs: repeat === "indefinite" ? source.startMs : void 0,
+        repeatPeriodMs: repeat === "indefinite" ? period : void 0,
+        repeatIndefinite: repeat === "indefinite" || void 0
+      });
+      if (node.autoReverse && remaining === 1) result.push({
+        ...source,
+        startMs: forwardEnd,
+        endMs: forwardEnd + node.durationMs,
+        from: source.to,
+        to: source.from,
+        repeatStartMs: repeat === "indefinite" ? source.startMs : void 0,
+        repeatPeriodMs: repeat === "indefinite" ? period : void 0,
+        repeatIndefinite: repeat === "indefinite" || void 0
+      });
+    }
+  }
+  return result;
+}
+function fragmentsForEffect(scheduled, initialState, node) {
+  const effect = scheduled.effect;
+  const objectKey = effect.targetObjectKey;
+  if (!objectKey) return [];
+  const baseDuration = typeof node.durationMs === "number" ? node.durationMs : 0;
+  const baseEnd = scheduled.startMs + baseDuration;
+  const fragment = (property, from, to, startMs = scheduled.startMs, endMs = baseEnd) => ({
+    objectKey,
+    paragraphRange: effect.paragraphRange,
+    property,
+    initialValue: initialValue(initialState, objectKey, property, effect.paragraphRange),
+    startMs,
+    endMs,
+    from,
+    to,
+    sourceNodeId: scheduled.nodeId,
+    order: scheduled.order,
+    fill: node.fill,
+    easing: easingValue(node)
+  });
+  let fragments;
+  switch (effect.kind) {
+    case "appear":
+      fragments = [fragment("display", false, true, scheduled.startMs, scheduled.startMs)];
+      break;
+    case "disappear":
+      fragments = [fragment("display", true, false, scheduled.startMs, scheduled.startMs)];
+      break;
+    case "fade-in":
+      fragments = [
+        fragment("display", false, true, scheduled.startMs, scheduled.startMs),
+        fragment("opacity", 0, 1)
+      ];
+      break;
+    case "fade-out":
+      fragments = [
+        fragment("opacity", 1, 0),
+        fragment("display", true, false, baseEnd, baseEnd)
+      ];
+      break;
+    case "scale":
+      {
+        const fallback = effect.presetClass === "emph" ? 1 : 0;
+        const fromX = numberValue(effect, "scaleFromX", fallback);
+        const fromY = numberValue(effect, "scaleFromY", fallback);
+        fragments = [
+          fragment("scale-x", fromX, numberValue(effect, "scaleToX", fromX * numberValue(effect, "scaleByX", 1))),
+          fragment("scale-y", fromY, numberValue(effect, "scaleToY", fromY * numberValue(effect, "scaleByY", 1)))
+        ];
+      }
+      break;
+    case "emphasis": {
+      const property = effect.values.emphasisProperty;
+      if (property === "opacity") {
+        const from = numberValue(effect, "emphasisFrom", initialValue(initialState, objectKey, "opacity", effect.paragraphRange));
+        fragments = [fragment("opacity", from, numberValue(effect, "emphasisTo", from))];
+      } else fragments = [];
+      break;
+    }
+    case "rotate":
+      fragments = [fragment("rotate", 0, numberValue(effect, "rotationBy", 0))];
+      break;
+    case "motion-path": {
+      const end = motionEnd(effect);
+      fragments = end ? [fragment("translate-x", 0, end.x), fragment("translate-y", 0, end.y)] : [];
+      break;
+    }
+    case "wipe": {
+      const direction = effect.filter?.match(/wipe\(([^)]+)\)/iu)?.[1]?.toLowerCase();
+      if (direction !== "left" && direction !== "right") {
+        fragments = [];
+        break;
+      }
+      const from = direction === "right" ? "inset(0 0 0 100%)" : "inset(0 100% 0 0)";
+      fragments = [fragment("clip-path", from, "inset(0 0 0 0)")];
+      break;
+    }
+    case "media-command":
+      fragments = [fragment("media-playback", "stopped", effect.command ?? "play")];
+      break;
+    default:
+      fragments = [];
+  }
+  return expandRepeats(fragments, node);
+}
+function trackKey(fragment) {
+  const range = fragment.paragraphRange;
+  return `${fragment.objectKey}|${range ? `${range.start}:${range.end}` : "object"}|${fragment.property}`;
+}
+function compileFragments(fragments) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const fragment of fragments) {
+    const key = trackKey(fragment);
+    const list = groups.get(key) ?? [];
+    list.push(fragment);
+    groups.set(key, list);
+  }
+  return Object.freeze([...groups.values()].map((items) => {
+    const ordered = [...items].sort((left, right) => left.startMs - right.startMs || left.order - right.order);
+    const frames = /* @__PURE__ */ new Map();
+    for (const item of ordered) {
+      frames.set(item.startMs, Object.freeze({
+        timeMs: item.startMs,
+        value: item.from,
+        easing: item.easing,
+        sourceNodeId: item.sourceNodeId
+      }));
+      frames.set(item.endMs, Object.freeze({
+        timeMs: item.endMs,
+        value: item.to,
+        sourceNodeId: item.sourceNodeId
+      }));
+    }
+    const keyframes = Object.freeze([...frames.values()].sort((left, right) => left.timeMs - right.timeMs));
+    const first = ordered[0];
+    return Object.freeze({
+      objectKey: first.objectKey,
+      paragraphRange: first.paragraphRange,
+      property: first.property,
+      initialValue: first.initialValue,
+      keyframes,
+      segments: Object.freeze(ordered.map((item) => Object.freeze({
+        startMs: item.startMs,
+        endMs: item.endMs,
+        from: item.from,
+        to: item.to,
+        sourceNodeId: item.sourceNodeId,
+        order: item.order,
+        fill: item.fill,
+        easing: item.easing,
+        repeatStartMs: item.repeatStartMs,
+        repeatPeriodMs: item.repeatPeriodMs,
+        repeatIndefinite: item.repeatIndefinite
+      }))),
+      endTimeMs: ordered.some((item) => item.repeatIndefinite) ? "indefinite" : Math.max(0, ...ordered.map((item) => item.endMs)),
+      repeatStartMs: ordered.find((item) => item.repeatIndefinite)?.repeatStartMs,
+      repeatPeriodMs: ordered.find((item) => item.repeatIndefinite)?.repeatPeriodMs,
+      repeatIndefinite: ordered.some((item) => item.repeatIndefinite) || void 0
+    });
+  }));
+}
+function compilePptxSlideTracks(slide, initialState = Object.freeze({})) {
+  const schedule = compilePptxSlideSchedule(slide);
+  const preparedState = Object.fromEntries(
+    Object.entries(initialState).map(([key, value]) => [key, { ...value }])
+  );
+  const sourceState = Object.freeze(Object.fromEntries(
+    Object.entries(preparedState).map(([key, value]) => [key, Object.freeze({ ...value })])
+  ));
+  const compilableNodeIds = /* @__PURE__ */ new Set();
+  for (const scheduled of schedule.groups.flatMap((group) => group.effects)) {
+    const node = slide.nodes[scheduled.nodeId];
+    if (node && fragmentsForEffect(scheduled, sourceState, node).length > 0) {
+      compilableNodeIds.add(scheduled.nodeId);
+    }
+  }
+  for (const scheduled of schedule.groups.flatMap((group) => group.effects)) {
+    const effect = scheduled.effect;
+    const objectKey = effect.targetObjectKey;
+    if (!objectKey || effect.presetClass !== "entr" || !compilableNodeIds.has(scheduled.nodeId)) continue;
+    const target = effect.paragraphRange ? `${objectKey}#paragraph:${effect.paragraphRange.start}-${effect.paragraphRange.end}` : objectKey;
+    const state = preparedState[target] ?? {};
+    if (effect.kind === "appear") state.display = false;
+    else if (effect.kind === "fade-in") {
+      state.display = false;
+      state.opacity = 0;
+    } else if (effect.kind === "wipe") state["clip-path"] = effect.filter?.includes("right") ? "inset(0 0 0 100%)" : "inset(0 100% 0 0)";
+    else if (effect.kind === "scale") {
+      state["scale-x"] = numberValue(effect, "scaleFromX", 0);
+      state["scale-y"] = numberValue(effect, "scaleFromY", 0);
+    }
+    preparedState[target] = state;
+  }
+  const frozenInitialState = Object.freeze(Object.fromEntries(
+    Object.entries(preparedState).map(([key, value]) => [key, Object.freeze(value)])
+  ));
+  const groups = schedule.groups.map((group) => {
+    const effects = group.effects.filter((effect) => compilableNodeIds.has(effect.nodeId));
+    const durationMs = effects.some((effect) => effect.endMs === "indefinite") ? "indefinite" : Math.max(0, ...effects.map((effect) => effect.endMs));
+    return Object.freeze({
+      key: group.key,
+      clickBoundary: group.clickBoundary,
+      durationMs,
+      tracks: compileFragments(effects.flatMap((effect) => fragmentsForEffect(
+        effect,
+        frozenInitialState,
+        slide.nodes[effect.nodeId]
+      ))),
+      effects: Object.freeze(effects)
+    });
+  });
+  return Object.freeze({
+    slideIndex: slide.index,
+    schedule,
+    groups: Object.freeze(groups),
+    initialState: frozenInitialState
+  });
+}
+function segmentProgress(segment, positionMs) {
+  if (segment.endMs <= segment.startMs) return 1;
+  let progress = (positionMs - segment.startMs) / (segment.endMs - segment.startMs);
+  const easing = segment.easing?.match(/^pptx\(([^,]+),([^)]+)\)$/u);
+  if (easing) {
+    let acceleration = Math.max(0, Number(easing[1]) || 0);
+    let deceleration = Math.max(0, Number(easing[2]) || 0);
+    const total = acceleration + deceleration;
+    if (total > 1) {
+      acceleration /= total;
+      deceleration /= total;
+    }
+    const peak = 1 / (1 - (acceleration + deceleration) / 2);
+    if (acceleration > 0 && progress < acceleration) {
+      progress = peak * progress * progress / (2 * acceleration);
+    } else if (deceleration > 0 && progress > 1 - deceleration) {
+      progress = 1 - peak * (1 - progress) * (1 - progress) / (2 * deceleration);
+    } else progress = peak * (progress - acceleration / 2);
+  }
+  return Math.max(0, Math.min(1, progress));
+}
+function evaluateSegment(segment, positionMs) {
+  if (positionMs >= segment.endMs) return segment.to;
+  const progress = segmentProgress(segment, positionMs);
+  if (typeof segment.from === "number" && typeof segment.to === "number") {
+    return segment.from + (segment.to - segment.from) * progress;
+  }
+  if (typeof segment.from === "string" && typeof segment.to === "string") {
+    const fromInset = [...segment.from.matchAll(/-?\d+(?:\.\d+)?/gu)].map((match) => Number(match[0]));
+    const toInset = [...segment.to.matchAll(/-?\d+(?:\.\d+)?/gu)].map((match) => Number(match[0]));
+    if (segment.from.startsWith("inset(") && segment.to.startsWith("inset(") && fromInset.length === 4 && toInset.length === 4) {
+      return `inset(${fromInset.map((value, item) => `${value + (toInset[item] - value) * progress}%`).join(" ")})`;
+    }
+  }
+  return progress >= 1 ? segment.to : segment.from;
+}
+function evaluatePptxTrack(track, positionMs) {
+  if (track.repeatIndefinite && track.repeatPeriodMs && track.repeatStartMs !== void 0 && positionMs >= track.repeatStartMs) {
+    positionMs = track.repeatStartMs + (positionMs - track.repeatStartMs) % track.repeatPeriodMs;
+  }
+  const segments = track.segments;
+  if (segments?.length) {
+    const selected = segments.filter((segment) => {
+      if (positionMs < segment.startMs) return false;
+      if (positionMs < segment.endMs) return true;
+      return segment.fill !== "remove";
+    }).sort((left, right) => left.startMs - right.startMs || left.order - right.order).at(-1);
+    return selected ? evaluateSegment(selected, positionMs) : track.initialValue;
+  }
+  if (track.keyframes.length === 0 || positionMs < track.keyframes[0].timeMs) return track.initialValue;
+  let previous = track.keyframes[0];
+  for (let index = 1; index < track.keyframes.length; index += 1) {
+    const next = track.keyframes[index];
+    if (positionMs < next.timeMs) {
+      if (typeof previous.value === "number" && typeof next.value === "number" && next.timeMs > previous.timeMs) {
+        let progress = (positionMs - previous.timeMs) / (next.timeMs - previous.timeMs);
+        const easing = previous.easing?.match(/^pptx\(([^,]+),([^)]+)\)$/u);
+        if (easing) {
+          let acceleration = Math.max(0, Number(easing[1]) || 0);
+          let deceleration = Math.max(0, Number(easing[2]) || 0);
+          const total = acceleration + deceleration;
+          if (total > 1) {
+            acceleration /= total;
+            deceleration /= total;
+          }
+          const peak = 1 / (1 - (acceleration + deceleration) / 2);
+          if (acceleration > 0 && progress < acceleration) progress = peak * progress * progress / (2 * acceleration);
+          else if (deceleration > 0 && progress > 1 - deceleration) {
+            progress = 1 - peak * (1 - progress) * (1 - progress) / (2 * deceleration);
+          } else progress = peak * (progress - acceleration / 2);
+        }
+        return previous.value + (next.value - previous.value) * Math.max(0, Math.min(1, progress));
+      }
+      if (typeof previous.value === "string" && typeof next.value === "string") {
+        const fromInset = [...previous.value.matchAll(/-?\d+(?:\.\d+)?/gu)].map((match) => Number(match[0]));
+        const toInset = [...next.value.matchAll(/-?\d+(?:\.\d+)?/gu)].map((match) => Number(match[0]));
+        if (previous.value.startsWith("inset(") && next.value.startsWith("inset(") && fromInset.length === 4 && toInset.length === 4) {
+          const progress = Math.max(0, Math.min(1, (positionMs - previous.timeMs) / (next.timeMs - previous.timeMs)));
+          return `inset(${fromInset.map((value, item) => `${value + (toInset[item] - value) * progress}%`).join(" ")})`;
+        }
+      }
+      return previous.value;
+    }
+    previous = next;
+  }
+  return previous.value;
+}
+function evaluatePptxTriggerGroup(group, positionMs) {
+  const result = {};
+  for (const track of group.tracks) {
+    const target = track.paragraphRange ? `${track.objectKey}#paragraph:${track.paragraphRange.start}-${track.paragraphRange.end}` : track.objectKey;
+    const state = result[target] ?? {};
+    state[track.property] = evaluatePptxTrack(track, positionMs);
+    result[target] = state;
+  }
+  return Object.freeze(Object.fromEntries(
+    Object.entries(result).map(([key, value]) => [key, Object.freeze(value)])
+  ));
+}
+function mergeState(target, source) {
+  for (const [objectKey, values] of Object.entries(source)) {
+    target[objectKey] = { ...target[objectKey] ?? {}, ...values };
+  }
+}
+function rebuildPptxStateAtBoundary(compiled, clickBoundary) {
+  const result = Object.fromEntries(
+    Object.entries(compiled.initialState).map(([key, value]) => [key, { ...value }])
+  );
+  for (const group of compiled.groups) {
+    if (group.key !== "auto" && (!group.key.startsWith("click:") || group.clickBoundary > clickBoundary)) continue;
+    const position = group.durationMs === "indefinite" ? 0 : group.durationMs;
+    mergeState(result, evaluatePptxTriggerGroup(group, position));
+  }
+  return Object.freeze(Object.fromEntries(
+    Object.entries(result).map(([key, value]) => [key, Object.freeze(value)])
+  ));
+}
+
+// src/index.ts
+var DEFAULT_PPTX_PREVIEW_LIMITS = Object.freeze({
+  maxInputBytes: 50 * 1024 * 1024,
+  maxArchiveEntries: 4e3,
+  maxSingleEntryBytes: 32 * 1024 * 1024,
+  maxUncompressedBytes: 256 * 1024 * 1024,
+  maxMediaBytes: 192 * 1024 * 1024,
+  maxConcurrency: 8
+});
+
+export {
+  PptxPreviewError,
+  PptxPlaybackError,
+  createPptxCapabilityReport,
+  createPptxObjectKey,
+  matchPptxMorphObjects,
+  compilePptxSlideSchedule,
+  compilePptxSlideTracks,
+  evaluatePptxTrack,
+  evaluatePptxTriggerGroup,
+  rebuildPptxStateAtBoundary,
+  DEFAULT_PPTX_PREVIEW_LIMITS
+};