@openpresentation/opf-pptx 0.17.0 → 0.18.0

package/dist/index.js

@@ -24,13 +24,14 @@ import {headingValue,joinRichLines} from './rich-heading.js';
 import {attachPlainTextTags,importPlainTextGroups} from './text-provenance.js';
 import {attachTimelineTags,timelineManifest,importTimelineGroups} from './timeline-provenance.js';
 import {attachQuoteTags,quoteManifest,importQuoteGroups,quotePhotoName} from './quote-provenance.js';
-import {attachFurnitureTags, furnitureManifest, importFurniture, manifestPartIndex, staticDateFallback} from './furniture-provenance.js';
+import {attachFurnitureTags, furnitureManifest, importFurniture, logoShape, staticDateFallback, stampFurnitureImageKeys} from './furniture-provenance.js';
 import {restoreRunColors} from './run-colors.js';
 import {joinWrappedText} from './content-topology.js';
 import {applyDocumentProvenance, attachDocumentProvenance, documentProvenance, recordContentTopology, restoreDocumentProvenance, joinAuthors, splitAuthors, slideListBreaks, storedMetadata, DEFAULT_AUTHOR, DEFAULT_TITLE} from './document-provenance.js';
 import {INVALID_XML_CHARACTER, nativeSections, writeSectionList} from './sections.js';
 import {attachFurnitureFields, furniturePartFields, lineFields, nativeFieldType} from './furniture-fields.js';
 import {attachNativePlaceholders, defaultPlaceholderGeometry, nativeDateText, nativeFurnitureParts, nativePlaceholderForPart, writeNativeMasters} from './native-furniture.js';
+import {liftMasterFurniture} from './master-furniture.js';
 import {importImageOrientation} from './image-import.js';
 import {extractSignals, normalizeSignalOptions, themeFactsFor} from './import-signals.js';
 import {placeImages, importImages, imageName, imageOverlayName, backgroundImageName, backgroundOverlayName, IMAGE_TREATMENT_KEYS, BACKGROUND_IMAGE_KEYS} from './image-provenance.js';
