@openpresentation/opf-pptx 0.14.0 → 0.15.0

package/dist/script-fonts.js

@@ -6,7 +6,12 @@
 //
 // When the resolver throws for a deck, the exporter writes what it wrote before FF-07 (lang="en-US", empty theme ea/cs, no
 // rtl) and reports `language-export-unavailable`.
-import {paragraphDirection, physicalAlignment, resolveScriptFonts as resolver} from "@openpresentation/opf/composition";
+import {paragraphDirection, physicalAlignment, resolveScriptFonts as coreResolveScriptFonts} from "@openpresentation/opf/composition";
+
+// OPF 0.15 (FA-23): core resolves the font-scheme references a deck or a language object names against the document's
+// catalogs and the host's registered `catalogs` (Catalog[]), the same option the slide context takes. `catalogs` is passed
+// only when the host gave one, so core's own default applies otherwise.
+const resolver = (input, options = {}, catalogs = undefined) => coreResolveScriptFonts(input, catalogs === undefined ? options : {...options, catalogs});
 
 // RR-05: authored alignment is logical for right-to-left text (`left` is the start edge). Core owns the rule, and the
 // paragraph-direction rule is the one the renderer shares (core FF-07).
@@ -18,12 +23,12 @@ const SCRIPT_SLOTS = [["ea", "eastAsian"], ["cs", "complexScript"]];
  * Resolve the deck (slide 0, which also sets the theme) and every slide.
  * Returns null when the resolver throws for the deck.
  */
