@arbidocs/blocks 0.5.120 → 0.5.121

package/dist/presentation/import-pptx.js

@@ -0,0 +1,659 @@
+"use client";
+import { SLIDE_POINTS } from "./boxes.js";
+import { STAGE_ASPECT } from "./model.js";
+import { DEFAULT_THEME } from "./theme.js";
+import {
+  EMU_PER_POINT,
+  Package,
+  boolAttr,
+  colorIn,
+  kid,
+  kids,
+  mediaDataUrl,
+  numAttr,
+  path,
+  readFill,
+  readLine,
+  readTheme,
+  relAttr,
+  typefaceOf
+} from "./pptx-xml.js";
+const IDENTITY = { sx: 1, sy: 1, ox: 0, oy: 0 };
+const TITLE_TYPES = /* @__PURE__ */ new Set(["title", "ctrTitle"]);
+const FOOTER_TYPES = /* @__PURE__ */ new Set(["dt", "ftr", "sldNum", "hdr"]);
+function placeholderOf(shape) {
+  const nv = kids(shape).find((child) => child.localName.startsWith("nv"));
+  const ph = path(nv, "nvPr", "ph");
+  if (!ph) return null;
+  return { type: ph.getAttribute("type") ?? "body", idx: ph.getAttribute("idx") };
+}
+function findPlaceholder(tree, ph, master) {
+  const shapes = kids(tree).filter((child) => child.localName === "sp");
+  const typeOf = (type) => master ? TITLE_TYPES.has(type) ? "title" : FOOTER_TYPES.has(type) ? type : "body" : type;
+  if (!master && ph.idx !== null) {
+    const byIdx = shapes.find((shape) => placeholderOf(shape)?.idx === ph.idx);
+    if (byIdx) return byIdx;
+  }
+  const wanted = typeOf(ph.type);
+  return shapes.find((shape) => {
+    const other = placeholderOf(shape);
+    return other !== null && typeOf(other.type) === wanted;
+  }) ?? null;
+}
+const ALIGN = { l: "left", ctr: "center", r: "right", just: "justify" };
+function readRunProps(rPr, theme) {
+  if (!rPr) return {};
+  const style = {};
+  if (rPr.hasAttribute("sz")) style.size = numAttr(rPr, "sz") / 100;
+  const b = boolAttr(rPr, "b");
+  if (b !== void 0) style.bold = b;
+  const i = boolAttr(rPr, "i");
+  if (i !== void 0) style.italic = i;
+  const u = rPr.getAttribute("u");
+  if (u) style.underline = u !== "none";
+  const fill = readFill(rPr, theme);
+  if (fill?.kind === "solid") style.color = fill.color;
+  else if (fill?.kind === "gradient") style.color = fill.from;
+  const font = typefaceOf(kid(rPr, "latin")?.getAttribute("typeface"), theme);
+  if (font) style.font = font;
+  return style;
+}
+function readLevel(pPr, theme) {
+  if (!pPr) return {};
+  const style = { ...readRunProps(kid(pPr, "defRPr"), theme) };
+  const algn = pPr.getAttribute("algn");
+  if (algn && ALIGN[algn]) style.align = ALIGN[algn];
+  if (kid(pPr, "buNone")) style.bullet = false;
+  else if (kid(pPr, "buChar") || kid(pPr, "buAutoNum") || kid(pPr, "buBlip")) style.bullet = true;
+  return style;
+}
+function merge(styles) {
+  const out = {};
+  for (const style of styles) {
+    for (const key of Object.keys(style)) {
+      if (out[key] === void 0 && style[key] !== void 0) {
+        ;
+        out[key] = style[key];
+      }
+    }
+  }
+  return out;
+}
+function levelStyle(chain, level, theme) {
+  return merge(chain.map((list) => readLevel(kid(list, `lvl${level + 1}pPr`), theme)));
+}
+const note = (deck, text) => deck.notes.set(text, (deck.notes.get(text) ?? 0) + 1);
+function hash(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36);
+}
+async function mediaKey(deck, part) {
+  if (deck.mediaKeys.has(part)) return deck.mediaKeys.get(part) ?? null;
+  const url = await mediaDataUrl(deck.pkg, part);
+  const key = url ? `m${hash(url)}` : null;
+  if (url && key) deck.media[key] = url;
+  deck.mediaKeys.set(part, key);
+  return key;
+}
+function areaOf(xfrm, transform) {
+  const off = kid(xfrm, "off");
+  const ext = kid(xfrm, "ext");
+  if (!off || !ext) return null;
+  return {
+    x: transform.ox + numAttr(off, "x") * transform.sx,
+    y: transform.oy + numAttr(off, "y") * transform.sy,
+    w: numAttr(ext, "cx") * transform.sx,
+    h: numAttr(ext, "cy") * transform.sy,
+    rotation: numAttr(xfrm, "rot") / 6e4,
+    flipH: boolAttr(xfrm, "flipH") === true,
+    flipV: boolAttr(xfrm, "flipV") === true
+  };
+}
+function stageFrame(deck, area) {
+  const { cx, cy } = deck.slideSize;
+  const { place } = deck;
+  return {
+    x: place.x + area.x / cx * place.w,
+    y: place.y + area.y / cy * place.h,
+    w: area.w / cx * place.w,
+    h: area.h / cy * place.h
+  };
+}
+const hexOf = (color) => color.hex;
+function renditionClip(deck, part, area, what) {
+  const { documentId, version, fileName } = deck.options;
+  if (!documentId || part.page === null) {
+    note(deck, `${what} could not be shown`);
+    return null;
+  }
+  const { cx, cy } = deck.slideSize;
+  const clamp = (v) => Math.min(1, Math.max(0, v));
+  const x = clamp(area.x / cx);
+  const y = clamp(area.y / cy);
+  const rect = { x, y, w: clamp((area.x + area.w) / cx) - x, h: clamp((area.y + area.h) / cy) - y };
+  if (rect.w <= 0 || rect.h <= 0) return null;
+  const frame = stageFrame(deck, area);
+  note(deck, `${what} shown as a picture`);
+  deck.clips.push({
+    kind: "pdf",
+    documentId,
+    ...version !== void 0 ? { version } : {},
+    fileName: fileName ?? "Presentation.pptx",
+    page: part.page,
+    rect,
+    aspect: frame.w * STAGE_ASPECT / Math.max(frame.h, 1e-6),
+    caption: "",
+    plain: true
+  });
+  return deck.clips.length - 1;
+}
+function readParagraphs(body, chain, deck, defaults, fontScale, fallback = []) {
+  const { theme } = deck;
+  const paragraphs = [];
+  for (const p of kids(body, "p")) {
+    const pPr = kid(p, "pPr");
+    const level = Math.min(8, numAttr(pPr, "lvl"));
+    const own = readLevel(pPr, theme);
+    const style = merge([
+      own,
+      levelStyle(chain, level, theme),
+      defaults.color ? { color: defaults.color } : {},
+      levelStyle(fallback, level, theme)
+    ]);
+    const runStyle = (rPr) => {
+      const s = merge([readRunProps(rPr, theme), style]);
+      const color = s.color ?? defaults.base;
+      return {
+        text: "",
+        size: Math.round((s.size ?? 18) * fontScale * deck.pointScale * 10) / 10,
+        ...s.bold ? { bold: true } : {},
+        ...s.italic ? { italic: true } : {},
+        ...s.underline ? { underline: true } : {},
+        ...color ? { color: hexOf(color) } : {},
+        font: s.font ?? theme.minorFont
+      };
+    };
+    const shape = (runs2) => ({
+      runs: runs2,
+      ...style.align && style.align !== "left" ? { align: style.align } : {},
+      ...level ? { level } : {},
+      ...style.bullet && runs2.some((run) => run.text.trim()) ? { bullet: true } : {}
+    });
+    let runs = [];
+    for (const child of kids(p)) {
+      if (child.localName === "r" || child.localName === "fld") {
+        const text = kid(child, "t")?.textContent ?? "";
+        runs.push({ ...runStyle(kid(child, "rPr")), text });
+      } else if (child.localName === "br") {
+        paragraphs.push(shape(runs.length ? runs : [{ ...runStyle(kid(child, "rPr")), text: "" }]));
+        runs = [];
+      }
+    }
+    if (!runs.length) runs = [{ ...runStyle(kid(p, "endParaRPr")), text: "" }];
+    paragraphs.push(shape(runs));
+  }
+  while (paragraphs.length > 1 && !paragraphs[paragraphs.length - 1].runs.some((run) => run.text.trim())) {
+    paragraphs.pop();
+  }
+  return paragraphs;
+}
+const SHAPES = {
+  rect: "rect",
+  flowChartProcess: "rect",
+  snip1Rect: "rect",
+  roundRect: "roundRect",
+  round1Rect: "roundRect",
+  round2SameRect: "roundRect",
+  flowChartAlternateProcess: "roundRect",
+  ellipse: "ellipse",
+  flowChartConnector: "ellipse",
+  line: "line",
+  straightConnector1: "line"
+};
+async function readShape(shape, transform, deck, part, inherit, built) {
+  const { theme } = deck;
+  const name = shape.localName;
+  if (name === "AlternateContent") {
+    const choice = kid(shape, "Fallback") ?? kid(shape, "Choice");
+    for (const child of kids(choice)) await readShape(child, transform, deck, part, inherit, built);
+    return;
+  }
+  if (name === "grpSp") {
+    const xfrm2 = path(shape, "grpSpPr", "xfrm");
+    const off = kid(xfrm2, "off");
+    const ext = kid(xfrm2, "ext");
+    const chOff = kid(xfrm2, "chOff");
+    const chExt = kid(xfrm2, "chExt");
+    let inner = transform;
+    if (off && ext && chOff && chExt) {
+      const sx = numAttr(chExt, "cx") ? numAttr(ext, "cx") / numAttr(chExt, "cx") : 1;
+      const sy = numAttr(chExt, "cy") ? numAttr(ext, "cy") / numAttr(chExt, "cy") : 1;
+      inner = {
+        sx: transform.sx * sx,
+        sy: transform.sy * sy,
+        ox: transform.ox + (numAttr(off, "x") - numAttr(chOff, "x") * sx) * transform.sx,
+        oy: transform.oy + (numAttr(off, "y") - numAttr(chOff, "y") * sy) * transform.sy
+      };
+    }
+    for (const child of kids(shape)) await readShape(child, inner, deck, part, inherit, built);
+    return;
+  }
+  const ph = name === "sp" || name === "pic" ? placeholderOf(shape) : null;
+  if (ph && !inherit) return;
+  if (ph && FOOTER_TYPES.has(ph.type)) return;
+  const layoutPh = ph && inherit ? findPlaceholder(inherit.layoutTree, ph, false) : null;
+  const masterPh = ph && inherit ? findPlaceholder(inherit.masterTree, ph, true) : null;
+  const spPr = kid(shape, name === "graphicFrame" ? "xfrm" : "spPr");
+  const xfrm = name === "graphicFrame" ? kid(shape, "xfrm") : kid(spPr, "xfrm") ?? path(layoutPh, "spPr", "xfrm") ?? path(masterPh, "spPr", "xfrm");
+  const area = areaOf(xfrm, transform);
+  if (!area) return;
+  if (name === "pic") {
+    const blipFill = kid(shape, "blipFill");
+    const embed = relAttr(kid(blipFill, "blip"), "embed");
+    const target = embed ? (await deck.pkg.relationships(part.part)).get(embed) : void 0;
+    const key = target && !target.external ? await mediaKey(deck, target.target) : null;
+    if (!key || Math.abs(area.rotation) > 0.5 || area.flipH || area.flipV) {
+      const clip = renditionClip(deck, part, area, "A picture");
+      if (clip !== null) {
+        const frame2 = stageFrame(deck, area);
+        built.items.push({ clip, frame: frame2, after: built.boxes.length });
+      }
+      return;
+    }
+    const src = kid(blipFill, "srcRect");
+    const l = numAttr(src, "l") / 1e5;
+    const t = numAttr(src, "t") / 1e5;
+    const r = numAttr(src, "r") / 1e5;
+    const b = numAttr(src, "b") / 1e5;
+    const rect = {
+      x: Math.max(0, l),
+      y: Math.max(0, t),
+      w: Math.min(1, 1 - r) - Math.max(0, l),
+      h: Math.min(1, 1 - b) - Math.max(0, t)
+    };
+    if (rect.w <= 0 || rect.h <= 0) return;
+    if (kid(path(shape, "nvPicPr", "nvPr"), "videoFile")) note(deck, "A video shown as its picture");
+    const frame = stageFrame(deck, area);
+    deck.clips.push({
+      kind: "image",
+      documentId: "",
+      fileName: target?.target.split("/").pop() ?? "Picture",
+      page: 1,
+      rect,
+      aspect: frame.w * STAGE_ASPECT / Math.max(frame.h, 1e-6),
+      caption: "",
+      media: key,
+      plain: true
+    });
+    built.items.push({ clip: deck.clips.length - 1, frame, after: built.boxes.length });
+    return;
+  }
+  if (name === "graphicFrame") {
+    const data = path(shape, "graphic", "graphicData");
+    const table = kid(data, "tbl");
+    if (table) {
+      readTable(table, area, deck, built);
+      return;
+    }
+    const uri = data?.getAttribute("uri") ?? "";
+    const what = uri.includes("chart") ? "A chart" : uri.includes("diagram") ? "A SmartArt graphic" : "An embedded object";
+    const clip = renditionClip(deck, part, area, what);
+    if (clip !== null)
+      built.items.push({ clip, frame: stageFrame(deck, area), after: built.boxes.length });
+    return;
+  }
+  if (name !== "sp" && name !== "cxnSp") return;
+  const style = kid(shape, "style");
+  const prst = path(spPr, "prstGeom")?.getAttribute("prst") ?? (kid(spPr, "custGeom") ? "custom" : "rect");
+  let fill = readFill(spPr, theme);
+  const fillRef = kid(style, "fillRef");
+  if (!fill && fillRef && numAttr(fillRef, "idx") > 0) {
+    const color = colorIn(fillRef, theme);
+    if (color) fill = { kind: "solid", color };
+  }
+  if (!fill && ph)
+    fill = readFill(kid(layoutPh, "spPr"), theme) ?? readFill(kid(masterPh, "spPr"), theme);
+  let line = readLine(kid(spPr, "ln"), theme);
+  const lnRef = kid(style, "lnRef");
+  if (line === void 0 && lnRef && numAttr(lnRef, "idx") > 0) {
+    const color = colorIn(lnRef, theme);
+    if (color)
+      line = { color, width: theme.lineWidths[numAttr(lnRef, "idx") - 1] ?? 0.75, dash: false };
+  }
+  if (line === void 0 && name === "cxnSp") line = null;
+  const body = kid(shape, "txBody");
+  const bodyPr = kid(body, "bodyPr");
+  const inheritedBodyPr = [
+    bodyPr,
+    path(layoutPh, "txBody", "bodyPr"),
+    path(masterPh, "txBody", "bodyPr")
+  ];
+  const category = !ph ? "otherStyle" : TITLE_TYPES.has(ph.type) ? "titleStyle" : "bodyStyle";
+  const chain = [
+    kid(body, "lstStyle"),
+    path(layoutPh, "txBody", "lstStyle"),
+    path(masterPh, "txBody", "lstStyle"),
+    ph ? kid(inherit?.masterTxStyles, category) : null
+  ];
+  const fontRef = kid(style, "fontRef");
+  const tx1 = theme.scheme[theme.map.tx1 ?? "dk1"];
+  const fontScale = numAttr(kid(bodyPr, "normAutofit"), "fontScale", 1e5) / 1e5;
+  const paragraphs = body ? readParagraphs(
+    body,
+    chain,
+    deck,
+    {
+      color: colorIn(fontRef, theme) ?? void 0,
+      base: tx1 ? { hex: `#${tx1}`, alpha: 1 } : void 0
+    },
+    fontScale,
+    [deck.defaultText]
+  ) : [];
+  const hasText = paragraphs.some((p) => p.runs.some((run) => run.text.trim()));
+  const visibleFill = fill && fill.kind !== "none" && fill.kind !== "image";
+  if (!hasText && !visibleFill && !line && fill?.kind !== "image") return;
+  let shapeKind = SHAPES[prst] ?? (name === "cxnSp" ? "line" : "rect");
+  const exotic = !SHAPES[prst] && name !== "cxnSp";
+  if (exotic && (visibleFill || line) || fill?.kind === "image") {
+    const clip = renditionClip(deck, part, area, exotic ? "A shape" : "A picture fill");
+    if (clip !== null) {
+      built.items.push({ clip, frame: stageFrame(deck, area), after: built.boxes.length });
+      if (!hasText) return;
+      fill = null;
+      line = null;
+      shapeKind = "text";
+    }
+  }
+  if (shapeKind === "rect" && !visibleFill && !line) shapeKind = "text";
+  const anchorOf = (value) => value === "ctr" ? "middle" : value === "b" ? "bottom" : value === "t" ? "top" : void 0;
+  const anchor = inheritedBodyPr.map((pr) => anchorOf(pr?.getAttribute("anchor"))).find(Boolean) ?? (ph && TITLE_TYPES.has(ph.type) ? "middle" : "top");
+  const insetPr = inheritedBodyPr.find((pr) => pr?.hasAttribute("lIns"));
+  const inset = numAttr(insetPr, "lIns", 91440) / EMU_PER_POINT;
+  const shapeName = path(shape, "nvSpPr", "cNvPr")?.getAttribute("name") ?? "";
+  const role = ph ? TITLE_TYPES.has(ph.type) ? "title" : "body" : shapeName === "ARBI title" ? "title" : shapeName === "ARBI body" ? "body" : void 0;
+  const box = {
+    frame: stageFrame(deck, area),
+    shape: shapeKind,
+    paragraphs: hasText ? paragraphs : [],
+    ...Math.abs(area.rotation) > 0.01 ? { rotation: area.rotation } : {},
+    ...area.flipH ? { flipH: true } : {},
+    ...area.flipV ? { flipV: true } : {},
+    ...fill?.kind === "solid" ? { fill: fill.color.hex, ...fill.color.alpha < 1 ? { fillAlpha: fill.color.alpha } : {} } : fill?.kind === "gradient" ? { fill: fill.from.hex } : {},
+    ...line ? { line: { color: line.color.hex, width: line.width, ...line.dash ? { dash: true } : {} } } : {},
+    ...anchor !== "top" ? { anchor } : {},
+    ...Math.abs(inset - 7.2) > 0.05 ? { inset: inset * deck.pointScale } : {},
+    ...role ? { role } : {}
+  };
+  built.boxes.push(box);
+}
+function readTable(table, area, deck, built) {
+  const { theme } = deck;
+  const tblPr = kid(table, "tblPr");
+  const styled = !!kid(tblPr, "tableStyleId");
+  const firstRow = boolAttr(tblPr, "firstRow") === true;
+  const banded = boolAttr(tblPr, "bandRow") === true;
+  const accent = `#${theme.scheme.accent1 ?? "4472c4"}`;
+  const tint = (hex, amount) => `#${[1, 3, 5].map(
+    (i) => Math.round(255 - (255 - parseInt(hex.slice(i, i + 2), 16)) * amount).toString(16).padStart(2, "0")
+  ).join("")}`;
+  const columns = kids(kid(table, "tblGrid"), "gridCol").map((col) => numAttr(col, "w"));
+  const totalW = columns.reduce((sum, w) => sum + w, 0) || area.w;
+  const rows = kids(table, "tr");
+  const totalH = rows.reduce((sum, row) => sum + numAttr(row, "h"), 0) || area.h;
+  const scaleY = area.h / totalH;
+  let y = area.y;
+  rows.forEach((row, r) => {
+    const h = numAttr(row, "h") * scaleY;
+    let x = area.x;
+    let c = 0;
+    for (const cell of kids(row, "tc")) {
+      const span = Math.max(1, numAttr(cell, "gridSpan", 1));
+      const w = columns.slice(c, c + span).reduce((sum, cw) => sum + cw, 0) * (area.w / totalW);
+      c += span;
+      if (boolAttr(cell, "hMerge") || boolAttr(cell, "vMerge")) {
+        x += w;
+        continue;
+      }
+      const rowSpan = Math.max(1, numAttr(cell, "rowSpan", 1));
+      const cellH = rows.slice(r, r + rowSpan).reduce((sum, rr) => sum + numAttr(rr, "h") * scaleY, 0);
+      const tcPr = kid(cell, "tcPr");
+      const own = readFill(tcPr, theme);
+      const header = styled && firstRow && r === 0;
+      const fill = own?.kind === "solid" ? own.color.hex : own?.kind === "none" ? void 0 : styled ? header ? accent : banded && (r - (firstRow ? 1 : 0)) % 2 === 0 ? tint(accent, 0.2) : tint(accent, 0.1) : void 0;
+      const text = readParagraphs(
+        kid(cell, "txBody"),
+        // The table's style sets its text colour, over the deck's default text.
+        [kid(kid(cell, "txBody"), "lstStyle")],
+        deck,
+        {
+          color: {
+            hex: header ? "#ffffff" : `#${theme.scheme[theme.map.tx1 ?? "dk1"] ?? "000000"}`,
+            alpha: 1
+          }
+        },
+        1
+      ).map((p) => header ? { ...p, runs: p.runs.map((run) => ({ ...run, bold: true })) } : p);
+      const border = readLine(kid(tcPr, "lnB"), theme) ?? readLine(kid(tcPr, "lnT"), theme);
+      built.boxes.push({
+        frame: stageFrame(deck, { x, y, w, h: cellH }),
+        shape: fill || border || styled ? "rect" : "text",
+        paragraphs: text,
+        ...fill ? { fill } : {},
+        ...border ? { line: { color: border.color.hex, width: border.width } } : styled ? { line: { color: "#ffffff", width: 1 } } : {},
+        anchor: tcPr?.getAttribute("anchor") === "ctr" ? "middle" : "top",
+        inset: 7.2 * deck.pointScale
+      });
+      x += w;
+    }
+    y += h;
+  });
+}
+async function readBackground(bg, deck, part) {
+  if (!bg) return null;
+  const bgPr = kid(bg, "bgPr");
+  const bgRef = kid(bg, "bgRef");
+  const fill = bgPr ? readFill(bgPr, deck.theme) : null;
+  if (fill?.kind === "solid") return { color: fill.color.hex };
+  if (fill?.kind === "gradient") {
+    return { gradient: { from: fill.from.hex, to: fill.to.hex, angle: fill.angle } };
+  }
+  if (fill?.kind === "image") {
+    const target = (await deck.pkg.relationships(part)).get(fill.embed);
+    const key = target && !target.external ? await mediaKey(deck, target.target) : null;
+    return key ? { image: key } : null;
+  }
+  if (bgRef) {
+    const color = colorIn(bgRef, deck.theme);
+    if (color) return { color: color.hex };
+  }
+  return null;
+}
+async function slideParts(pkg) {
+  const pres = await pkg.xml("ppt/presentation.xml");
+  const rels = await pkg.relationships("ppt/presentation.xml");
+  const parts = [];
+  for (const id of kids(kid(pres?.documentElement, "sldIdLst"), "sldId")) {
+    const rel = rels.get(relAttr(id, "id") ?? "");
+    if (!rel) continue;
+    const slide = await pkg.xml(rel.target);
+    parts.push({ part: rel.target, hidden: slide?.documentElement.getAttribute("show") === "0" });
+  }
+  return parts;
+}
+async function speakerNotes(pkg, part) {
+  const notesPart = await pkg.related(part, "/notesSlide");
+  const doc = notesPart ? await pkg.xml(notesPart) : null;
+  const tree = path(doc?.documentElement, "cSld", "spTree");
+  for (const shape of kids(tree, "sp")) {
+    const ph = placeholderOf(shape);
+    if (ph?.type !== "body") continue;
+    return kids(kid(shape, "txBody"), "p").map(
+      (p) => kids(p).filter((child) => child.localName === "r" || child.localName === "fld").map((run) => kid(run, "t")?.textContent ?? "").join("")
+    ).join("\n").trim();
+  }
+  return "";
+}
+const JSZIP = () => import("jszip").then((module) => module.default);
+async function importPptx(bytes, options = {}) {
+  const JSZip = await JSZIP();
+  const pkg = new Package(await JSZip.loadAsync(bytes));
+  const pres = await pkg.xml("ppt/presentation.xml");
+  if (!pres) throw new Error("This file is not a PowerPoint presentation.");
+  const size = kid(pres.documentElement, "sldSz");
+  const cx = numAttr(size, "cx", 12192e3);
+  const cy = numAttr(size, "cy", 6858e3);
+  const deckAspect = cx / cy;
+  const place = deckAspect < STAGE_ASPECT ? { w: deckAspect / STAGE_ASPECT, h: 1, x: (1 - deckAspect / STAGE_ASPECT) / 2, y: 0 } : { w: 1, h: STAGE_ASPECT / deckAspect, x: 0, y: (1 - STAGE_ASPECT / deckAspect) / 2 };
+  const slides = await slideParts(pkg);
+  const firstLayout = slides.length ? await pkg.related(slides[0].part, "/slideLayout") : null;
+  const firstMaster = firstLayout ? await pkg.related(firstLayout, "/slideMaster") : null;
+  const deck = {
+    pkg,
+    theme: firstMaster ? await readTheme(pkg, firstMaster) : { scheme: {}, map: {}, majorFont: "Calibri", minorFont: "Calibri", lineWidths: [] },
+    slideSize: { cx, cy },
+    place,
+    pointScale: SLIDE_POINTS.h * place.h / (cy / EMU_PER_POINT),
+    defaultText: kid(pres.documentElement, "defaultTextStyle"),
+    options,
+    clips: [],
+    media: {},
+    mediaKeys: /* @__PURE__ */ new Map(),
+    notes: /* @__PURE__ */ new Map()
+  };
+  const saved = [];
+  let page = 0;
+  for (const { part, hidden } of slides) {
+    if (!hidden) page += 1;
+    const layout = await pkg.related(part, "/slideLayout");
+    const master = layout ? await pkg.related(layout, "/slideMaster") : null;
+    if (master && master !== firstMaster) deck.theme = await readTheme(pkg, master);
+    const slideDoc = await pkg.xml(part);
+    const layoutDoc = layout ? await pkg.xml(layout) : null;
+    const masterDoc = master ? await pkg.xml(master) : null;
+    const tree = (doc) => path(doc?.documentElement, "cSld", "spTree");
+    const built = { boxes: [], items: [] };
+    const partContext = { part, page: hidden ? null : page };
+    const showMaster = (doc) => doc?.documentElement.getAttribute("showMasterSp") !== "0";
+    if (masterDoc && showMaster(slideDoc) && showMaster(layoutDoc)) {
+      for (const shape of kids(tree(masterDoc))) {
+        await readShape(
+          shape,
+          IDENTITY,
+          deck,
+          { part: master, page: partContext.page },
+          null,
+          built
+        );
+      }
+    }
+    if (layoutDoc && showMaster(slideDoc)) {
+      for (const shape of kids(tree(layoutDoc))) {
+        await readShape(
+          shape,
+          IDENTITY,
+          deck,
+          { part: layout, page: partContext.page },
+          null,
+          built
+        );
+      }
+    }
+    const inherit = {
+      layoutTree: tree(layoutDoc),
+      masterTree: tree(masterDoc),
+      masterTxStyles: kid(masterDoc?.documentElement, "txStyles")
+    };
+    for (const shape of kids(tree(slideDoc))) {
+      await readShape(shape, IDENTITY, deck, partContext, inherit, built);
+    }
+    const bg = await readBackground(path(slideDoc?.documentElement, "cSld", "bg"), deck, part) ?? (layout ? await readBackground(path(layoutDoc?.documentElement, "cSld", "bg"), deck, layout) : null) ?? (master ? await readBackground(path(masterDoc?.documentElement, "cSld", "bg"), deck, master) : null) ?? {
+      color: "#ffffff"
+    };
+    if (hidden) note(deck, "A hidden slide");
+    const firstClipAt = built.items.length ? Math.min(...built.items.map((item) => item.after)) : Infinity;
+    const boxes = built.boxes.map(
+      (box, index) => index >= firstClipAt ? { ...box, front: true } : box
+    );
+    const title = boxes.find((box) => box.role === "title");
+    const notes = await speakerNotes(pkg, part);
+    saved.push({
+      caption: title ? title.paragraphs.map((p) => p.runs.map((run) => run.text).join("")).join(" ").replace(/\s+/g, " ").trim() : "",
+      auto: false,
+      layout: "free",
+      items: built.items.map(({ clip, frame }) => ({
+        clip,
+        frame: { x: frame.x, y: frame.y, w: frame.w }
+      })),
+      boxes,
+      background: bg,
+      ...notes ? { notes } : {}
+    });
+  }
+  for (const part of Object.keys(pkg.zip.files)) {
+    if (/^ppt\/slides\/slide\d+\.xml$/.test(part)) {
+      const xml = await pkg.zip.file(part).async("string");
+      if (/<p:timing\b/.test(xml)) {
+        note(deck, "Animations are not kept");
+        break;
+      }
+    }
+  }
+  const core = await pkg.xml("docProps/core.xml");
+  const coreTitle = Array.from(core?.documentElement.childNodes ?? []).find(
+    (node) => node instanceof Element && node.localName === "title"
+  )?.textContent;
+  return {
+    saved: {
+      format: "arbi-presentation",
+      version: 1,
+      title: options.title ?? (coreTitle?.trim() || "Presentation"),
+      captions: false,
+      theme: DEFAULT_THEME,
+      clips: deck.clips,
+      slides: saved,
+      ...Object.keys(deck.media).length ? { media: deck.media } : {}
+    },
+    notes: [...deck.notes.entries()].map(
+      ([text, count]) => count > 1 && !text.startsWith("Animations") ? `${text} (${count})` : text
+    ),
+    fingerprints: await fingerprintsOf(pkg, slides)
+  };
+}
+async function fingerprintsOf(pkg, slides) {
+  const out = [];
+  for (const { part } of slides) {
+    const doc = await pkg.xml(part);
+    const tree = path(doc?.documentElement, "cSld", "spTree");
+    const parts = [];
+    const visit = (element) => {
+      for (const child of kids(element)) {
+        const name = child.localName;
+        if (name === "t") parts.push(child.textContent ?? "");
+        else if (name === "off") {
+          parts.push(
+            `@${Math.round(numAttr(child, "x") / 12e4)},${Math.round(numAttr(child, "y") / 68e3)}`
+          );
+        } else if (name === "blip") parts.push("pic");
+        else visit(child);
+      }
+    };
+    if (tree) visit(tree);
+    parts.push(`notes:${await speakerNotes(pkg, part)}`);
+    out.push(hash(parts.join("|").replace(/\s+/g, " ")));
+  }
+  return out;
+}
+async function slideFingerprints(bytes) {
+  const JSZip = await JSZIP();
+  const pkg = new Package(await JSZip.loadAsync(bytes));
+  return fingerprintsOf(pkg, await slideParts(pkg));
+}
+export {
+  importPptx,
+  slideFingerprints
+};
+//# sourceMappingURL=import-pptx.js.map