@@ -278,10 +279,13 @@ export async function toPptx(input, options = {}) {
   context.quoteTags = new Map();
   context.quotePhotos = new Map();
   context.furnitureTags = new Map();
-  context.furnitureLogoTags = new Map();
+  context.furnitureImages = new Map();
   context.furnitureFields = new Map();
   context.furnitureManifests = new Map();
   context.nativeFurniture = new Map();
+  context.nativeFurnitureBands = new Map();
+  // RR-72: each slide's furniture parts and the object names of their shapes, for the slide master and layouts.
+  context.furnitureParts = [];
   context.hostDate = options.date;
   context.authored = authored;
   context.codeTags = new Map();
@@ -408,6 +412,19 @@ export async function fromPptx(input, options = {}) {
   // Layouts and the master are read once however many slides inherit a placeholder from them (RR-11).
   const cached = read => { const memo = new Map(); return path => { if (!memo.has(path)) memo.set(path, read(path)); return memo.get(path); }; };
   const cachedRelationships = cached(path => parseRelationships(entries, path)), cachedPart = cached(path => parseOptionalXml(entries, path));
+  // RR-72: the furniture a slide shows from its layout and slide master (src/master-furniture.js), read once per part.
+  const inheritedParts = new Map();
+  const inheritedPart = path => {
+    if (!path) return undefined;
+    if (!inheritedParts.has(path)) {
+      const element = /slideMaster/.test(path) ? 'p:sldMaster' : 'p:sldLayout', root = cachedPart(path)?.[element];
+      const tree = root?.['p:cSld']?.['p:spTree'];
+      inheritedParts.set(path, root ? {path, root, relationships: cachedRelationships(path), shapes: nativeTextShapes(tree), pictures: nativePictures(tree),
+        paragraphs: nativeShapeParagraphs(decodeText(entries[path]), element)} : undefined);
+    }
+    return inheritedParts.get(path);
+  };
+  const relatedPath = (path, type) => path ? [...cachedRelationships(path).values()].find(rel => rel.type === `http://schemas.openxmlformats.org/officeDocument/2006/relationships/${type}` && rel.targetMode !== 'External' && entries[rel.path])?.path : undefined;
   const furnitureContexts = slidePaths.map((slidePath, index) => {
     const root = parseRequiredXml(entries, slidePath)['p:sld'];
     if (!root) throw new OPFPptxError('invalid-pptx', `PPTX slide is not a PresentationML slide: ${slidePath}.`, {path: slidePath});
@@ -417,7 +434,12 @@ export async function fromPptx(input, options = {}) {
       path: slidePath, slideWidth: Number(presentationRoot['p:sldSz']?.cx), relationshipsOf: cachedRelationships, readPart: cachedPart,
       paragraphs: nativeShapeParagraphs(decodeText(entries[slidePath])),
       readPicture: picture => importPicture(entries, picture, slidePath, relationships,
-        diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${index}.design`}))};
+        diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${index}.design`})),
+      inherited: () => {
+        const layout = relatedPath(slidePath, 'slideLayout'), master = relatedPath(layout, 'slideMaster');
+        return Object.fromEntries([['layout', inheritedPart(layout)], ['master', inheritedPart(master)]].filter(([, part]) => part).map(([on, part]) => [on, {...part,
+          readPicture: picture => importPicture(entries, picture, part.path, part.relationships, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${index}.design`}))}]));
+      }};
   });
   // Native sections (PowerPoint's own section list, `Default Section` = none) name each slide's `{{slide.section}}` for the footer text check
   // and, after the slides, are reconciled with the stored value in restoreDocumentProvenance.
@@ -432,7 +454,7 @@ export async function fromPptx(input, options = {}) {
     ...(stored.organization !== undefined ? {organization: stored.organization} : {}),
     ...(stored.speaker !== undefined ? {speaker: stored.speaker} : {}),
   };
-  const furniture = importFurniture(furnitureContexts, entries, options.onDiagnostic, {sections: slideSections ?? [], organizations: asArray(stored.organization).filter(item => isPlainObject(item) && typeof item.id === 'string' && typeof item.name === 'string').map(item => ({id: item.id, name: item.name})),
+  const furniture = importFurniture(furnitureContexts, entries, options.onDiagnostic, {sections: slideSections ?? [], organizations: asArray(stored.organization).filter(item => isPlainObject(item) && typeof item.id === 'string' && typeof item.name === 'string').map(item => ({id: item.id, name: item.name, ...(typeof item.role === 'string' ? {role: item.role} : {}), ...(logoShape(item.logo) !== undefined ? {logo: logoShape(item.logo)} : {})})),
     draw: (template, {index, count, section}) => drawFurnitureText(template, {index, count, section}, importedMetadata)});
   if (Object.keys(furniture.design).length) imported.design = {...imported.design, ...furniture.design};
   if (furniture.organization) imported.organization = furniture.organization;
@@ -530,21 +552,19 @@ function applyRunColors(imported, slideProvenance, restoredGroups, report, optio
   restoreRunColors(imported.slides, info, resolve, report);
 }
 
-// A consumed logo picture (OPF_LOGO_V1) never becomes content. Its own image restores the logo only when nothing else
-// did: the stored document and slide design (or the organization) win and carry LogoSet variants, so a package exported
-// without provenance still keeps its logo. A slide-level logo path restores slide design; every other path the deck's.
+// A consumed logo picture (OPF_LOGO_V1) never becomes content. Its own image restores the organization's logo only when the
+// stored document did not (RR-71: logos live on the organization), so a package exported without provenance still keeps its
+// logo: on the primary organization, else on a new one named after the deck. The picture is one drawn asset, so it becomes the
+// organization's single logo for every shape.
 function restoreLogoFallback(imported, contexts) {
   const organizations = asArray(imported.organization);
-  contexts.forEach((context, index) => {
-    const fallback = context.logoFallback;
-    if (!fallback) return;
-    const slide = imported.slides[index];
-    const image = fallback.image;
-    // A slide's own logo restores whenever the slide states none, whatever the deck logo is; the deck logo only
-    // when neither it nor the organization has one.
-    if (fallback.path.startsWith('slides.')) { if (slide.design?.logo === undefined) slide.design = {...slide.design, logo: image}; }
-    else if (imported.design?.logo === undefined && !organizations.some(item => item?.logo !== undefined)) imported.design = {...imported.design, logo: image};
-  });
+  if (organizations.some(item => item?.logo !== undefined)) return;
+  const image = contexts.map(context => context.logoFallback?.image).find(Boolean);
+  if (!image) return;
+  const primary = organizations.find(item => item?.role === 'primary') ?? organizations[0];
+  if (!primary) { imported.organization = {id: 'brand', name: imported.name ?? 'Brand', logo: image}; return; }
+  const index = organizations.indexOf(primary), withLogo = {...primary, logo: image};
+  imported.organization = Array.isArray(imported.organization) ? imported.organization.map((item, at) => at === index ? withLogo : item) : withLogo;
 }
 
 function readPptxZip(input) {
@@ -752,7 +772,7 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
     diagnostic => options.onDiagnostic?.({...diagnostic, path: watermarkPath}));
   if (watermark.design) slide.design = {...slide.design, ...watermark.design};
   nativeContext.watermarkPictures = watermark.consumed;
-  // The generated deck logo picture is not content; its value returns from the stored design (or, without one, from the picture).
+  // The generated cover logo picture is not content; the logo returns from the stored organization (or, without one, from the picture).
   const logoPath = `slides.${slideIndex}.design.logo`;
   const logo = importLogo(nativeContext.pictures, relationships, entries, slideIndex,
     picture => importPicture(entries, picture, slidePath, relationships, diagnostic => {
@@ -1948,6 +1968,7 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
   const geometry = composeSlide(opfSlide, composeOptions);
   // The default footer band (date left, text center, number right): where a footer added natively lands (RR-11).
   if (slideIndex === 0) context.defaultFooterOptions = composeOptions;
+  slideContext.zoneBand = zoneBands(composeOptions);
   slide.background = { color: slideContext.colors.background };
   // An image background is core's geometry.backgroundImage (slide, deck, then theme background); every other kind is the
   // effective design or theme background definition.
@@ -2809,10 +2830,19 @@ function defaultFooterParts(composeOptions) {
   }
 }
 
+// The band core gives a lone text part in a zone (x and width in pixels): where a footer added natively sits.
+function zoneBands(composeOptions) {
+  let bands;
+  return zone => (bands ??= new Map((defaultFooterParts(composeOptions) ?? []).map(part => [part.zone, {x: part.box.x, width: part.box.width}]))).get(zone);
+}
+
 // The slide and deck as given to toPptx (variables not yet resolved), for the furniture manifest's authored header and footer text.
 const authoredFurniture = (context, slideIndex) => ({presentation: context.authored, slide: context.authored?.slides?.[slideIndex]});
 
 async function addFurniture(slide,presentation,source,layout,context,options,slideIndex) {
+  // RR-72: every slide is listed, a slide without furniture too (it may need a layout that hides the master's).
+  const drawn = [];
+  context.furnitureParts[slideIndex] = {path: `ppt/slides/slide${slideIndex + 1}.xml`, parts: drawn};
   if(!layout){
     if(['header','footer'].some(kind=>(source.design?.[kind]??presentation.design?.[kind])))throw new OPFPptxError('missing-furniture-layout','Header/footer export requires coordinated core furniture geometry.',{path:`slides.${slideIndex}.design`});
     const manifest = furnitureManifest(presentation, source, {parts: []}, slideIndex, undefined, undefined, authoredFurniture(context, slideIndex));
@@ -2823,12 +2853,18 @@ async function addFurniture(slide,presentation,source,layout,context,options,sli
   // RR-11: the first footer text, date and slide number that fit one line are native placeholders (src/native-furniture.js).
   const natives = nativeFurnitureParts(layout);
   for(const [index,part]of layout.parts.entries()){
+    const entry = {index, kind: part.kind, zone: part.zone, field: part.field, type: part.type, path: part.path, native: natives.has(index), names: []};
+    drawn.push(entry);
     if(part.type==='image'){
       const region={x:part.box.x/96,y:part.box.y/96,w:part.box.width/96,h:part.box.height/96};
-      const objectName = await addImagePayload(slide,presentation,part.image,region,part.path,context,options);
-      // A generated deck logo is listed beside the manifest topology (see furnitureManifest) and tagged as a logo.
-      if (objectName && part.field === 'logo') context.furnitureLogoTags.set(objectName, {v:1, role:'furniture', group:String(slideIndex), furniture:part.kind, zone:part.zone});
-      else if (objectName) context.furnitureTags.set(objectName, {v:1, role:'image', group:String(slideIndex), part:manifestPartIndex(layout.parts, index)});
+      // A logo reference draws the organization's asset: a source that cannot be drawn is reported where the asset is written.
+      const objectName = await addImagePayload(slide,presentation,part.image,region,part.reference!==undefined?part.sourcePath:part.path,context,options);
+      if (objectName) {
+        entry.names.push(objectName);
+        context.furnitureTags.set(objectName, {v:1, role:'image', group:String(slideIndex), part:index});
+        // RR-71: a part drawn from a logo reference (var:organization.logo.icon) records its picture, so import can tell it is unchanged.
+        if (part.reference !== undefined) context.furnitureImages.set(`ppt/slides/slide${slideIndex + 1}.xml|${part.kind}.${part.zone}`, objectName);
+      }
     }else{
       if(!part.fit?.sourceLines)throw new OPFPptxError('missing-furniture-layout','Repeated text requires accepted source lines from core.',{path:part.path});
       // Slide numbers ({{slide.number}}) and current dates become native PowerPoint fields; {{deck.slideCount}},
@@ -2848,8 +2884,15 @@ async function addFurniture(slide,presentation,source,layout,context,options,sli
           if(marker) staticDates.set(index,marker);
         }
       }
-      addMeasuredPayloadText(slide,part.text,part.box,context,options,{path:part.path,fit:part.fit,textStyle:part.style,align:part.alignment,diagnosticsHandled:true,color:context.mutedColor,keepEmpty:true,objectName:`OPF furniture ${slideIndex} part ${index}`,furniture:{group:String(slideIndex),part:manifestPartIndex(layout.parts,index)},liveFields,links:part.links});
-      if(natives.has(index))context.nativeFurniture.set(`OPF furniture ${slideIndex} part ${index} line 0`,natives.get(index));
+      addMeasuredPayloadText(slide,part.text,part.box,context,options,{path:part.path,fit:part.fit,textStyle:part.style,align:part.alignment,diagnosticsHandled:true,color:context.mutedColor,keepEmpty:true,objectName:`OPF furniture ${slideIndex} part ${index}`,furniture:{group:String(slideIndex),part:index},liveFields,links:part.links});
+      entry.names.push(...part.fit.lines.map((line, number) => `OPF furniture ${slideIndex} part ${index} line ${number}`));
+      if(natives.has(index)){
+        const name=`OPF furniture ${slideIndex} part ${index} line 0`;
+        context.nativeFurniture.set(name,natives.get(index));
+        // RR-71: a part in a row with other parts is as wide as its text; the master's placeholder spans the zone.
+        const band=context.zoneBand?.(part.zone);
+        if(band&&part.box.width<band.width-.5)context.nativeFurnitureBands.set(name,band);
+      }
     }
   }
   const manifest = furnitureManifest(presentation, source, layout, slideIndex, staticDates, natives, authoredFurniture(context, slideIndex));
@@ -3555,7 +3598,7 @@ async function resolveImage(asset, presentation, options, path, outcome = {}) {
   if (raster) return dataUriMediaType(resolved.data) === raster.mediaType ? resolved : {...resolved, data: `data:${raster.mediaType};base64,${bytesToBase64(bytes)}`};
   const svg = svgDataUriBytes(resolved.data);
   if (svg) return resolveSvgImage(svg, options, path, outcome);
-  const message = `The image is not a readable PNG, JPEG, GIF or WebP (${dataUriMediaType(resolved.data) ?? "unknown type"}); supply a raster through imageResolver (for example opf-render svgToPng).`;
+  const message = `The image is not a readable PNG, JPEG, GIF or WebP (${dataUriMediaType(resolved.data) ?? "unknown type"}); supply a raster through imageResolver (for example opf-render toPng).`;
   if (options.strictAssets) throw new OPFPptxError("unsupported-image-dimensions", `Image fitting requires readable PNG, JPEG, GIF or WebP dimensions. ${message}`, { path });
   options.onDiagnostic?.({ code: "unresolved-asset", path, reason: "unsupported-format", message });
   outcome.reported = true;
@@ -3799,9 +3842,9 @@ async function normalizePptxZip(raw, context) {
   attachQuoteTags(entries,context.quoteTags);
   attachAnnotationTags(entries,context);
   attachFurnitureFields(entries,context.furnitureFields);
-  attachFurnitureTags(entries,context.furnitureTags,context.furnitureManifests,context.furnitureLogoTags);
+  attachFurnitureTags(entries,context.furnitureTags,context.furnitureManifests);
   // RR-11: the recorded footer shapes become PowerPoint's date, footer and slide-number placeholders.
-  context.nativePlaceholders = attachNativePlaceholders(entries,context.nativeFurniture);
+  context.nativePlaceholders = attachNativePlaceholders(entries,context.nativeFurniture,context.nativeFurnitureBands);
   // The "Image unavailable" panel of an unresolved logo: identity only, so import does not read it as content.
   attachTextTags(entries,context.logoPlaceholderTags,LOGO_TAG,'opfLogoPlaceholder','logo placeholder');
   for(const [part,bytes]of Object.entries(entries)){
@@ -3905,6 +3948,8 @@ async function normalizePptxZip(raw, context) {
   });
   // A picture repeated across slides embeds once (after fitting, which needs each slide's own relationship).
   dedupeMedia(entries, imageMetadata, resolveRelationshipTarget);
+  // The media keys of the logo-reference pictures, now that the package holds its final media (src/furniture-provenance.js).
+  stampFurnitureImageKeys(entries, context.furnitureManifests, context.furnitureImages, parseRelationships);
   // Charts and notes follow the language and fonts of the slide they belong to.
   context.partSlides = new Map();
   for (const part of Object.keys(entries)) {
@@ -3951,6 +3996,12 @@ async function normalizePptxZip(raw, context) {
     }
     reportPerSlideNotesScriptFonts(context.scriptFonts, slideThemes);
   }
+  // RR-72: furniture drawn the same on several slides moves to the slide master or a layout (src/master-furniture.js).
+  try {
+    liftMasterFurniture(output, context.furnitureParts, diagnostic => context.reportDiagnostic?.(diagnostic));
+  } catch (error) {
+    throw new OPFPptxError('packaging-failed', 'Header and footer furniture could not be written to the slide master and layouts.', {cause: errorMessage(error)});
+  }
   finalizeFontsUsed(output);
   // Document references record evidence from the final normalized parts.
   if (context.documentProvenance) {

package/dist/logo-provenance.js

@@ -3,13 +3,13 @@ import {normalizeCrop, withoutSvgBlip} from './svg-image.js';
 import {decodeTextTag, encodeTextTag} from './code-provenance.js';
 import {pictureTransform} from './image-geometry.js';
 
-// The deck logo (core's `geometry.logo`: design.logo, a slide's own logo or the
-// primary organization's logo on a cover or section slide) exports as one native
+// The cover and section logo (core's `geometry.logo`: the primary organization's full logo, or the
+// organization a `design.logo` reference names, RR-71) exports as one native
 // picture per slide named `OPF logo`, after the watermark and before content. It
 // is fitted into core's box without cropping, anchored left and vertically
 // centered (the preview's `xMinYMid meet`). The native tag records the exact
 // picture, so an unchanged picture is consumed on import (the logo itself returns
-// from the document and slide design records) while an edited one stays an
+// from the document record's organization) while an edited one stays an
 // ordinary picture and reports `invalid-logo-provenance`.
 const TAG = 'OPF_LOGO_V1', REL = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags';
 const EMUS_PER_INCH = 914400;
@@ -19,8 +19,8 @@ const array = value => value === undefined ? [] : Array.isArray(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);
-// The OPF paths core reports for a logo source.
-const LOGO_PATH = /^(?:slides\.\d{1,9}\.design\.logo|design\.logo|organization(?:\.\d{1,9})?\.logo)(?:\.[A-Za-z]{1,16})?$/;
+// The OPF paths core reports for a logo source: the organization's `logo`, then a shape and a tone below it.
+const LOGO_PATH = /^organization(?:\.\d{1,9})?\.logo(?:\.[A-Za-z]{1,16}){0,2}$/;
 
 export const LOGO_TAG = TAG;
 export const logoName = () => 'OPF logo';
@@ -138,10 +138,10 @@ export function importLogoPlaceholders(shapes, relationships, entries, slideInde
 }
 
 /**
- * Consume an unchanged tagged logo picture: it is generated from design.logo (or
- * the organization's logo), never content. Returns the consumed picture indexes
+ * Consume an unchanged tagged logo picture: it is drawn from the organization's
+ * logo, never content. Returns the consumed picture indexes
  * and `fallback`, the picture's own `{path, image}`: the caller uses it for the
- * logo only when the stored document and slide design did not restore one (an
+ * organization's logo only when the stored document did not restore one (an
  * export without provenance, or one that omitted the field), so the logo is never
  * lost. An edited, ambiguous or damaged tagged picture stays an ordinary picture
  * and is reported. readPicture(picture) returns the ordinary imported payload.

package/dist/master-furniture.js

@@ -0,0 +1,326 @@
+// RR-72: header and footer furniture on the slide master and layouts (docs/native-header-footer.md, "Master furniture").
+//
+// Furniture parts PowerPoint has no placeholder for (a logo or other zone image, socials, header text, footer text
+// other than the one native `ftr`) are drawn by core on every slide. When a part is drawn the same on two or more slides
+// (the same XML: content, box, style, picture bytes), it is written once instead:
+//
+// - on the slide master, when it is the same on every slide that shows liftable furniture (two or more slides);
+// - on a layout (a copy of the master's layout, with RR-11's placeholders), when it is shared by two or more slides
+//   but not by all of them: one layout per distinct set, so a logo with onLight/onDark variants gets one layout per
+//   background tone, and a section's header text one layout per section;
+// - a slide that shows none of the master's parts (its footer hidden, `design.footer: false`) uses a layout whose
+//   `showMasterSp="0"` hides the master's furniture.
+//
+// A part stays an ordinary shape on its slide when it is drawn on that slide only (nothing repeats, a one-slide deck
+// included), when it holds a live field (a header slide number or current date: its cached value is per slide) or when
+// slide content overlaps its box: PowerPoint draws master and layout shapes beneath every slide shape, while core paints
+// furniture above content, so such a part stays above the content on its slide (`furniture-on-slide` diagnostic).
+//
+// Provenance. A lifted shape keeps its OPF_FURNITURE_V1 tag, with the slot (`footer.left.image`) in place of the slide
+// group and part. Each slide's manifest moves the part (its topology entry, the definition's flag, and its stored text
+// template or logo reference) into `shared`, keyed by slot, with `on: 'master' | 'layout'`; importers before 0.18,
+// which read only slide shapes, ignore `shared` and read the rest of the slide's furniture as before.
+
+import {decodeTextTag, encodeTextTag} from './code-provenance.js';
+
+const dec = new TextDecoder('utf-8', {fatal: true}), enc = new TextEncoder();
+const REL = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const TAGS_TYPE = 'application/vnd.openxmlformats-officedocument.presentationml.tags+xml';
+const LAYOUT_TYPE = 'application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml';
+const NS = 'http://schemas.openxmlformats.org/presentationml/2006/main';
+const TAG = 'OPF_FURNITURE_V1';
+
+const relsOf = path => path.replace(/([^/]+)$/, '_rels/$1.rels');
+const attribute = (xml, name) => new RegExp(`\\s${name}="([^"]*)"`).exec(xml)?.[1];
+const escapeAttribute = value => value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;');
+const unescapeAttribute = value => value.replace(/&quot;/g, '"').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+const escapeRegExp = value => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+function resolvePart(source, target) {
+  if (target.startsWith('/')) return target.slice(1);
+  const parts = source.split('/').slice(0, -1);
+  for (const piece of target.split('/')) {
+    if (piece === '..') parts.pop();
+    else if (piece !== '.' && piece) parts.push(piece);
+  }
+  return parts.join('/');
+}
+
+function relativeTarget(source, path) {
+  const from = source.split('/').slice(0, -1), to = path.split('/');
+  let common = 0;
+  while (common < from.length && common < to.length - 1 && from[common] === to[common]) common++;
+  return [...Array(from.length - common).fill('..'), ...to.slice(common)].join('/');
+}
+
+// The relationships of one part: [{node, id, type, target, external, path}].
+function relationships(xml) {
+  return [...xml.matchAll(/<Relationship\b[^>]*\/>/g)].map(([node]) => ({node, id: attribute(node, 'Id'), type: attribute(node, 'Type') ?? '',
+    target: unescapeAttribute(attribute(node, 'Target') ?? ''), external: attribute(node, 'TargetMode') === 'External'}));
+}
+
+// Top-level text shapes and pictures by object name (generated furniture is never grouped).
+const shapeElements = xml => [...xml.matchAll(/<p:(sp|pic)>[\s\S]*?<\/p:\1>/g)].map(match => ({xml: match[0], kind: match[1], name: unescapeAttribute(match[0].match(/<p:cNvPr\b[^>]*\bname="([^"]*)"/)?.[1] ?? '')}));
+const RELATIONSHIP_ATTRIBUTE = /\br:(embed|link|id|pict)="([^"]*)"/g;
+
+function bounds(xml) {
+  const boxes = [...xml.matchAll(/<a:off x="(-?\d+)" y="(-?\d+)"\/>\s*<a:ext cx="(\d+)" cy="(\d+)"\/>/g)].map(match => match.slice(1).map(Number));
+  if (!boxes.length) return undefined;
+  const left = Math.min(...boxes.map(box => box[0])), top = Math.min(...boxes.map(box => box[1]));
+  return {left, top, right: Math.max(...boxes.map(box => box[0] + box[2])), bottom: Math.max(...boxes.map(box => box[1] + box[3]))};
+}
+const overlaps = (a, b) => Math.min(a.right, b.right) - Math.max(a.left, b.left) > 0 && Math.min(a.bottom, b.bottom) - Math.max(a.top, b.top) > 0;
+
+/**
+ * Write the furniture that repeats across slides once, on the slide master or a layout. `output` maps a package path to
+ * [bytes, zipOptions] (the finished, normalized package; per-script masters already exist). `slides[i]` describes slide i:
+ * `{path, parts: [{index, kind, zone, field, type, names, native, path}]}`, the core furniture parts in manifest order with the
+ * object names of their shapes (one per text line). `report` receives export diagnostics.
+ */
+export function liftMasterFurniture(output, slides, report = () => {}) {
+  const has = path => Object.hasOwn(output, path);
+  const read = path => dec.decode(output[path][0]);
+  const options = output['ppt/presentation.xml'][1];
+  const write = (path, xml) => { output[path] = [enc.encode(xml), output[path]?.[1] ?? options]; };
+  let types = read('[Content_Types].xml');
+  const relsCache = new Map();
+  const rels = path => {
+    if (!relsCache.has(path)) relsCache.set(path, has(relsOf(path)) ? relationships(read(relsOf(path))) : []);
+    return relsCache.get(path);
+  };
+  const related = (path, type) => {
+    const rel = rels(path).find(item => !item.external && item.type === `${REL}/${type}`);
+    return rel ? resolvePart(path, rel.target) : undefined;
+  };
+
+  // 1. Each slide's candidates: slot -> {signature, box, shapes, part}; and the parts content overlaps.
+  const plans = [];
+  for (const [slideIndex, slide] of slides.entries()) {
+    if (!slide || !has(slide.path)) continue;
+    const xml = read(slide.path), layout = related(slide.path, 'slideLayout'), master = layout && related(layout, 'slideMaster');
+    if (!layout || !master) continue;
+    const elements = new Map(shapeElements(xml).map(element => [element.name, element]));
+    const furnitureNames = new Set(slide.parts.flatMap(part => part.names));
+    // Every other shape's frame: furniture under any of them keeps its paint order on the slide.
+    let others = xml;
+    for (const element of shapeElements(xml)) if (furnitureNames.has(element.name)) others = others.replace(element.xml, '');
+    const occupied = [...others.matchAll(/<a:off x="(-?\d+)" y="(-?\d+)"\/>\s*<a:ext cx="(\d+)" cy="(\d+)"\/>/g)]
+      .map(match => match.slice(1).map(Number)).filter(([, , cx, cy]) => cx > 0 || cy > 0)
+      // A line has no area: one unit across, so a rule through the band still counts.
+      .map(([x, y, cx, cy]) => ({left: x, top: y, right: x + Math.max(cx, 1), bottom: y + Math.max(cy, 1)}));
+    const relationOf = id => {
+      const rel = rels(slide.path).find(item => item.id === id);
+      return rel ? `${rel.type}|${rel.external ? `external:${rel.target}` : resolvePart(slide.path, rel.target)}` : `missing:${id}`;
+    };
+    const candidates = new Map(), pinned = new Set();
+    for (const part of slide.parts) {
+      if (part.native || !part.names.length) continue;
+      const shapes = part.names.map(name => elements.get(name));
+      if (shapes.some(shape => !shape || shape.kind !== (part.type === 'image' ? 'pic' : 'sp'))) continue;
+      if (shapes.some(shape => /<a:fld\b/.test(shape.xml))) continue;
+      const box = bounds(shapes.map(shape => shape.xml).join(''));
+      if (!box) continue;
+      // Drawn content and box: the shape XML without its object id, name and tags, relationship ids read as their targets.
+      const signature = shapes.map(shape => shape.xml.replace(/<p:custDataLst>[\s\S]*?<\/p:custDataLst>/g, '')
+        .replace(/(<p:cNvPr\b[^>]*?)\s(?:id|name)="[^"]*"/g, '$1').replace(/(<p:cNvPr\b[^>]*?)\s(?:id|name)="[^"]*"/g, '$1')
+        .replace(RELATIONSHIP_ATTRIBUTE, (match, kind, id) => `r:${kind}="${relationOf(id)}"`)).join('\n');
+      const slot = `${part.kind}.${part.zone}.${part.field}`;
+      candidates.set(slot, {slot, signature, part, shapes, box});
+      if (occupied.some(frame => overlaps(frame, box))) pinned.add(slot);
+    }
+    plans.push({slideIndex, slide, xml, layout, master, candidates, pinned});
+  }
+  if (!plans.length) return;
+  // One report per part (its authored path), naming the slides where content covers it.
+  const covered = new Map();
+  for (const plan of plans) for (const slot of plan.pinned) {
+    const part = plan.candidates.get(slot).part;
+    covered.set(part.path, {part, slides: [...(covered.get(part.path)?.slides ?? []), plan.slideIndex + 1]});
+  }
+  for (const [path, {part, slides: numbers}] of covered) report({code: 'furniture-on-slide', path, message: `Slide content overlaps the ${part.kind} ${part.zone} ${part.field} on slide${numbers.length > 1 ? 's' : ''} ${numbers.join(', ')}. PowerPoint draws slide master and layout shapes beneath slide content, so there this part stays a shape on the slide, drawn above the content as in the preview.`});
+
+  // 2. Per slide master: the master's parts, each slide's layout key, and the layouts to create.
+  const value = (plan, slot) => plan.candidates.get(slot)?.signature;
+  const free = (plan, slot) => plan.candidates.has(slot) && !plan.pinned.has(slot);
+  const id = (slot, signature) => `${slot}\u0000${signature}`;
+  const assignments = [];
+  for (const master of [...new Set(plans.map(plan => plan.master))]) {
+    const group = plans.filter(plan => plan.master === master);
+    const showing = group.filter(plan => plan.candidates.size);
+    // The master holds the parts drawn the same on every slide that shows liftable furniture.
+    let common = showing.length >= 2 ? [...showing[0].candidates.keys()].filter(slot => showing.every(plan => value(plan, slot) === value(showing[0], slot))) : [];
+    if (!showing.some(plan => common.every(slot => free(plan, slot)))) common = [];
+    const counts = new Map();
+    for (const plan of group) for (const [slot, candidate] of plan.candidates) if (free(plan, slot)) counts.set(id(slot, candidate.signature), (counts.get(id(slot, candidate.signature)) ?? 0) + 1);
+    const layouts = new Map();
+    for (const plan of group) {
+      const showsMaster = plan.candidates.size ? common.every(slot => free(plan, slot)) : !common.length;
+      const extras = [...plan.candidates.keys()].filter(slot => free(plan, slot) && (showsMaster ? !common.includes(slot) && counts.get(id(slot, value(plan, slot))) >= 2
+        : common.includes(slot) || counts.get(id(slot, value(plan, slot))) >= 2)).sort();
+      const key = `${showsMaster ? 1 : 0}\u0001${extras.map(slot => id(slot, value(plan, slot))).join('\u0001')}`;
+      plan.extras = extras;
+      plan.lifted = new Map([...(showsMaster ? common.map(slot => [slot, 'master']) : []), ...extras.map(slot => [slot, 'layout'])]);
+      plan.layoutKey = showsMaster && !extras.length ? undefined : key;
+      if (plan.layoutKey !== undefined && !layouts.has(key)) layouts.set(key, {showsMaster, source: plan, slides: []});
+      if (plan.layoutKey !== undefined) layouts.get(key).slides.push(plan);
+    }
+    assignments.push({master, group, common, layouts});
+  }
+  if (!assignments.some(item => item.common.length || item.layouts.size)) return;
+
+  // 3. Write: the master's shapes, the new layouts, and each slide without its lifted shapes.
+  const tagPart = n => `ppt/tags/opfFurnitureShared${n}.xml`;
+  let tagNumber = 0, nextLayout = Math.max(0, ...Object.keys(output).map(path => Number(/^ppt\/slideLayouts\/slideLayout(\d+)\.xml$/.exec(path)?.[1] ?? 0))) + 1;
+  const presentation = read('ppt/presentation.xml');
+  const usedIds = [...presentation.matchAll(/<p:sldMasterId\b[^>]*\bid="(\d+)"/g), ...Object.keys(output).filter(path => /^ppt\/slideMasters\/slideMaster\d+\.xml$/.test(path))
+    .flatMap(path => [...read(path).matchAll(/<p:sldLayoutId\b[^>]*\bid="(\d+)"/g)])].map(match => Number(match[1]));
+  let nextLayoutId = Math.max(2147483648, ...usedIds) + 1;
+  const pending = new Map(); // part path -> {xml, rels}
+  const partXml = path => pending.get(path)?.xml ?? read(path);
+  const partRels = path => pending.get(path)?.rels ?? (has(relsOf(path)) ? read(relsOf(path)) : `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>`);
+  const stage = (path, xml, relsXml) => pending.set(path, {xml, rels: relsXml});
+  const relationshipId = (relsXml, type, target, external) => {
+    const existing = relationships(relsXml).find(rel => rel.type === type && rel.target === target && rel.external === external);
+    if (existing) return {relsXml, rid: existing.id};
+    const taken = new Set(relationships(relsXml).map(rel => rel.id));
+    let n = 1, rid;
+    do rid = `rId${n++}`; while (taken.has(rid));
+    return {rid, relsXml: relsXml.replace('</Relationships>', `<Relationship Id="${rid}" Type="${type}" Target="${escapeAttribute(target)}"${external ? ' TargetMode="External"' : ''}/></Relationships>`)};
+  };
+
+  // Copy one slide's shapes of a slot into a master or layout, with its relationships and a slot tag.
+  const transplant = (target, plan, slot) => {
+    const candidate = plan.candidates.get(slot);
+    let xml = partXml(target), relsXml = partRels(target);
+    let nextId = Math.max(0, ...[...xml.matchAll(/<p:cNvPr\b[^>]*\bid="(\d+)"/g)].map(match => Number(match[1]))) + 1;
+    const copies = candidate.shapes.map((shape, line) => {
+      let copy = shape.xml;
+      // The tag: the slide record with the slot in place of the slide's group and part.
+      const tagId = copy.match(/<p:custDataLst>\s*<p:tags r:id="([^"]+)"\/>\s*<\/p:custDataLst>/)?.[1];
+      copy = copy.replace(/<p:custDataLst>[\s\S]*?<\/p:custDataLst>/g, '');
+      copy = copy.replace(RELATIONSHIP_ATTRIBUTE, (match, kind, rid) => {
+        if (!rid) return match;
+        const rel = rels(plan.slide.path).find(item => item.id === rid);
+        if (!rel) throw new Error(`Furniture shape relationship ${rid} is missing.`);
+        const result = relationshipId(relsXml, rel.type, rel.external ? rel.target : relativeTarget(target, resolvePart(plan.slide.path, rel.target)), rel.external);
+        relsXml = result.relsXml;
+        return `r:${kind}="${result.rid}"`;
+      });
+      const tagRel = tagId && rels(plan.slide.path).find(item => item.id === tagId);
+      if (tagRel) {
+        const source = resolvePart(plan.slide.path, tagRel.target), record = decodeTextTag(read(source).match(/\bval="([^"]*)"/)[1]);
+        const {group, part, ...rest} = record;
+        const path = tagPart(++tagNumber);
+        output[path] = [enc.encode(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?><p:tagLst xmlns:p="${NS}"><p:tag name="${TAG}" val="${encodeTextTag({...rest, slot})}"/></p:tagLst>`), options];
+        types = types.replace('</Types>', `<Override PartName="/${path}" ContentType="${TAGS_TYPE}"/></Types>`);
+        const result = relationshipId(relsXml, `${REL}/tags`, relativeTarget(target, path), false);
+        relsXml = result.relsXml;
+        copy = copy.replace(/<p:nvPr\s*\/>/, '<p:nvPr></p:nvPr>').replace('</p:nvPr>', `<p:custDataLst><p:tags r:id="${result.rid}"/></p:custDataLst></p:nvPr>`);
+      }
+      const name = `OPF furniture ${slot.replace(/\./g, ' ')}${candidate.part.type === 'text' ? ` line ${line}` : ''}`;
+      return copy.replace(/(<p:cNvPr\b[^>]*?\bid=")\d+(")/, `$1${nextId++}$2`).replace(/(<p:cNvPr\b[^>]*?\bname=")[^"]*(")/, `$1${escapeAttribute(name)}$2`);
+    });
+    const end = xml.lastIndexOf('</p:spTree>');
+    if (end < 0) throw new Error(`${target} has no shape tree.`);
+    stage(target, xml.slice(0, end) + copies.join('') + xml.slice(end), relsXml);
+  };
+
+  for (const {master, group, common, layouts} of assignments) {
+    const showing = group.find(plan => common.every(slot => free(plan, slot)) && plan.candidates.size);
+    for (const slot of common) transplant(master, showing, slot);
+    // The layout the slides use now (each master has one), copied once per layout key.
+    const base = group[0].layout;
+    let masterXml = partXml(master), masterRels = partRels(master);
+    let number = 0;
+    for (const layout of layouts.values()) {
+      const path = `ppt/slideLayouts/slideLayout${nextLayout++}.xml`;
+      const name = layout.source.extras.length ? `OPF furniture ${++number}` : 'OPF no furniture';
+      let xml = read(base).replace(/(<p:cSld\b[^>]*?\bname=")[^"]*(")/, `$1${escapeAttribute(name)}$2`);
+      if (!layout.showsMaster) xml = xml.replace(/<p:sldLayout\b[^>]*>/, open => `${open.slice(0, -1).replace(/\s+showMasterSp="[^"]*"/, '')} showMasterSp="0">`);
+      const baseRels = has(relsOf(base)) ? read(relsOf(base)) : '';
+      // A copied layout keeps only its master relationship; the furniture brings its own.
+      const masterRel = relationships(baseRels).find(rel => rel.type === `${REL}/slideMaster`);
+      if (!masterRel) throw new Error(`${base} has no slide master relationship.`);
+      stage(path, xml, `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${masterRel.node}</Relationships>`);
+      types = types.replace('</Types>', `<Override PartName="/${path}" ContentType="${LAYOUT_TYPE}"/></Types>`);
+      for (const slot of layout.source.extras) transplant(path, layout.source, slot);
+      const result = relationshipId(masterRels, `${REL}/slideLayout`, relativeTarget(master, path), false);
+      masterRels = result.relsXml;
+      if (!masterXml.includes('</p:sldLayoutIdLst>')) throw new Error(`${master} has no layout list.`);
+      masterXml = masterXml.replace('</p:sldLayoutIdLst>', `<p:sldLayoutId id="${nextLayoutId++}" r:id="${result.rid}"/></p:sldLayoutIdLst>`);
+      layout.path = path;
+    }
+    stage(master, masterXml, masterRels);
+
+    // Each slide: drop its lifted shapes (and what only they referenced), point it at its layout, and move the manifest entries.
+    for (const plan of group) {
+      if (!plan.lifted.size && plan.layoutKey === undefined) continue;
+      let xml = plan.xml, relsXml = read(relsOf(plan.slide.path));
+      // The relationships only the removed shapes used (their tags, pictures and links) go with them.
+      const released = new Set();
+      for (const slot of plan.lifted.keys()) for (const shape of plan.candidates.get(slot).shapes) {
+        for (const match of shape.xml.matchAll(RELATIONSHIP_ATTRIBUTE)) released.add(match[2]);
+        xml = xml.replace(shape.xml, '');
+      }
+      for (const rel of relationships(relsXml)) {
+        if (!released.has(rel.id) || new RegExp(`"${escapeRegExp(rel.id)}"`).test(xml)) continue;
+        relsXml = relsXml.replace(rel.node, '');
+        if (rel.type === `${REL}/tags`) {
+          const path = resolvePart(plan.slide.path, rel.target);
+          delete output[path];
+          types = types.replace(`<Override PartName="/${path}" ContentType="${TAGS_TYPE}"/>`, '');
+        }
+      }
+      if (plan.layoutKey !== undefined) {
+        const target = relativeTarget(plan.slide.path, layoutsFor(assignments, plan).path);
+        relsXml = relsXml.replace(/<Relationship\b[^>]*\/>/g, node => attribute(node, 'Type') === `${REL}/slideLayout` ? node.replace(/\sTarget="[^"]*"/, ` Target="${target}"`) : node);
+      }
+      moveManifestEntries(output, plan, read, write);
+      write(plan.slide.path, xml);
+      write(relsOf(plan.slide.path), relsXml);
+    }
+  }
+  for (const [path, {xml, rels: relsXml}] of pending) { write(path, xml); write(relsOf(path), relsXml); }
+  write('[Content_Types].xml', types);
+}
+
+function layoutsFor(assignments, plan) {
+  return assignments.find(item => item.group.includes(plan)).layouts.get(plan.layoutKey);
+}
+
+// The slide's manifest: each lifted part leaves `parts`, `definitions` (its flag), `templates` and `images` for `shared`, and the
+// remaining parts are renumbered in the slide's own shape tags, so an importer that does not know `shared` reads the slide as it is.
+function moveManifestEntries(output, plan, read, write) {
+  const path = `ppt/tags/opfFurnitureSlide${plan.slideIndex}.xml`;
+  if (!Object.hasOwn(output, path) || !plan.lifted.size) return;
+  const manifest = decodeTextTag(read(path).match(/\bval="([^"]*)"/)[1]);
+  const shared = {}, keep = [], renumber = new Map();
+  for (const [index, part] of manifest.parts.entries()) {
+    const slot = `${part.kind}.${part.zone}.${part.field}`, on = plan.lifted.get(slot);
+    if (!on) { renumber.set(index, keep.length); keep.push(part); continue; }
+    const zone = manifest.definitions[part.kind].value[part.zone];
+    const entry = {...part, on, flag: zone[part.field]};
+    delete zone[part.field];
+    const key = `${part.kind}.${part.zone}`;
+    if (part.field === 'text' && manifest.templates?.[key] !== undefined) { entry.template = manifest.templates[key]; delete manifest.templates[key]; }
+    if (part.field === 'image' && manifest.images?.[key] !== undefined) { entry.image = manifest.images[key]; delete manifest.images[key]; }
+    shared[slot] = entry;
+  }
+  for (const name of ['templates', 'images']) if (manifest[name] && !Object.keys(manifest[name]).length) delete manifest[name];
+  manifest.parts = keep;
+  manifest.shared = shared;
+  write(path, read(path).replace(/\bval="[^"]*"/, () => `val="${encodeTextTag(manifest)}"`));
+  // Renumber the slide's remaining furniture shape tags.
+  const slideRels = relationships(read(relsOf(plan.slide.path)));
+  const remaining = new Set(plan.slide.parts.filter(part => !plan.lifted.has(`${part.kind}.${part.zone}.${part.field}`)).flatMap(part => part.names));
+  for (const element of shapeElements(plan.xml)) {
+    if (!remaining.has(element.name)) continue;
+    const tagId = element.xml.match(/<p:custDataLst>\s*<p:tags r:id="([^"]+)"\/>/)?.[1];
+    const rel = tagId && slideRels.find(item => item.id === tagId);
+    if (!rel) continue;
+    const tag = resolvePart(plan.slide.path, rel.target);
+    const record = decodeTextTag(read(tag).match(/\bval="([^"]*)"/)[1]);
+    if (record.part === undefined || !renumber.has(record.part) || renumber.get(record.part) === record.part) continue;
+    write(tag, read(tag).replace(/\bval="[^"]*"/, () => `val="${encodeTextTag({...record, part: renumber.get(record.part)})}"`));
+  }
+}

package/dist/media-dedupe.js

@@ -13,6 +13,8 @@ const hashBytes = bytes => {
   h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
   return (h2 >>> 0).toString(16) + (h1 >>> 0).toString(16);
 };
+/** The content key of a media part's bytes: its length and hash (a bucket key; equal keys are confirmed byte for byte where it matters). */
+export const mediaKey = bytes => `${bytes.byteLength}:${hashBytes(bytes)}`;
 const sameBytes = (a, b) => a.byteLength === b.byteLength && a.every((value, index) => value === b[index]);
 const decoder = new TextDecoder(), encoder = new TextEncoder();