-export function planScriptFonts(presentation, report) {
+export function planScriptFonts(presentation, report, {catalogs} = {}) {
   const count = Array.isArray(presentation.slides) ? presentation.slides.length : 0;
   let slides, deck;
   try {
-    slides = Array.from({length: count}, (_, slideIndex) => resolver(presentation, {slideIndex}));
-    deck = slides[0] ?? resolver(presentation);
+    slides = Array.from({length: count}, (_, slideIndex) => resolver(presentation, {slideIndex}, catalogs));
+    deck = slides[0] ?? resolver(presentation, {}, catalogs);
   } catch (error) {
     // Keep exporting as before FF-07 rather than failing on the language model.
     report?.({code: "language-export-unavailable", path: "language",
@@ -32,11 +37,11 @@ export function planScriptFonts(presentation, report) {
   }
   if (presentation.language !== undefined && deck.languageSource === "default") {
     report?.({code: "language-unresolved", path: "language",
-      message: `The presentation language could not be resolved locally (a URL, pkg: reference or unknown id), so the PPTX uses ${deck.lang}.`});
+      message: `The presentation language could not be resolved (a BCP-47 tag whose script core does not know), so the PPTX uses ${deck.lang}.`});
   }
   // opf-pptx#168: which slides have notes (a presentation has one notes master; see reportPerSlideNotesScriptFonts).
   const notes = (presentation.slides ?? []).map(slide => typeof slide?.notes === "string" ? slide.notes.trim() !== "" : Boolean(slide?.notes));
-  return {deck, slides, notes, report, lang: deck.lang, rtl: deck.rtl, presentation, contentEastAsian: contentEastAsianFonts(presentation, deck, report)};
+  return {deck, slides, notes, report, lang: deck.lang, rtl: deck.rtl, presentation, catalogs, contentEastAsian: contentEastAsianFonts(presentation, deck, report, catalogs)};
 }
 
 /**
@@ -50,7 +55,7 @@ export function runLanguageTag(plan, tag) {
   if (!cache.has(tag)) {
     let lang = tag;
     try {
-      const resolved = resolver(plan.presentation, {language: tag});
+      const resolved = resolver(plan.presentation, {language: tag}, plan.catalogs);
       if (resolved.languageSource !== "default") lang = resolved.lang;
     } catch { /* an unresolvable tag is written as given */ }
     cache.set(tag, lang.toLowerCase() === String(plan.lang).toLowerCase() ? undefined : lang);
@@ -87,7 +92,7 @@ function runScriptPlan(plan, slideIndex, lang) {
   const cache = plan.runScripts ??= new Map(), key = `${slideIndex}|${lang}`;
   if (!cache.has(key)) {
     let resolved;
-    try { resolved = resolver(plan.presentation, {slideIndex, language: lang}); } catch { resolved = undefined; }
+    try { resolved = resolver(plan.presentation, {slideIndex, language: lang}, plan.catalogs); } catch { resolved = undefined; }
     cache.set(key, resolved && resolved.languageSource !== "default" ? resolved : undefined);
   }
   return cache.get(key);
@@ -193,7 +198,7 @@ export function reportPerSlideNotesScriptFonts(plan, {themes, assignment}) {
 // script of the text picks the language core resolves it for: kana is Japanese, hangul Korean, Han alone Simplified
 // Chinese. Returns {heading, body} families, or null when the deck language already selects one or the text has none.
 const KANA = /[\p{Script=Hiragana}\p{Script=Katakana}]/u, HANGUL = /\p{Script=Hangul}/u, HAN = /\p{Script=Han}/u;
-function contentEastAsianFonts(presentation, deck, report) {
+function contentEastAsianFonts(presentation, deck, report, catalogs) {
   if (deck.sources.eastAsian !== "latin") return null;
   let kana = false, hangul = false, han = false;
   const seen = new Set();
@@ -206,10 +211,10 @@ function contentEastAsianFonts(presentation, deck, report) {
     }
   };
   walk(presentation.slides);
-  const language = kana ? "japanese" : hangul ? "korean" : han ? "chinese-simplified" : null;
+  const language = kana ? "ja" : hangul ? "ko" : han ? "zh-Hans" : null;
   if (!language) return null;
   try {
-    const resolved = resolver({...presentation, language}, {slideIndex: 0});
+    const resolved = resolver({...presentation, language}, {slideIndex: 0}, catalogs);
     return resolved.sources.eastAsian === "latin" ? null : {heading: resolved.heading.eastAsian, body: resolved.body.eastAsian};
   } catch (error) {
     report?.({code: "language-export-unavailable", path: "language",
@@ -425,36 +430,14 @@ export function partScriptFonts(path, xml, plan, slideIndex) {
 const LANGUAGE_TAG = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/;
 const attribute = (xml, name) => new RegExp(`\\s${name}="([^"]*)"`).exec(xml)?.[1];
 
-/**
- * Match an OOXML run language to the OPF language to import. A catalog id is
- * used when that record exports exactly this tag again: an exact BCP-47 tag,
- * then a curated `ooxmlLang` (preferring the same primary language). A tag
- * that core still resolves to a catalog record (for example en-NZ to English)
- * is imported as the tag itself, so it round-trips.
- * Returns {language, record, shared} or null when nothing matches.
- */
-export function matchCatalogLanguage(lang, catalogs) {
-  const records = Array.isArray(catalogs?.languages) ? catalogs.languages : [];
-  const key = lang.toLowerCase(), primary = key.split("-")[0];
-  const lower = value => typeof value === "string" ? value.toLowerCase() : undefined;
-  const shared = records.filter(record => lower(record.bcp47) === key || lower(record.ooxmlLang) === key);
-  const exports = record => resolver({language: record.id}).lang.toLowerCase() === key;
-  const record = shared.find(record => lower(record.bcp47) === key && exports(record))
-    ?? shared.find(record => lower(record.bcp47)?.split("-")[0] === primary && exports(record))
-    ?? shared.find(exports);
-  if (record) return {language: record.id, record, shared};
-  const resolved = resolver({language: lang});
-  // A tag core cannot resolve falls back to its default language; that is no match.
-  const matched = resolved.languageSource !== "default" && resolved.languageId && records.find(candidate => candidate.id === resolved.languageId);
-  return matched ? {language: lang, record: matched, shared: []} : null;
-}
-
 /**
  * Observe the presentation language in run `lang`. `slides` and `theme` are
- * XML strings. `language` is a catalog id, the run's tag when no catalog
- * record matches, or undefined when the runs carry no language; `lang` is the
- * dominant run tag itself. Nothing is reported here: languageDiagnostics()
- * reports against the final imported document, after FF-32 provenance.
+ * XML strings. `language` is the dominant run tag, imported as a BCP-47 tag
+ * string (OPF 0.15: language is an engine vocabulary, not a catalog), or
+ * undefined when the runs carry no language; `lang` is the same tag.
+ * `catalogs` are the host's registered catalogs, for the font schemes core
+ * resolves. Nothing is reported here: languageDiagnostics() reports against
+ * the final imported document, after FF-32 provenance.
  */
 export function observeLanguage({slides, theme, themePath, slideThemes, catalogs}) {
   const counts = new Map();
@@ -469,8 +452,7 @@ export function observeLanguage({slides, theme, themePath, slideThemes, catalogs
   }
   const ranked = [...counts].sort((left, right) => right[1] - left[1] || (left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0));
   const lang = ranked[0]?.[0];
-  const match = lang === undefined ? null : matchCatalogLanguage(lang, catalogs);
-  return {lang, language: lang === undefined ? undefined : match?.language ?? lang, match, ranked, rtlParagraphs, theme, themePath, slideThemes};
+  return {lang, language: lang, ranked, rtlParagraphs, theme, themePath, slideThemes, catalogs};
 }
 
 /**
@@ -485,29 +467,27 @@ export function reconcileLanguage(groups, observed, report) {
   if (index < 0 || observed.lang === undefined) return groups;
   const stored = groups[index].ops.find(op => op.path?.length === 1 && op.path[0] === "language")?.value;
   if (stored === undefined) return groups;
-  const resolved = resolver({language: stored});
+  const resolved = resolver({language: stored}, {}, observed.catalogs);
   if (resolved.languageSource === "default" || resolved.lang.toLowerCase() === observed.lang.toLowerCase()) return groups;
   report?.({code: "metadata-reference-changed", path: "language",
     message: `Runs now use ${observed.lang}, not ${resolved.lang} of the stored language, so the stored language was not restored; the imported language follows the runs.`});
   return groups.filter((_, position) => position !== index);
 }
 
-/**
- * Diagnostics for the final imported document: several run languages, a run
- * tag that maps ambiguously or to no catalog record (only when that observed
- * language was kept), right-to-left paragraphs under a left-to-right
- * language, and theme East Asian/complex-script fonts the document does not
- * reproduce.
- */
 /** Whether the language observed in the runs is written right to left. */
 export function observedRtl(observed) {
   if (observed.lang === undefined) return false;
-  try { return resolver({language: observed.language}).rtl === true; } catch { return false; }
+  try { return resolver({language: observed.language}, {}, observed.catalogs).rtl === true; } catch { return false; }
 }
 
+/**
+ * Diagnostics for the final imported document: several run languages,
+ * right-to-left paragraphs under a left-to-right language, and theme East
+ * Asian/complex-script fonts the document does not reproduce.
+ */
 export function languageDiagnostics(imported, observed, report) {
   if (!report) return;
-  const {lang, match, ranked, rtlParagraphs, theme} = observed;
+  const {lang, ranked, rtlParagraphs, theme, catalogs} = observed;
   if (lang === undefined) {
     if (rtlParagraphs) report({code: "rtl-language-mismatch", path: "language", message: `${rtlParagraphs} right-to-left paragraph(s) carry no run language, so no presentation language was imported.`});
     return;
@@ -518,19 +498,13 @@ export function languageDiagnostics(imported, observed, report) {
     report({code: "mixed-run-languages", path: "language",
       message: `Runs use ${languages.length} languages (${languages.map(([tag, count]) => `${tag} x${count}`).join(", ")}). OPF has one presentation language, so ${lang} was imported; a run in another language keeps it as its own lang where the text imports as rich text.`});
   }
-  const kept = imported.language === observed.language;
-  if (kept && !match) report({code: "language-uncatalogued", path: "language", message: `Run language ${lang} matches no languages catalog record; it was imported as a BCP-47 tag.`});
-  else if (kept && match.shared.length > 1 && !match.shared.some(record => record.bcp47?.toLowerCase() === lang.toLowerCase())) {
-    report({code: "language-ambiguous", path: "language",
-      message: `Run language ${lang} is the OOXML tag of ${match.shared.map(record => record.id).join(", ")}; ${match.language} was imported.`});
-  }
-  const resolved = resolver(imported);
+  const resolved = resolver(imported, {}, catalogs);
   if (rtlParagraphs && !resolved.rtl) {
     report({code: "rtl-language-mismatch", path: "language", message: `${rtlParagraphs} right-to-left paragraph(s) do not match the left-to-right language ${typeof imported.language === "string" ? imported.language : lang}; paragraph direction is not imported separately.`});
   }
   // The presentation theme carries the first slide's script fonts (planScriptFonts), so it is compared with that slide.
   let themeResolved = resolved;
-  if (imported.slides?.length) { try { themeResolved = resolver(imported, {slideIndex: 0}); } catch { themeResolved = resolved; } }
+  if (imported.slides?.length) { try { themeResolved = resolver(imported, {slideIndex: 0}, catalogs); } catch { themeResolved = resolved; } }
   if (theme && themeResolved) {
     for (const {tag, slot, face} of themeScriptMismatches(theme, themeResolved)) {
       report({code: "script-font-not-imported", path: "design.fontScheme",
@@ -542,7 +516,7 @@ export function languageDiagnostics(imported, observed, report) {
     observed.slideThemes.forEach((slideTheme, index) => {
       if (!slideTheme || slideTheme.path === observed.themePath) return;
       let slideResolved;
-      try { slideResolved = resolver(imported, {slideIndex: index}); } catch { return; }
+      try { slideResolved = resolver(imported, {slideIndex: index}, catalogs); } catch { return; }
       for (const {tag, slot, face} of themeScriptMismatches(slideTheme.xml, slideResolved)) {
         report({code: "script-font-not-imported", path: `slides.${index}.design.fontScheme`,
           message: `Slide ${index + 1}'s master theme ${tag} ${slot} font "${face}" differs from both its latin font and what the imported slide resolves, and is not represented in the imported OPF.`});

package/dist/theme-colors.js

@@ -213,9 +213,11 @@ function recordColors(record) {
 
 /**
  * Recover design.colorScheme from theme clrScheme colors.
- * An exact twelve-slot match with a catalog record yields its id (the clrScheme
- * name breaks ties). Otherwise the colors are inline: relative to the record
- * whose name the clrScheme carries, or as all readable slots.
+ * `records` are the colour schemes a bare id can name in the imported document
+ * (FA-23: the host default catalog's, each with its key as `id`; none when the
+ * host registers no catalog). An exact twelve-slot match yields that bare id
+ * (the clrScheme name breaks ties). Otherwise the colors are inline: relative
+ * to the record whose name the clrScheme carries, or as all readable slots.
  */
 export function recoverColorScheme({colors, unreadable, name}, records) {
   const complete = unreadable.length === 0;
@@ -245,19 +247,22 @@ export function presentationThemePath(presentationRoot, presentationRels, relati
 }
 
 /**
- * Identify a catalog theme from the native theme name. The name must equal a
- * catalog theme name, and the package must corroborate it with that theme's
- * color scheme or its heading/body font pair, so a foreign deck that happens to
- * use a theme called "Bold" is not bound to the OPF theme.
+ * Identify a catalog theme from the native theme name. `themes` are the theme
+ * records a bare id can name (as for recoverColorScheme, each with its key as
+ * `id`); `colorScheme(theme)` and `fontFamilies(theme)` resolve the theme's own
+ * references (null when they resolve nowhere). The name must equal a theme
+ * name, and the package must corroborate it with that theme's color scheme or
+ * its heading/body font pair, so a foreign deck that happens to use a theme
+ * called "Bold" is not bound to the OPF theme.
  */
-export function recoverTheme({themeName, colors, majorFont, minorFont}, {themes, colorSchemes, fontFamilies}) {
+export function recoverTheme({themeName, colors, majorFont, minorFont}, {themes, colorScheme, fontFamilies}) {
   if (!themeName) return {};
   const theme = themes.find(record => record.name === themeName);
   if (!theme) return {};
-  const scheme = colorSchemes.find(record => record.id === theme.colorScheme);
+  const scheme = colorScheme(theme);
   const schemeColors = scheme ? recordColors(scheme) : null;
   const colorMatch = !!schemeColors && THEME_SLOTS.every(([slot]) => schemeColors[slot] === colors[slot]);
-  const fonts = fontFamilies(theme.fontScheme);
+  const fonts = fontFamilies(theme);
   const fontMatch = !!fonts && fonts.heading === majorFont && fonts.body === minorFont;
   return colorMatch || fontMatch ? {id: theme.id} : {unverified: theme.id};
 }

package/dist/typeface-inventory.js

@@ -117,7 +117,7 @@ export function checkTypefaces(input, options = {}) {
     }
     const reference = THEME_REFERENCE.exec(entry.typeface);
     if (reference) {
-      if (entry.resolved === null) fail(entry, 'unresolved-theme-reference');
+      if (entry.resolved === null) fail(entry, 'theme-reference-unresolved');
       else if (entry.resolved === '') { if (!allowEmpty || reference[2] === 'lt') fail(entry, 'empty-theme-reference'); }
       else if (!chosen.has(entry.resolved)) fail(entry, 'foreign-theme-reference', {resolved: entry.resolved});
       continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -65,7 +65,7 @@
   },
   "dependencies": {
     "@node-projects/jszip": "4.3.0",
-    "@openpresentation/opf": "^0.14.0",
+    "@openpresentation/opf": "^0.15.1",
     "@rgrove/parse-xml": "4.2.3",
     "fast-xml-parser": "^5.8.0",
     "fflate": "^0.8.3",
@@ -73,7 +73,7 @@
     "sharp": "0.35.5"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.14.0"
+    "@openpresentation/opf-render": "^0.15.0"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -82,7 +82,7 @@
   },
   "devDependencies": {
     "@expo-google-fonts/carlito": "0.4.1",
-    "@openpresentation/opf-render": "0.14.0",
+    "@openpresentation/opf-render": "0.15.0",
     "esbuild": "0.28.2",
     "playwright": "1.63.0"
   },

package/dist/slide-image-provenance.js

@@ -1,177 +0,0 @@
-import {XMLParser} from 'fast-xml-parser';
-import {normalizeCrop, withoutSvgBlip} from './svg-image.js';
-import {attachTextTags, decodeTextTag} from './code-provenance.js';
-import {framedPictureTransform} from './image-geometry.js';
-
-// A slide-level image (design.slideImage) exports as one native picture. Its
-// tag records the OPF placement and the exact native geometry, so an unchanged
-// picture imports back as design.slideImage while an edited one stays ordinary.
-const TAG = 'OPF_SLIDE_IMAGE_V1', OVERLAY_TAG = 'OPF_SLIDE_IMAGE_OVERLAY_V1', REL = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags';
-const EMUS_PER_INCH = 914400;
-const parser = new XMLParser({ignoreAttributes:false, attributeNamePrefix:'', parseTagValue:false, trimValues:false});
-const decoder = new TextDecoder('utf-8', {fatal:true}), encoder = new TextEncoder();
-const array = value => value === undefined ? [] : Array.isArray(value) ? value : [value];
-// Whitespace-only text between elements is not identity: the vendored writer indents, PowerPoint drops it on save.
-const canonical = value => JSON.stringify(value, (_key, item) => item && typeof item === 'object' && !Array.isArray(item)
-  ? Object.fromEntries(Object.keys(item).sort().filter(key => !(key === '#text' && typeof item[key] === 'string' && !item[key].trim())).map(key => [key, item[key]])) : item);
-const POSITIONS = ['background', 'top', 'bottom', 'left', 'right'];
-
-export const slideImageName = slidePath => `OPF slide image ${slidePath}`;
-export const slideImageOverlayName = slidePath => `OPF slide image overlay ${slidePath}`;
-
-// DrawingML for the shared treatment: preset geometry (core guide values), a
-// centered solid line, and blip recolor/alpha effects applied in that order.
-const presetXml = shape => `<a:prstGeom prst="${shape?.preset ?? 'rect'}"><a:avLst>${Object.entries(shape?.adjust ?? {}).map(([name, value]) => `<a:gd name="${name}" fmla="val ${value}"/>`).join('')}</a:avLst></a:prstGeom>`;
-const colorXml = ({hex, alpha}, extraAlpha = 1) => {
-  const value = Math.round(alpha * extraAlpha * 100000);
-  return `<a:srgbClr val="${hex}">${value < 100000 ? `<a:alpha val="${value}"/>` : ''}</a:srgbClr>`;
-};
-const lineXml = border => border ? `<a:ln w="${Math.round(border.width / 96 * EMUS_PER_INCH)}" algn="ctr"><a:solidFill>${colorXml(border)}</a:solidFill><a:miter lim="800000"/></a:ln>` : '';
-function blipEffects(effects) {
-  let xml = '';
-  if (effects?.recolor?.type === 'grayscale') xml += '<a:grayscl/>';
-  if (effects?.recolor?.type === 'duotone') xml += `<a:duotone>${colorXml({...effects.recolor.dark, alpha: 1})}${colorXml({...effects.recolor.light, alpha: 1})}</a:duotone>`;
-  if (typeof effects?.opacity === 'number') xml += `<a:alphaModFix amt="${Math.round(effects.opacity * 100000)}"/>`;
-  return xml;
-}
-
-// Native blip fill without its package-local relationship id.
-function blipFillIdentity(blipFill) {
-  const {['a:blip']: blip, ...rest} = normalizeCrop(blipFill) ?? {};
-  const {['r:embed']: _embed, ...blipRest} = withoutSvgBlip(blip) ?? {};
-  return {...rest, 'a:blip': blipRest};
-}
-
-/**
- * Place each generated slide-image picture at its frame (crop/fit through
- * a:srcRect), then bind the picture to its manifest with a native tag.
- * images: Map<objectName, {slide, box (inches), fill, treatment, path}>.
- */
-export function placeSlideImages(entries, images, metadataFor, fail) {
-  if (!images.size) return;
-  const manifests = new Map(), overlays = new Map();
-  for (const part of Object.keys(entries).filter(path => /^ppt\/slides\/slide\d+\.xml$/.test(path))) {
-    const xml = decoder.decode(entries[part]);
-    const next = xml.replace(/<p:pic>[\s\S]*?<\/p:pic>/g, picture => {
-      const name = picture.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1];
-      const image = images.get(name);
-      if (!image) return picture;
-      const embed = picture.match(/<a:blip\b[^>]*r:embed="([^"]+)"/)?.[1];
-      const metadata = metadataFor(part, embed);
-      if (!metadata) fail(image.path);
-      const placed = framedPictureTransform(metadata, image.box, image.fill);
-      const emu = value => Math.round(value * EMUS_PER_INCH);
-      const attributes = `${placed.rotation ? ` rot="${placed.rotation * 60000}"` : ''}${placed.flipH ? ' flipH="1"' : ''}${placed.flipV ? ' flipV="1"' : ''}`;
-      picture = picture.replace(/<a:xfrm\b[^>]*>[\s\S]*?<\/a:xfrm>/, `<a:xfrm${attributes}><a:off x="${emu(placed.x)}" y="${emu(placed.y)}"/><a:ext cx="${emu(placed.w)}" cy="${emu(placed.h)}"/></a:xfrm>`);
-      picture = picture.replace(/<a:srcRect\b[^>]*\/>/, '');
-      if (placed.crop) picture = picture.replace('<a:stretch>', `<a:srcRect l="${placed.crop.l}" t="${placed.crop.t}" r="${placed.crop.r}" b="${placed.crop.b}"/><a:stretch>`);
-      const effects = image.effects;
-      if (effects) {
-        picture = picture.replace(/<a:prstGeom\b[\s\S]*?<\/a:prstGeom>/, presetXml(effects.shape) + lineXml(effects.border));
-        const blip = blipEffects(effects);
-        if (blip) picture = picture.replace(/<a:blip\b([^>]*?)(?:\/>|>([\s\S]*?)<\/a:blip>)/, (_, attributes, inner = '') => `<a:blip${attributes}>${blip}${inner}</a:blip>`);
-      }
-      const node = parser.parse(picture)['p:pic'];
-      manifests.set(name, {v:1, slide:image.slide, position:image.treatment.position, fill:image.fill, treatment:image.treatment,
-        ...(image.content === true ? {content:true} : {}),
-        properties:node['p:spPr'], blipFill:blipFillIdentity(node['p:blipFill'])});
-      return picture;
-    });
-    const shaped = next.replace(/<p:sp>[\s\S]*?<\/p:sp>/g, shape => {
-      const name = shape.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1];
-      const image = [...images.values()].find(candidate => slideImageOverlayName(candidate.slide) === name);
-      const overlay = image?.effects?.overlay;
-      if (!overlay) return shape;
-      const emu = value => Math.round(value / 96 * EMUS_PER_INCH);
-      shape = shape.replace(/<p:spPr>[\s\S]*?<\/p:spPr>/, `<p:spPr><a:xfrm><a:off x="${emu(overlay.box.x)}" y="${emu(overlay.box.y)}"/><a:ext cx="${emu(overlay.box.width)}" cy="${emu(overlay.box.height)}"/></a:xfrm>${presetXml(overlay.shape)}<a:solidFill>${colorXml(overlay, overlay.opacity)}</a:solidFill><a:ln><a:noFill/></a:ln></p:spPr>`);
-      const node = parser.parse(shape)['p:sp'];
-      overlays.set(name, {v:1, slide:image.slide, properties:node['p:spPr']});
-      return shape;
-    });
-    if (shaped !== xml) entries[part] = encoder.encode(shaped);
-  }
-  if (manifests.size !== images.size) throw new Error('Missing generated slide image picture.');
-  attachTextTags(entries, manifests, TAG, 'opfSlideImage', 'slide image', {pictures:true});
-  attachTextTags(entries, overlays, OVERLAY_TAG, 'opfSlideImageOverlay', 'slide image overlay');
-}
-
-function readTags(container, relationships, entries) {
-  const tags = [];
-  let unreadable = false;
-  for (const link of array(container?.['p:tags'])) {
-    const rel = relationships.get(link['r:id']);
-    if (rel?.type !== REL || rel.targetMode === 'External' || !entries[rel.path]) { unreadable = true; continue; }
-    try { tags.push(...array(parser.parse(decoder.decode(entries[rel.path]))['p:tagLst']?.['p:tag'])); } catch { unreadable = true; }
-  }
-  return {tags, unreadable};
-}
-
-function validTreatment(treatment, position) {
-  return treatment && typeof treatment === 'object' && !Array.isArray(treatment) && treatment.position === position
-    && POSITIONS.includes(position) && treatment.src === undefined;
-}
-
-/**
- * Recover design.slideImage from an unchanged tagged picture. Returns the
- * consumed picture indexes and the slide design fields to restore.
- * readPicture(picture) returns the ordinary imported image payload.
- */
-export function importSlideImage(pictures, shapes, relationships, entries, slideIndex, readPicture, report) {
-  const consumed = new Set(), consumedShapes = new Set(), found = [];
-  for (const [index, picture] of pictures.entries()) {
-    const {tags, unreadable} = readTags(picture['p:nvPicPr']?.['p:nvPr']?.['p:custDataLst'], relationships, entries);
-    const own = tags.filter(tag => tag.name?.toUpperCase() === TAG);
-    if (!own.length) continue;
-    found.push({index, picture, own, unreadable, others: tags.some(tag => /^OPF_/i.test(tag.name) && tag.name.toUpperCase() !== TAG)});
-  }
-  if (!found.length) return {consumed, consumedShapes};
-  const invalid = () => report({code:'invalid-slide-image-provenance', message:'An edited, ambiguous or invalid tagged OPF slide image was imported as an ordinary picture. Its native placement is not reconstructed as design.slideImage.'});
-  if (found.length > 1) { invalid(); return {consumed, consumedShapes}; }
-  const [{index, picture, own, unreadable, others}] = found;
-  try {
-    if (unreadable || others || own.length !== 1) throw Error('Ambiguous slide image identity.');
-    const manifest = decodeTextTag(own[0].val);
-    if (manifest?.v !== 1 || manifest.slide !== `slides.${slideIndex}` || !['crop', 'fit'].includes(manifest.fill) || !validTreatment(manifest.treatment, manifest.position)) throw Error('Invalid slide image manifest.');
-    if (manifest.content !== undefined && manifest.content !== true) throw Error('Invalid slide image content flag.');
-    if (picture['p:nvPicPr']?.['p:cNvPr']?.name !== slideImageName(manifest.slide)) throw Error('Slide image identity changed.');
-    if (canonical(picture['p:spPr']) !== canonical(manifest.properties) || canonical(blipFillIdentity(picture['p:blipFill'])) !== canonical(normalizeCrop(manifest.blipFill))) throw Error('Slide image geometry or effects changed.');
-    const item = readPicture(picture);
-    const src = item?.payload?.image?.src;
-    if (typeof src !== 'string') throw Error('Slide image bytes are unavailable.');
-    consumed.add(index);
-    const treatment = {...manifest.treatment};
-    if (treatment.overlay !== undefined) {
-      // The scrim is a separate native shape; recover it only while it is unchanged.
-      const overlay = findOverlay(shapes, relationships, entries, manifest.slide);
-      if (overlay === null) {
-        delete treatment.overlay;
-        report({code:'invalid-slide-image-provenance', message:'The tagged OPF slide image overlay is missing, edited or ambiguous. The slide image is recovered without its overlay; any remaining native shape is imported as ordinary content.'});
-      } else consumedShapes.add(overlay);
-    }
-    // FF-53: a picture that replaced the slide's root `image` (same source as the slide image) restores that
-    // payload too, so the round trip keeps `slide.image` with its alt text as well as design.slideImage.
-    const alt = item.payload.image.alt;
-    const content = manifest.content === true ? {image: {src, ...(typeof alt === 'string' && alt ? {alt} : {})}} : {};
-    return {consumed, consumedShapes, design: {slideImage: {...treatment, src}, ...(manifest.fill === 'fit' ? {imageFill: 'fit'} : {})}, ...content};
-  } catch {
-    invalid();
-    return {consumed, consumedShapes};
-  }
-}
-
-function findOverlay(shapes, relationships, entries, slide) {
-  const matches = [];
-  for (const [index, shape] of shapes.entries()) {
-    const {tags, unreadable} = readTags(shape['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst'], relationships, entries);
-    const own = tags.filter(tag => tag.name?.toUpperCase() === OVERLAY_TAG);
-    if (!own.length) continue;
-    try {
-      if (unreadable || own.length !== 1 || tags.some(tag => /^OPF_/i.test(tag.name) && tag.name.toUpperCase() !== OVERLAY_TAG)) throw Error('Ambiguous overlay identity.');
-      const manifest = decodeTextTag(own[0].val);
-      if (manifest?.v !== 1 || manifest.slide !== slide || shape['p:nvSpPr']?.['p:cNvPr']?.name !== slideImageOverlayName(slide)) throw Error('Invalid overlay identity.');
-      if (canonical(shape['p:spPr']) !== canonical(manifest.properties)) throw Error('Overlay changed.');
-      matches.push(index);
-    } catch { return null; }
-  }
-  return matches.length === 1 ? matches[0] : null;
-}