@openpresentation/opf-pptx 0.16.1 → 0.18.0

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();
 

package/dist/native-furniture.js

@@ -16,7 +16,7 @@
 // or where core would draw a default footer when no slide has one.
 
 import {XMLParser} from 'fast-xml-parser';
-import {DEFAULT_DATE_FORMAT, NATIVE_DATE_FIELDS, formatDate} from './furniture-fields.js';
+import {DEFAULT_DATE_FORMAT, NATIVE_DATE_FIELDS, formatDate, hasSlideNumberField, slideNumberTemplate} from './furniture-fields.js';
 
 const enc = new TextEncoder(), dec = new TextDecoder('utf-8', {fatal: true});
 const parser = new XMLParser({ignoreAttributes: false, attributeNamePrefix: '', parseTagValue: false, trimValues: false});
@@ -28,25 +28,33 @@ const EMU = 9525;
 export const NATIVE_PLACEHOLDERS = Object.freeze({
   dt: {field: 'date', name: 'Date Placeholder', sz: 'half', idx: 10, masterIdx: 2, zone: 'left', align: 'l'},
   ftr: {field: 'text', name: 'Footer Placeholder', sz: 'quarter', idx: 11, masterIdx: 3, zone: 'center', align: 'ctr'},
-  sldNum: {field: 'slideNumber', name: 'Slide Number Placeholder', sz: 'quarter', idx: 12, masterIdx: 4, zone: 'right', align: 'r'},
+  sldNum: {field: 'text', name: 'Slide Number Placeholder', sz: 'quarter', idx: 12, masterIdx: 4, zone: 'right', align: 'r'},
 });
 const ORDER = ['dt', 'ftr', 'sldNum'];
-const phByField = {date: 'dt', text: 'ftr', slideNumber: 'sldNum'};
 export const isNativePlaceholderType = value => Object.hasOwn(NATIVE_PLACEHOLDERS, value);
