@openpresentation/opf-pptx 0.2.0 → 0.3.0

package/README.md

@@ -121,7 +121,9 @@ Pass the same `textMeasurement` provider used by preview and pagination to `toPp
 
 PptxGenJS is pinned to 4.0.1. Its unused `image-size` dependency remains flagged by npm audit; tested OPF operations run with that parser blocked. See [dependency reachability and regression coverage](DEPENDENCY-NOTES.md).
 
-### Native table fitting (unreleased)
+### Native table fitting
+
+Core 0.5.0 accepts `TextRun[]` cells and headers. The 0.3.0 exporter preserves their resolved fonts, emphasis, color/alpha, hyperlinks, script positions and explicit line breaks as editable native runs. It measures rich content before export without inserting measured soft wraps. These changes are not in 0.2.1; version 0.3.0 requires core 0.5.0 and renderer 0.3.0. Native table import still flattens rich runs to strings, and native PowerPoint rendering remains unverified.
 
 The development exporter measures every cell with the same `textMeasurement` provider, font roles and effective nested `minFontSize` used by the SVG preview. Native table cells retain the original strings and values as text, with matching fitted sizes, line spacing, alignment, margins and row/column geometry. Uneven rows receive empty cells for missing columns. Theme border colors now use the same slot as the preview.
 
@@ -160,7 +162,7 @@ Fixed solid and linear-gradient backgrounds now export as native slide fills, ke
 
 Diagonal gradients require a coordinate conversion: the preview uses an SVG object-bounding-box gradient, while native unscaled DrawingML angles use slide coordinates. Export converts both the physical gradient direction and stop interval. Tests compare 990 sample positions from serialized SVG/native properties across 33 gradients and three aspect ratios, plus solid opacity, inheritance, native edits and repeated imports/exports. Integer native angles/positions introduce small rounding differences. The mapping follows the [DrawingML linear-gradient angle definition](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.drawing.lineargradientfill?view=openxml-3.0.1).
 
-Import reads supported native RGB solid/linear fills directly; it uses no hidden source copy. Uniform alpha becomes OPF background opacity, and differing stop alpha uses eight-bit RGBA colors (which can round alpha). Native path gradients, transformed/theme stop colors, non-default tile/flip geometry and stop intervals outside OPF's fixed-endpoint representation are not imported. Pass `fromPptx(bytes, {onDiagnostic: issue => ...})` to observe `unsupported-background-gradient` with a slide path.
+Import reads supported native RGB solid/linear fills directly; it uses no hidden source copy. Uniform alpha becomes OPF background opacity, and differing stop alpha uses eight-bit RGBA colors (which can round alpha). Native path gradients, color transforms outside the supported luminance/alpha set, non-default tile/flip geometry and stop intervals outside OPF's fixed-endpoint representation are not imported. Pass `fromPptx(bytes, {onDiagnostic: issue => ...})` to observe `unsupported-background-gradient` with a slide path.
 
 Node 20/24 tests and the 126-deck / 805-slide structural corpus pass. This proves serialization and the mathematical mapping, not native viewer pixels. Keynote 14.4 recognizes the editable native gradients. Twelve captured native PNGs now support 18 comparisons, including a Keynote-generated PPTX import: opaque differences are at most 4/255 per channel (mean below 0.38), and transparent portrait alpha differs by at most 1/255. The checked-in references run in ordinary Node tests without Keynote. Quick Look still renders these specimens as a flat average color, so its thumbnails are not evidence of their native appearance. Microsoft PowerPoint remains unavailable and unverified. Pattern/image backgrounds, theme-aware native fills, and other design decorations remain separate fidelity work.
 
@@ -173,6 +175,16 @@ When a JPEG has no orientation tag, import either adds a minimal EXIF segment or
 
 This preserves image orientation, not arbitrary picture geometry. Crop windows, non-quarter-turn rotations, non-JPEG rotations/mirroring and unsupported EXIF structures retain their original image bytes and report `unsupported-image-crop` or `unsupported-image-orientation` through `FromPptxOptions.onDiagnostic`. Picture diagnostic paths identify native picture order, for example `slides.0.pictures.0`. Import still recomposes OPF layout and does not promise exact native placement, crop, effects, groups or full picture round-trip fidelity. Third-party native viewers may handle already-oriented embedded JPEGs differently; the metadata-before-native composition is the importer contract, not a cross-viewer parity claim.
 
+### Inherited native backgrounds (0.2.1)
+
+Since 0.2.1, the importer follows slide → layout → master background inheritance. An explicit slide background, including no-fill or an unsupported fill, takes precedence over inherited content. Solid and representable linear fills resolve theme slots through the master color map and layout/slide overrides; system colors use the saved `lastClr` fallback. Theme overrides can replace the color scheme or format scheme. Background style references use the original XML order in `fillStyleLst`/`bgFillStyleLst`, including placeholder colors and alpha. Theme-slot OPF exports also retain background opacity.
+
+The 0.2.1 importer applies `lum`, `lumMod`, `lumOff`, `alpha`, `alphaMod` and `alphaOff` in XML order, including repeated/interleaved transforms in theme definitions, style placeholders and gradient stops. Following DrawingML’s [luminance modulation](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.drawing.luminancemodulation?view=openxml-3.0.1) and [luminance offset](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.drawing.luminanceoffset?view=openxml-3.0.1) semantics, luminance adjustments retain hue and saturation, and opacity operations clamp after each step. Colors are rounded to RGB only after the full reference/transform chain. Tint/shade, saturation/hue, gamma and other transforms still produce diagnostics. The regression suite covers 70 inheritance, transform and diagnostic cases; these mathematical tests do not establish native viewer pixel parity.
+
+These colors become explicit editable OPF RGB fills. Import does not preserve a live link to the original PowerPoint master/theme. No external theme URL is fetched. Missing themes, unknown colors, unsupported color transforms, and unsupported image/pattern fills report `unsupported-background-fill` (or `unsupported-background-gradient` for gradients) at the slide background path.
+
+The regression fixtures cover inheritance, overrides, interleaved style lists, repeated export/import, source preservation and observable failures. The style indexes follow the [Open XML background-reference definition](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.presentation.backgroundstylereference?view=openxml-3.0.1). They prove conversion semantics, not universal native appearance. Keynote displayed a fixture referencing `fillStyleLst` index 2 as white; native comparison of other reference forms is still incomplete. Microsoft PowerPoint remains unverified. This work is not included in npm 0.2.0.
+
 Native dimensions retain full precision through import. Premature six-decimal inch rounding could change raster edges even on a 1280-pixel slide. With the local JPEG-aware renderer, all eight complete image-slide PNG previews now match their original OPF previews after native export/import; this remains an OPF-renderer comparison, not a native viewer pixel comparison.
 
 Background-only and empty slides now remain blank during PPTX import; the importer no longer inserts a synthetic “Slide N” title. Speaker notes remain separate from visible content. Native fixture verification covers this behavior using an actual Keynote-exported presentation.

package/dist/background-import.js

@@ -0,0 +1,88 @@
+import {XMLParser} from 'fast-xml-parser';
+import {readNativeBackground, readBackgroundColor, colorTransforms} from './background.js';
+
+const orderedParser = new XMLParser({ignoreAttributes: false, attributeNamePrefix: '', preserveOrder: true, parseAttributeValue: false, parseTagValue: false});
+const defaultMapping = {bg1:'lt1',tx1:'dk1',bg2:'lt2',tx2:'dk2'};
+const children = (nodes, name) => nodes?.find(node => Object.hasOwn(node, name))?.[name];
+function object(nodes) {
+  const result = Object.create(null);
+  for (const node of nodes ?? []) for (const [name, value] of Object.entries(node)) {
+    if (name === ':@' || name === '#text') continue;
+    const child = {...(node[':@'] ?? {}), ...object(value)};
+    if (['a:srgbClr', 'a:sysClr', 'a:schemeClr'].includes(name)) {
+      child[colorTransforms] = (value ?? []).flatMap(item => Object.keys(item)
+        .filter(key => key !== ':@' && key !== '#text')
+        .map(key => [key, {...(item[':@'] ?? {}), ...object(item[key])}]));
+    }
+    if (Object.hasOwn(result, name)) result[name] = Array.isArray(result[name]) ? [...result[name], child] : [result[name], child];
+    else result[name] = child;
+  }
+  return result;
+}
+
+// Cache by archive entry identity. Weak keys release parsed themes when the
+// input archive is collected and avoid reparsing a shared master for every slide.
+const parsedParts = new WeakMap();
+function parsed(bytes, parse) {
+  if (!bytes) return undefined;
+  if (!parsedParts.has(bytes)) {
+    const tree = parse();
+    parsedParts.set(bytes, {tree, value: object(tree)});
+  }
+  return parsedParts.get(bytes);
+}
+
+// Resolve only relationships inside the input archive; never fetch theme URLs.
+export function importBackground(slidePath, dimensions, {part, relationships, bytes}, report) {
+  const parsedPart = path => parsed(bytes(path), () => part(path, orderedParser));
+  const value = path => parsedPart(path)?.value;
+  const related = (path, type) => [...relationships(path).values()].find(rel => rel.type.endsWith('/' + type) && bytes(rel.path))?.path;
+  const layoutPath = related(slidePath, 'slideLayout');
+  const masterPath = layoutPath && related(layoutPath, 'slideMaster');
+  const chain = [[slidePath, 'p:sld'], [layoutPath, 'p:sldLayout'], [masterPath, 'p:sldMaster']]
+    .filter(([path]) => path).map(([path, root]) => ({path, root:value(path)?.[root]}));
+  const master = chain.find(item => item.root?.['p:clrMap'])?.root;
+  const masterMapping = {...defaultMapping, ...master?.['p:clrMap']};
+  let mapping = masterMapping;
+  for (const {root} of [...chain].reverse()) {
+    const override = root?.['p:clrMapOvr'];
+    if (override?.['a:overrideClrMapping']) mapping = {...defaultMapping, ...override['a:overrideClrMapping']};
+    else if (override && Object.hasOwn(override, 'a:masterClrMapping')) mapping = masterMapping;
+  }
+  let colors, format, formatPath;
+  for (const {path} of [...chain].reverse()) {
+    for (const type of ['theme', 'themeOverride']) {
+      const themePath = related(path, type);
+      if (!themePath) continue;
+      const doc = value(themePath);
+      const elements = type === 'theme' ? doc?.['a:theme']?.['a:themeElements'] : doc?.['a:themeOverride'];
+      if (elements?.['a:clrScheme']) colors = elements['a:clrScheme'];
+      if (elements?.['a:fmtScheme']) {format = elements['a:fmtScheme'];formatPath = themePath;}
+    }
+  }
+  const background = chain.map(item => item.root?.['p:cSld']?.['p:bg']).find(value => value !== undefined);
+  if (!background) return undefined;
+  const unsupported = () => {
+    report({code:'unsupported-background-fill',message:'The native background style reference or its theme color could not be resolved from this PPTX archive.'});
+    return undefined;
+  };
+  const context = {colors, mapping};
+  if (background['p:bgPr']) return readNativeBackground(background['p:bgPr'], dimensions, report, context);
+  const reference = background['p:bgRef'];
+  if (!/^\d+$/.test(reference?.idx ?? '')) return unsupported();
+  const index = Number(reference?.idx);
+  if (!Number.isInteger(index) || index < 0) return unsupported();
+  if (index === 0 || index === 1000) return {type:'solid',color:'#FFFFFF',opacity:0};
+  if (!format || !formatPath) return unsupported();
+  // Fill lists can interleave solid, gradient and image fills. Preserve XML
+  // child order when indexing them; the normal object parser groups tag names.
+  const tree = parsedPart(formatPath).tree;
+  const theme = children(tree, 'a:theme');
+  const elements = theme ? children(theme, 'a:themeElements') : children(tree, 'a:themeOverride');
+  const fmt = children(elements, 'a:fmtScheme');
+  const styles = children(fmt, index < 1000 ? 'a:fillStyleLst' : 'a:bgFillStyleLst')?.filter(node => Object.keys(node).some(k => k !== '#text' && k !== ':@'));
+  const style = styles?.[index < 1000 ? index - 1 : index - 1001];
+  if (!style) return unsupported();
+  context.placeholder = readBackgroundColor(reference, context);
+  return readNativeBackground(object([style]), dimensions, report, context);
+}

package/dist/background.js

@@ -20,7 +20,7 @@ export function nativeBackgroundFill(background, {width, height}, fallback = 'FF
   if (typeof background === 'string' && /^#[\da-f]{3}(?:[\da-f]{3}(?:[\da-f]{2})?)?$/i.test(background)) background = {type: 'solid', color: background};
   if (!background || typeof background !== 'object') return null;
   const opacity = background.opacity ?? 1;
-  if (background.type === 'solid') return `<a:solidFill>${colorXml(background.color, opacity, fallback)}</a:solidFill>`;
+  if (background.type === 'solid' || background.type === 'theme') return `<a:solidFill>${colorXml(background.type === 'theme' ? fallback : background.color, opacity, fallback)}</a:solidFill>`;
   if (background.type !== 'gradient') return null;
   const stops = background.gradient?.stops ?? [];
   if (!stops.length) return '<a:noFill/>';
@@ -38,21 +38,76 @@ export function nativeBackgroundFill(background, {width, height}, fallback = 'FF
   return `<a:gradFill rotWithShape="0"><a:gsLst>${nativeStops}</a:gsLst><a:lin ang="${angle}" scaled="0"/></a:gradFill>`;
 }
 
-function readColor(node) {
-  const c = node?.['a:srgbClr'];
-  if (!c || !/^[\da-f]{6}$/i.test(c.val) || Object.keys(c).some(k => k !== 'val' && k !== 'a:alpha')) return null;
-  const alpha = Number(c['a:alpha']?.val ?? 100000) / 100000;
-  if (!Number.isFinite(alpha) || alpha < 0 || alpha > 1) return null;
-  return {hex: '#' + c.val.toUpperCase(), alpha};
+// Internal metadata supplied by the ordered XML reader. A Symbol cannot collide
+// with a document attribute, and repeated transforms keep their original order.
+export const colorTransforms = Symbol('DrawingML color transforms');
+const transformNames = new Set(['a:alpha', 'a:alphaMod', 'a:alphaOff', 'a:lum', 'a:lumMod', 'a:lumOff']);
+function luminanceColor(hex) {
+  const rgb = hex.match(/../g).map(value => parseInt(value, 16) / 255);
+  const max = Math.max(...rgb), min = Math.min(...rgb), l = (max + min) / 2, delta = max - min;
+  // Retain hue/saturation across consecutive luminance changes, even when an
+  // intermediate luminance clips to black or white.
+  return {l, saturation: delta === 0 ? 0 : delta / (1 - Math.abs(2 * l - 1)), direction: rgb.map(c => delta ? (c - l) / delta : 0)};
+}
+function luminanceHex({l, saturation, direction}) {
+  const chroma = (1 - Math.abs(2 * l - 1)) * saturation;
+  return '#' + direction.map(c => Math.round(clamp(l + c * chroma) * 255).toString(16).padStart(2, '0')).join('').toUpperCase();
+}
+export function readBackgroundColor(node, context = {}, seen = new Set()) {
+  const kinds = ['a:srgbClr', 'a:sysClr', 'a:schemeClr'].filter(k => node?.[k]);
+  if (kinds.length !== 1) return null;
+  const kind = kinds[0], c = node[kind];
+  if (Array.isArray(c) || Object.keys(c).some(k => !['val', 'lastClr'].includes(k) && !transformNames.has(k))) return null;
+  const entries = Object.entries(c).filter(([key]) => key.startsWith('a:'));
+  // The legacy object shape is safe for one transform only. Never guess the
+  // order of repeated/interleaved operations after an unordered parser.
+  const transforms = c[colorTransforms] ?? (entries.length <= 1 && entries.every(([,value]) => !Array.isArray(value)) ? entries : null);
+  if (!transforms) return null;
+  let resolved;
+  if (kind === 'a:schemeClr') {
+    if (c.val === 'phClr') resolved = context.placeholder;
+    else {
+      const slot = context.mapping?.[c.val] ?? c.val;
+      if (seen.has(slot)) return null;
+      resolved = readBackgroundColor(context.colors?.['a:' + slot], context, new Set([...seen, slot]));
+    }
+  } else {
+    const hex = kind === 'a:sysClr' ? c.lastClr : c.val;
+    if (!/^[\da-f]{6}$/i.test(hex ?? '')) return null;
+    resolved = {hex: '#' + hex.toUpperCase(), alpha: 1, luminance: luminanceColor(hex)};
+  }
+  if (!resolved) return null;
+  let alpha = resolved.alpha;
+  const luminance = {...(resolved.luminance ?? luminanceColor(resolved.hex.slice(1)))};
+  for (const [name, attributes] of transforms) {
+    if (!transformNames.has(name) || !attributes || Object.keys(attributes).some(key => key !== 'val')) return null;
+    const raw = attributes.val;
+    if (!/^[+-]?\d+$/.test(raw ?? '')) return null;
+    const value = Number(raw) / 100000;
+    if (!Number.isFinite(value)) return null;
+    if ((name === 'a:alpha' || name === 'a:lum') && (value < 0 || value > 1)) return null;
+    if (name === 'a:alphaMod' && value < 0) return null;
+    if (name === 'a:alphaOff' && Math.abs(value) > 1) return null;
+    if (name === 'a:alpha') alpha = value;
+    if (name === 'a:alphaMod') alpha = clamp(alpha * value);
+    if (name === 'a:alphaOff') alpha = clamp(alpha + value);
+    if (name === 'a:lum') luminance.l = value;
+    if (name === 'a:lumMod') luminance.l = clamp(luminance.l * value);
+    if (name === 'a:lumOff') luminance.l = clamp(luminance.l + value);
+  }
+  return {hex: luminanceHex(luminance), alpha, luminance};
 }
 
-export function readNativeBackground(properties, {width, height}, report = () => {}) {
+export function readNativeBackground(properties, {width, height}, report = () => {}, context = {}) {
   if (!properties) return undefined;
   if (Object.hasOwn(properties, 'a:noFill')) return {type: 'solid', color: '#FFFFFF', opacity: 0};
-  const solid = readColor(properties['a:solidFill']);
+  const solid = readBackgroundColor(properties['a:solidFill'], context);
   if (solid) return {type: 'solid', color: solid.hex, ...(solid.alpha === 1 ? {} : {opacity: solid.alpha})};
   const gradient = properties['a:gradFill'];
-  if (!gradient) return undefined;
+  if (!gradient) {
+    report({code: 'unsupported-background-fill', message: 'This native background fill or color cannot be represented by the OPF background importer.'});
+    return undefined;
+  }
   const unsupported = () => {
     report({code: 'unsupported-background-gradient', message: 'This native gradient uses geometry or color transforms outside the OPF linear-gradient contract; its background was not imported.'});
     return undefined;
@@ -67,7 +122,7 @@ export function readNativeBackground(properties, {width, height}, report = () =>
   const angle = turn(Math.atan2(height * Math.sin(radians), width * Math.cos(radians)) * 180 / Math.PI);
   const a = angle * Math.PI / 180, span = Math.abs(Math.cos(a)) + Math.abs(Math.sin(a));
   const stops = list(gradient['a:gsLst']?.['a:gs']).map(stop => {
-    const c = readColor(stop), position = (Number(stop.pos) / 100000 - .5) * span + .5;
+    const c = readBackgroundColor(stop, context), position = (Number(stop.pos) / 100000 - .5) * span + .5;
     // Allow only native integer rounding, not a lossy clamping of arbitrary
     // corner-to-corner gradients that OPF's fixed endpoints cannot represent.
     if (!c || !Number.isFinite(position) || position < -.00002 || position > 1.00002) return null;

package/dist/index.js

@@ -1,8 +1,9 @@
 import {importImageOrientation} from './image-import.js';
-import {nativeBackgroundFill, readNativeBackground} from './background.js';
+import {nativeBackgroundFill} from './background.js';
+import {importBackground} from './background-import.js';
 import { webpToPng } from '#image-fallback';
 import { rasterMetadata, pictureTransform, normalizeImageOrientation } from './image-geometry.js';
-import { composeSlide, fitText, textWidthMeasurer, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle } from "@openpresentation/opf/composition";
+import { composeSlide, fitText, fitRichText, textWidthMeasurer, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle } from "@openpresentation/opf/composition";
 import PptxGenJS from "pptxgenjs";
 import { unzipSync, zipSync } from "fflate";
 import { XMLParser } from "fast-xml-parser";
@@ -250,13 +251,13 @@ function readPptxZip(input) {
   }
 }
 
-function parseRequiredXml(entries, path) {
+function parseRequiredXml(entries, path, parser = xmlParser) {
   const bytes = entries[path];
   if (!bytes) {
     throw new OPFPptxError("invalid-pptx", `PPTX is missing ${path}.`, { path });
   }
   try {
-    return xmlParser.parse(decodeText(bytes));
+    return parser.parse(decodeText(bytes));
   } catch (error) {
     throw new OPFPptxError("invalid-pptx", `PPTX XML part could not be parsed: ${path}.`, {
       path,
@@ -371,7 +372,9 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
   const slide = {};
   if (slideRoot.show === "0") slide.hidden = true;
 
-  const background = readNativeBackground(slideRoot["p:cSld"]?.["p:bg"]?.["p:bgPr"], resolveCanvasDimensions(dimensions), diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}.design.background`}));
+  const background = importBackground(slidePath, resolveCanvasDimensions(dimensions), {
+    part: (path, parser) => parseRequiredXml(entries, path, parser), relationships: path => parseRelationships(entries, path), bytes: path => entries[path]
+  }, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}.design.background`}));
   if (background) slide.design = {background};
 
   const items = collectSlideItems(entries, slideRoot, slidePath, relationships, dimensions, options, slideIndex)
@@ -1119,16 +1122,42 @@ function addTablePayload(slide, table, region, context, options, path) {
     const cellPath = header ? `${path}.columns.${columnIndex}` : `${path}.rows.${rowIndex - Number(hasHeaders)}.${columnIndex}`;
     const text = stringifyText(row[columnIndex]);
     const style = resolveTextStyle({ fontFamily: context.fonts.body, fontWeight: header ? 700 : 400, italic: false, path: cellPath }, options.textMeasurement);
-    const fit = fitText(text, cellBox, 15 * scale, (context.composition?.minFontSize ?? 16) * scale, textWidthMeasurer(style, options.textMeasurement));
+    const rich = Array.isArray(row[columnIndex]);
+    const fit = rich
+      ? fitRichText(row[columnIndex], cellBox, 15 * scale, (context.composition?.minFontSize ?? 16) * scale, {style,textMeasurement:options.textMeasurement})
+      : fitText(text, cellBox, 15 * scale, (context.composition?.minFontSize ?? 16) * scale, textWidthMeasurer(style, options.textMeasurement));
+    const fragments = rich ? fit.richLines.flatMap(line => line.fragments) : [];
+    const runs = rich ? row[columnIndex].flatMap((value, index) => {
+      const run = typeof value === 'string' ? {text:value} : value;
+      const fragment = fragments.find(item => item.runIndex === index);
+      const runStyle = fragment?.style ?? resolveTextStyle({...style,fontFamily:run.fontFamily ?? style.fontFamily,fontWeight:run.bold === undefined ? style.fontWeight : run.bold ? 700 : 400,italic:run.italic ?? style.italic}, options.textMeasurement);
+      const rawColor = /^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(run.color ?? '') ? run.color.slice(1) : header ? 'FFFFFF' : context.colors.text;
+      const color = normalizeHex(rawColor), transparency = rawColor.length === 8 ? (1 - parseInt(rawColor.slice(6), 16) / 255) * 100 : 0;
+      const runOptions = {
+        fontFace:runStyle.fontFamily,fontSize:fragment ? fragment.fontSize * .75 : fit.fontSize * .75,
+        bold:runStyle.fontWeight >= 600,italic:runStyle.italic,
+        underline:run.underline ? {color} : undefined,strike:run.strikethrough ? 'sngStrike' : undefined,
+        color,transparency,baseline:fragment?.baselineShift ? -fragment.baselineShift / fragment.fontSize * 2000 : undefined,
+        hyperlink:run.link && /^(https?:|mailto:)/i.test(run.link) ? {url:run.link} : undefined,
+      };
+      // PptxGenJS marks every part of a newline-containing run as a paragraph
+      // break, including its final part. Split explicitly so the next styled
+      // run stays on that final line, and preserve empty/trailing lines.
+      const parts = run.text.split(/\r*\n/);
+      return parts.map((text, part) => ({text,options:{...runOptions,breakLine:part < parts.length - 1}}));
+    }) : null;
     return {
       // Keep native wrapping and the original cell value: inserting measured
       // soft wraps into the text would change a later import or copy operation.
-      text,
+      text: rich ? runs : text,
       options: {
         fontFace: style.fontFamily,
         fontSize: fit.fontSize * 0.75,
-        bold: style.fontWeight >= 600,
-        italic: style.italic,
+        // PptxGenJS fills falsy run options from cell defaults. Rich runs
+        // carry their resolved weight, so a bold header default must not turn
+        // an explicit bold:false run back on.
+        bold: rich ? false : style.fontWeight >= 600,
+        italic: rich ? false : style.italic,
         lineSpacing: fit.lineHeight * 0.75,
         paraSpaceAfter: 0,
         align: context.contentAlignment,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -35,21 +35,21 @@
   "sideEffects": false,
   "scripts": {
     "build": "node scripts/build.mjs",
-    "typecheck": "node --check src/index.js && node --check scripts/build.mjs && node --check scripts/validate-package.mjs && node --check test/smoke.mjs && node --check src/image-geometry.js && node --check test/image-fit.mjs && node --check test/image-orientation.mjs && node --check test/table-layout.mjs && node --check test/table-import.mjs && node --check test/object-ids.mjs && node --check test/export-corpus.mjs && node --check test/image-media-type.mjs && node --check src/image-fallback-node.js && node --check src/image-fallback-browser.js && node --check test/webp-fallback.mjs && node --check scripts/build-browser-check.mjs && node --check test/webp-fallback-browser.js && node --check test/image-fallback-boundary.mjs && node --check src/background.js && node --check test/background.mjs && node --check src/image-import.js && node --check test/image-import.mjs && node --check test/native-background.mjs",
+    "typecheck": "node --check src/index.js && node --check scripts/build.mjs && node --check scripts/validate-package.mjs && node --check test/smoke.mjs && node --check src/image-geometry.js && node --check test/image-fit.mjs && node --check test/image-orientation.mjs && node --check test/table-layout.mjs && node --check test/table-import.mjs && node --check test/object-ids.mjs && node --check test/export-corpus.mjs && node --check test/image-media-type.mjs && node --check src/image-fallback-node.js && node --check src/image-fallback-browser.js && node --check test/webp-fallback.mjs && node --check scripts/build-browser-check.mjs && node --check test/webp-fallback-browser.js && node --check test/image-fallback-boundary.mjs && node --check src/background.js && node --check test/background.mjs && node --check src/image-import.js && node --check test/image-import.mjs && node --check test/native-background.mjs && node --check src/background-import.js && node --check test/background-inheritance.mjs && node --check test/rich-table.mjs",
     "test": "npm run build && node test/dependency-boundary.mjs && npm run build:browser-check",
     "validate": "node scripts/validate-package.mjs",
     "prepack": "npm run build",
     "build:browser-check": "node scripts/build-browser-check.mjs"
   },
   "dependencies": {
-    "@openpresentation/opf": "^0.4.1",
+    "@openpresentation/opf": "^0.5.0",
     "fast-xml-parser": "^5.8.0",
     "fflate": "^0.8.3",
     "pptxgenjs": "4.0.1",
     "sharp": "0.35.4"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.2.0"
+    "@openpresentation/opf-render": "^0.3.0"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -57,7 +57,7 @@
     }
   },
   "devDependencies": {
-    "@openpresentation/opf-render": "0.2.0",
+    "@openpresentation/opf-render": "0.3.0",
     "esbuild": "0.28.2"
   },
   "imports": {