-export const nativePlaceholderForField = field => phByField[field];
+/**
+ * The placeholder type a core footer part maps to: a date is `dt`; a zone `text` with a slide-number field
+ * (`{{slide.number}}`) is `sldNum`, its words around the field fixed runs; any other zone `text` is `ftr`.
+ */
+export function nativePlaceholderForPart(part) {
+  if (part.type !== 'text') return undefined;
+  if (part.field === 'date') return 'dt';
+  if (part.field !== 'text') return undefined;
+  return hasSlideNumberField(part) ? 'sldNum' : 'ftr';
+}
 const ZONES = ['left', 'center', 'right'];
 const ALIGN = {left: 'l', center: 'ctr', right: 'r'};
 
 /**
  * Which accepted core parts of one slide become native placeholders: the first
- * footer text, the first footer date and the first footer slide number whose
- * text fits one accepted line. Returns Map<partIndex, 'dt'|'ftr'|'sldNum'>.
+ * footer text, the first footer date and the first footer text with a slide-number
+ * field whose text fits one accepted line. Returns Map<partIndex, 'dt'|'ftr'|'sldNum'>.
  */
 export function nativeFurnitureParts(layout) {
   const chosen = new Map(), taken = new Set();
   for (const [index, part] of (layout?.parts ?? []).entries()) {
-    const ph = phByField[part.field];
-    if (part.kind !== 'footer' || part.type !== 'text' || !ph || taken.has(ph)) continue;
+    const ph = nativePlaceholderForPart(part);
+    if (part.kind !== 'footer' || !ph || taken.has(ph)) continue;
     // One native shape holds one line; a part that wraps or breaks stays tagged shapes.
     if (part.fit?.sourceLines?.length !== 1 || part.fit.lines?.length !== 1 || !part.text || part.links?.length) continue;
     taken.add(ph);
@@ -70,9 +78,10 @@ const guid = (kind, n) => `{0F0F2701-${kind}-4000-8000-${n.toString(16).toUpperC
  * maps a generated object name to its placeholder type. Runs after the tags are
  * attached: the shape keeps its name, geometry, runs, fields and tags, and gains
  * `p:ph` (a placeholder is a text shape the layout can supply defaults for).
+ * `bands` maps a generated object name to its zone's band (`{x, width}` in pixels) for a part narrower than its zone.
  * Returns the placeholders in use and the first geometry/alignment seen per type.
  */
-export function attachNativePlaceholders(entries, records) {
+export function attachNativePlaceholders(entries, records, bands = new Map()) {
   const used = new Set(), first = new Map(), seen = new Set();
   if (!records.size) return {used, first};
   const slides = Object.keys(entries).filter(path => /^ppt\/slides\/slide\d+\.xml$/.test(path)).sort((a, b) => Number(a.match(/\d+/)[0]) - Number(b.match(/\d+/)[0]));
@@ -93,7 +102,10 @@ export function attachNativePlaceholders(entries, records) {
       if (!first.has(ph)) {
         const geometry = shape.match(/<a:off x="(-?\d+)" y="(-?\d+)"\/><a:ext cx="(\d+)" cy="(\d+)"\/>/);
         const algn = shape.match(/<a:pPr\b[^>]*\balgn="(\w+)"/)?.[1] ?? 'l';
-        if (geometry) first.set(ph, {x: Number(geometry[1]), y: Number(geometry[2]), cx: Number(geometry[3]), cy: Number(geometry[4]), algn});
+        // A part in a zone with other parts (a logo beside the footer text) is only as wide as its text (RR-71); the master and
+        // layout placeholders a footer added natively lands in use the zone's whole band at the same edge.
+        const band = bands.get(name);
+        if (geometry) first.set(ph, {x: band ? Math.round(band.x * EMU) : Number(geometry[1]), y: Number(geometry[2]), cx: band ? Math.round(band.width * EMU) : Number(geometry[3]), cy: Number(geometry[4]), algn});
       }
       changed = true;
       return shape;
@@ -252,8 +264,9 @@ function zoneOf(bounds, slideWidth, fallback) {
 /**
  * The footer one slide's native placeholders describe. `claimed` is the set of
  * shape indexes OPF provenance already consumed or reserved. Returns
- * {fields: [{zone, field, value, settings, index}], skipped: [index]} where `value`
- * is the OPF field value and `settings` the zone's `dateFormat`/`slideNumberFormat`.
+ * [{zone, field, value, settings, index, ph}] where `value` is the OPF field value (a zone
+ * `text` carries `{{slide.number}}` where the placeholder holds a native slide-number field)
+ * and `settings` the zone's `dateFormat`.
  */
 export function readNativePlaceholders(context, claimed, relationships, readPart) {
   const fields = [];
@@ -262,36 +275,44 @@ export function readNativePlaceholders(context, claimed, relationships, readPart
     if (!isNativePlaceholderType(ph) || claimed.has(index)) continue;
     const paragraphs = context.paragraphs[index] ?? [];
     const text = paragraphs.map(paragraph => paragraph.text).join('\n');
-    const nativeFields = paragraphs.flatMap(paragraph => paragraph.fields ?? []);
+    // The native fields with their offsets into `text` (the paragraphs are joined by a newline).
+    const nativeFields = [];
+    let base = 0;
+    for (const paragraph of paragraphs) {
+      for (const field of paragraph.fields ?? []) nativeFields.push({...field, start: base + (field.start ?? text.indexOf(field.text, base) - base)});
+      base += paragraph.text.length + 1;
+    }
     const zone = zoneOf(inheritedBounds(shape, ph, context.path, relationships, readPart), context.slideWidth, NATIVE_PLACEHOLDERS[ph].zone);
     const properties = NATIVE_PLACEHOLDERS[ph];
     if (ph === 'sldNum') {
-      const live = nativeFields.filter(field => field.type === 'slidenum');
-      if (live.length !== 1) continue;
-      const at = text.indexOf(live[0].text);
-      const format = at < 0 ? undefined : text.slice(0, at) + '{current}' + text.slice(at + live[0].text.length);
-      fields.push({index, zone, field: properties.field, value: true, settings: format && format !== '{current}' ? {slideNumberFormat: format} : {}});
+      // The words around a native slide-number field are the zone text and the field is `{{slide.number}}`.
+      if (!nativeFields.some(field => field.type === 'slidenum')) continue;
+      fields.push({index, zone, ph, field: properties.field, value: slideNumberTemplate(text, nativeFields), settings: {}});
     } else if (ph === 'dt') {
       if (!text.trim()) continue;
       const pattern = nativeFields.length === 1 && nativeFields[0].text === text ? dateFormatForField[nativeFields[0].type] : undefined;
-      if (pattern) fields.push({index, zone, field: properties.field, value: true, settings: pattern === DEFAULT_DATE_FORMAT ? {} : {dateFormat: pattern}});
+      if (pattern) fields.push({index, zone, ph, field: properties.field, value: true, settings: pattern === DEFAULT_DATE_FORMAT ? {} : {dateFormat: pattern}});
       // A fixed date, or a field with no OPF pattern (a time, the master's datetimeFigureOut), keeps its current words.
-      else fields.push({index, zone, field: properties.field, value: text, settings: {}});
+      else fields.push({index, zone, ph, field: properties.field, value: text, settings: {}});
     } else {
       if (!text.trim()) continue;
-      fields.push({index, zone, field: properties.field, value: text, settings: {}});
+      fields.push({index, zone, ph, field: properties.field, value: slideNumberTemplate(text, nativeFields), settings: {}});
     }
   }
   return fields;
 }
 
-/** The OPF footer value for native placeholder fields: zones keyed left/center/right. */
+/**
+ * The OPF footer value for native placeholder fields: zones keyed left/center/right. A footer text and a slide
+ * number in one zone are one `text`: the footer words, then the number's line (the zone stack's order).
+ */
 export function footerValue(fields) {
   const value = {};
-  for (const item of fields) {
+  for (const item of [...fields].sort((a, b) => ORDER.indexOf(a.ph) - ORDER.indexOf(b.ph))) {
     value[item.zone] ??= {};
-    value[item.zone][item.field] = item.value;
-    Object.assign(value[item.zone], item.settings);
+    const zone = value[item.zone];
+    zone[item.field] = item.field === 'text' && typeof zone.text === 'string' ? `${zone.text}\n${item.value}` : item.value;
+    Object.assign(zone, item.settings);
   }
   return Object.fromEntries(ZONES.filter(zone => value[zone]).map(zone => [zone, value[zone]]));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -54,7 +54,7 @@
     "test:metric": "node test/shared-metric.mjs && node test/metric-provenance.mjs",
     "test:font-variants": "node test/font-variants.mjs",
     "test:timeline": "node test/shared-timeline.mjs",
-    "test:furniture": "node test/shared-furniture.mjs && node test/furniture-provenance.mjs && node test/furniture-fields.mjs && node test/furniture-wrapped-date.mjs && node test/socials-furniture.mjs && node test/native-furniture.mjs",
+    "test:furniture": "node test/shared-furniture.mjs && node test/furniture-provenance.mjs && node test/slide-variables.mjs && node test/furniture-fields.mjs && node test/furniture-wrapped-date.mjs && node test/socials-furniture.mjs && node test/native-furniture.mjs",
     "test:native-picture-edit-controls": "node test/compare-native-picture-edit-controls.mjs",
     "test:native-font-embed-controls": "node test/native-font-embed-controls.mjs",
     "test:native-mixed-edit-controls": "node test/native-mixed-edit-controls.mjs",
@@ -65,7 +65,7 @@
   },
   "dependencies": {
     "@node-projects/jszip": "4.3.0",
-    "@openpresentation/opf": "^0.16.0",
+    "@openpresentation/opf": "^0.18.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.16.0"
+    "@openpresentation/opf-render": "^0.18.0"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -92,7 +92,7 @@
     "@expo-google-fonts/roboto": "0.4.3",
     "@expo-google-fonts/roboto-mono": "0.4.2",
     "@expo-google-fonts/tinos": "0.4.2",
-    "@openpresentation/opf-render": "0.16.0",
+    "@openpresentation/opf-render": "0.18.0",
     "@resvg/resvg-js": "2.6.2",
     "esbuild": "0.28.2",
     "playwright": "1.63.0"