@openpresentation/opf-pptx 0.4.0 → 0.5.1

package/DEPENDENCY-NOTES.md

@@ -0,0 +1,23 @@
+# PptxGenJS runtime provenance
+
+OPF PPTX 0.5.1 ships the exact, unmodified PptxGenJS 4.0.1 ESM distribution in `vendor/pptxgenjs`, with its MIT license, upstream archive integrity and per-file SHA-256 hashes. Its actual JSZip dependency is declared directly. Ordinary npm installations therefore omit the unused image-size parser without requiring consumer overrides. This removes the affected dependency; it does not patch the parser. Published OPF PPTX 0.5.0 retains the older graph.
+
+The inspected PptxGenJS 4.0.1 ESM/CommonJS distributions do not import `image-size`. The only sizing-module reference is in a commented, unused helper. OPF supplies image geometry itself. The image-fit follow-up reads bounded PNG/JPEG/GIF/WebP dimension headers and inline JPEG EXIF orientation; it does not load image-size or decode pixels.
+
+`npm test` requires image-size to be absent, then blocks both ESM and CommonJS loading before running the full model suite and checking image-byte preservation for data URIs, local paths and host-resolved bytes. Browser bundling retains upstream's Node built-in exclusions through the vendor directory's package metadata. This is not a guarantee about every upstream PptxGenJS API or future version.
+
+Every build checks the vendored code and license against `UPSTREAM.json`. `node scripts/vendor-pptxgenjs.mjs` is an explicit maintainer command that fetches the pinned official npm archive, verifies its SHA-512 integrity and reads only the named distribution/license entries. It is never run by builds or installations. Review the upstream source, actual imports, license and audit before changing versions; retain tests and reassess [GHSA-w3rx-r6r6-pgpr](https://github.com/advisories/GHSA-w3rx-r6r6-pgpr) and [GHSA-5p2g-fcmc-qvqq](https://github.com/advisories/GHSA-5p2g-fcmc-qvqq). Do not accept npm's incompatible PptxGenJS downgrade suggestion.
+
+## Compatible raster decoding
+
+Sharp 0.35.4 (Apache-2.0) is pinned for Node-only WebP-to-PNG conversion and loads lazily only when conversion is needed. Its platform packages include libvips and codec licenses; retain the upstream license files distributed by npm. Node 20.9+ and normal optional-platform dependency installation are required. Browser builds use the browser's decoder/canvas and a conditional package import; a bundling check rejects Sharp or the Node adapter in browser output. Ordinary/preserved image exports are tested with Sharp loading blocked.
+
+The candidate's complete npm audit reports no known vulnerabilities in the installed graph. npm does not audit vendored source as an installed PptxGenJS package: maintainers must also review upstream PptxGenJS advisories and releases when updating or auditing the vendor directory. The browser bundler esbuild 0.28.2 and Playwright are development-only. No hosted service, paid API or telemetry was added.
+
+## Repeatable patch comparison
+
+After `npm ci`, run `npm test` and `npm run test:packed`. The packed check installs the actual tarball into a fresh temporary consumer, audits its complete graph, checks shipped upstream hashes/license and exercises editable table export/reimport. It does not use consumer overrides.
+
+Run `npm run test:browser` for real browser WebP pixel preservation and rich, conditional and merged/styled table import/preview/export/reimport checks. Local Windows runs use installed Microsoft Edge; other environments first run `npx playwright install --with-deps chromium`. CI and release jobs run the Chromium checks on their built candidate. These assertions cover the named fixtures, not arbitrary Office files.
+
+For a comparison against the preceding release, create a separate empty directory, run `npm init -y` there, then `npm install --ignore-scripts --no-audit --no-fund @openpresentation/opf-pptx@0.5.0`. From this repository run `npm run test:compare-published -- <absolute-consumer-directory> <report.json>`. The script verifies the reference version and registry lockfile integrity, then compares every installed core example's PPTX bytes. The older reference deliberately contains the dependency being removed; it is only a comparison input. Explicit replacement images and fallback fonts make the comparison reproducible. Matching bytes do not establish original-asset fidelity or native viewer equivalence.

package/README.md

@@ -67,7 +67,7 @@ The first importer is mechanical and schema-compatible:
 - Remaining text boxes map to `blocks[]` as text or list payloads, sorted by OOXML position.
 - PowerPoint tables map to OPF table blocks, embedded images map to data URI image blocks, and cached chart series map to basic OPF chart blocks.
 - Table imports retain empty rows. A native `firstRow` flag of `1` or `true` maps the first row to column labels; absent/false flags retain every row as data. New exports set this flag from OPF columns. Older exports without the flag retain their labels as the first data row rather than inferring headers.
-- Native table text preserves run/field/break order, significant whitespace, and blank paragraphs. Cells with supported formatting become canonical `TextRun[]`; unstyled body cells stay strings. Explicit normal headers override OPF’s bold header default. Numeric/boolean/null source types cannot be reconstructed from native display text.
+- Native table text preserves run/field/break order, significant whitespace, and blank paragraphs. Cells return canonical `{value, style}` objects; `value` retains scalar text or supported rich runs. Covered merge positions are `null`. Explicit normal headers override OPF’s bold header default. Numeric/boolean/null source types cannot be reconstructed from native display text.
 - Imported runs retain bold, italic, underline, strike, point sizes, Latin font families, solid colors/alpha, external hyperlink URLs, and superscript/subscript direction. List-level and paragraph defaults apply before run overrides; supported theme fonts/colors resolve from the archive. Field values become their cached text, and underline/strike variants and baseline magnitudes reduce to OPF booleans.
 - Conditional table styles, merged-cell geometry, cell fills/borders/alignment, unsupported text fills/colors, and internal hyperlink actions are not fully reconstructed. `onDiagnostic` reports unsupported table style references, merges, fonts/colors/fills and links with native frame/cell paths. Table paths use the native graphic-frame and row indexes, including a header row. The shared core 0.6.0 layout sizes rows from their content and reports `text-overflow` when text cannot fit at the minimum size. These checks establish native XML conversion, not visual parity with PowerPoint.
 - Unknown non-text shapes and unsupported graphic frames become editable text fallback blocks instead of failing the import.
@@ -121,7 +121,7 @@ For crowded drafts, run `paginatePresentation` from `@openpresentation/opf/pagin
 
 Pass the same `textMeasurement` provider used by preview and pagination to `toPptx`. Plain text and headings retain the measured line breaks and resolved font family in editable PowerPoint shapes. Font binaries are not yet embedded in PPTX; native viewers still need the resolved font installed.
 
-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).
+Since 0.5.1, the exact PptxGenJS 4.0.1 ESM distribution is shipped with its MIT license and verified upstream hashes. Its unused `image-size` dependency is not installed; JSZip is declared directly. See [dependency provenance and regression coverage](DEPENDENCY-NOTES.md). The published 0.5.0 package retains the older dependency graph.
 
 ### Native table fitting
 
@@ -192,3 +192,25 @@ Native dimensions retain full precision through import. Premature six-decimal in
 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.
 
 Version 0.2.0 requires Node 20.9 or later for native image decoding. Browser bundles continue using browser-safe entrypoints.
+
+
+## Conditional table text styles (since 0.5.0)
+
+The importer resolves referenced table styles through the archive's presentation relationship, including custom part paths, and accepts inline definitions. It applies whole-table, alternating row/column, edge and corner text styles using [Microsoft's DrawingML precedence](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/90de4085-5fbf-47a7-bc37-d59509481d0a). Direct list-level, paragraph and run properties override the inherited style. Supported character properties are bold/italic, explicit or major/minor-theme Latin fonts, and the existing RGB/system/theme color and alpha transforms. Font-reference placeholder colors resolve after style inheritance. The table-style list's insertion default does not silently restyle existing tables without a reference.
+
+Version 0.5.0 adds conditional table styles. Missing definitions (including built-in Office IDs whose definitions are absent from the archive) produce `unsupported-table-style`; no style data is fetched. Unsupported effects and table backgrounds produce `unsupported-table-cell-style`. Supported conditional solid fills, borders and their theme references use the same precedence as character styles. Native right-to-left geometry reports `unsupported-table-direction` and retains source cell order. Script-specific font selection, unsupported border geometry/color models and native PowerPoint raster parity remain separate work. Native re-export preserves effective character formatting but does not reconstruct the original style reference or redundant explicit normal flags.
+
+`test/table-styles.mjs` builds independent native XML fixtures covering band offsets, overlapping first/last flags, all four corners, theme and explicit fonts, placeholder alpha, inheritance/defaults, direct resets, absent/external definitions and repeated conversion. The checked-in `test/fixtures/table-styles/conditional.pptx` is project-authored test data, not a captured native-viewer reference. After `npm run build:browser-check`, serve this repository and open `/artifacts/native-table-styles/browser/index.html` for 11 browser import, preview-trace and re-export checks.
+
+
+## Styled and merged table cells (since 0.5.0)
+
+The importer returns canonical `{value, style}` cell objects. Values retain supported rich runs, and styles retain direct solid fills/alpha, individual borders, horizontal/vertical alignment and reference-pixel padding. Rectangular native merges use `rowSpan`/`colSpan` anchors with explicit `null` at covered grid positions. Numeric source types cannot be recovered from displayed native text.
+
+Import validates native continuation flags, bounds and covered text before applying merges. A malformed merge falls back to separate styled cells and reports `unsupported-table-merge`, retaining every source cell's text. If a valid merge crosses a flagged first row, the table keeps that row in its body with explicit formatting and reports `table-header-in-body`; OPF repeated headers cannot extend into body rows. Mixed/justified paragraph alignment, vertical text, unsupported fills/lines and 3D/diagonal effects remain explicit diagnostics. Unequal native column widths still need canonical representation.
+
+Conditional borders keep the whole-table outer frame separate from interior horizontal/vertical lines. Row/column bands, edges and corners inherit line properties before direct cell overrides. Archive-local line references resolve theme placeholder colors and alpha. Missing references report `unsupported-table-border` unless an invisible or complete direct line masks them. A merged anchor uses its full span to select outer edges; differing native continuation border segments report `unsupported-table-merge-border` and retain the anchor border. `test/table-border-styles.mjs` covers these cases with native XML fixtures and repeated conversion.
+
+Export consumes the same core geometry as SVG. It writes native merged cells and corrects PptxGenJS's padding-unit heuristic and missing dotted/transparent-border options in generated XML. Rich runs retain their own resolved opacity, including opaque overrides within a translucent cell. Tests inspect actual native XML and repeated conversions; native PowerPoint raster parity is not established.
+
+Version 0.5.0 requires core 0.7.0 and renderer 0.5.0 for coordinated previews. `npm run test:styled-table` runs export/import regressions. For local browser verification, set `OPF_CORE_ROOT` to the core repository and `OPF_RENDER_ROOT` to the coordinated renderer worktree when running `npm run build:browser-check`. Serve the repository and open `/artifacts/native-styled-table-import/browser/index.html`. Omit those variables to exercise installed package dependencies.

package/dist/index.js

@@ -5,7 +5,7 @@ import {importBackground} from './background-import.js';
 import { webpToPng } from '#image-fallback';
 import { rasterMetadata, pictureTransform, normalizeImageOrientation } from './image-geometry.js';
 import { layoutTable, composeSlide, fitText, fitRichText, textWidthMeasurer, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle } from "@openpresentation/opf/composition";
-import PptxGenJS from "pptxgenjs";
+import PptxGenJS from "../vendor/pptxgenjs/pptxgen.es.js";
 import { unzipSync, zipSync } from "fflate";
 import { XMLParser } from "fast-xml-parser";
 import {
@@ -167,6 +167,7 @@ export async function toPptx(input, options = {}) {
   const context = resolvePresentationContext(presentation, {...options,textMeasurement:undefined});
   context.listMarkers = new Map();
   context.tableHeaders = new Map();
+  context.tableCells = new Map();
   context.imagePlacements = new Map();
   context.backgroundFills = new Map();
   context.imageFormat = options.imageFormat ?? "compatible";
@@ -410,7 +411,7 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
   const tables = frames.some(frame => frame['a:graphic']?.['a:graphicData']?.['a:tbl'])
     ? importTableFrames(slidePath, {
       part: (path, parser) => parseRequiredXml(entries, path, parser), relationships: path => parseRelationships(entries, path), bytes: path => entries[path]
-    }, relationships, (frame, cell, code, message) => options.onDiagnostic?.({code, message, path: `slides.${slideIndex}.tables.${frame}${cell ? '.' + cell : ''}`})) : [];
+    }, relationships, (frame, cell, code, message) => options.onDiagnostic?.({code, message, path: `slides.${slideIndex}.tables.${frame}${cell ? '.' + cell : ''}`}), dimensions) : [];
   for (const [index, frame] of frames.entries()) {
     const item = importGraphicFrame(entries, frame, slidePath, relationships, tables[index]);
     if (item) items.push(item);
@@ -1111,13 +1112,17 @@ function addTablePayload(slide, table, region, context, options, path) {
   const columnCount = layout.columnCount;
   const rows = layout.rows.map(row => row.cells.map(cell => {
     const {header,rich,fit} = cell;
+    const cellStyle = cell.style ?? {};
+    const baseColor = (cellStyle.color ?? (header ? '#FFFFFF' : '#' + context.colors.text)).replace(/^#/, '');
+    const baseFill = (cellStyle.fill ?? (header ? '#' + context.colors.accent : '#' + context.colors.surface)).replace(/^#/, '');
+    const alpha = value => value.length === 8 ? (1 - parseInt(value.slice(6), 16) / 255) * 100 : 0;
     const text = stringifyText(cell.value), style = cell.textStyle;
     const fragments = rich ? fit.richLines.flatMap(line => line.fragments) : [];
     const runs = rich ? cell.value.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 rawColor = /^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(run.color ?? '') ? run.color.slice(1) : baseColor;
       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,
@@ -1146,14 +1151,21 @@ function addTablePayload(slide, table, region, context, options, path) {
         italic: rich ? false : style.italic,
         lineSpacing: fit.lineHeight * 0.75,
         paraSpaceAfter: 0,
-        align: context.contentAlignment,
-        color: header ? "FFFFFF" : context.colors.text,
-        fill: { color: header ? context.colors.accent : context.colors.surface },
+        align: cellStyle.align ?? context.contentAlignment,
+        valign: cellStyle.verticalAlign ?? 'top',
+        ...(cell.colSpan > 1 ? {colspan:cell.colSpan} : {}),
+        ...(cell.rowSpan > 1 ? {rowspan:cell.rowSpan} : {}),
+        color: normalizeHex(baseColor),
+        // Rich runs carry resolved alpha. A translucent cell default would
+        // overwrite an explicit opaque run because PptxGenJS inherits falsy 0.
+        ...(cellStyle.color && !rich ? {transparency:alpha(baseColor)} : {}),
+        fill: { color: normalizeHex(baseFill), ...(cellStyle.fill ? {transparency:alpha(baseFill)} : {}) },
       },
     };
   }));
   const objectName = `OPF table ${context.tableHeaders.size + 1}`;
   context.tableHeaders.set(objectName, hasHeaders);
+  if (layout.rows.some(row => row.cells.some(cell => Object.keys(cell.style ?? {}).length))) context.tableCells.set(objectName, {layout, scale, defaultBorder:{color:"#"+context.colors.border,width:1/scale}});
   slide.addTable(rows, {
     objectName,
     x: region.x,
@@ -1629,7 +1641,56 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
       xml = xml.replace(/<p:graphicFrame>([\s\S]*?)<\/p:graphicFrame>/g, frame => {
         const name = frame.match(/name="(OPF table \d+)"/)?.[1];
         if (!context.tableHeaders.has(name)) return frame;
-        return frame.replace('<a:tblPr/>', `<a:tblPr firstRow="${context.tableHeaders.get(name) ? 1 : 0}"/>`);
+        frame = frame.replace('<a:tblPr/>', `<a:tblPr firstRow="${context.tableHeaders.get(name) ? 1 : 0}"/>`);
+        const table = context.tableCells.get(name);
+        if (!table) return frame;
+        const anchors = table.layout.rows.flatMap(row => row.cells);
+        const ownerAt = (row,column) => anchors.find(anchor => row >= anchor.row && row < anchor.row + anchor.rowSpan && column >= anchor.column && column < anchor.column + anchor.colSpan);
+        let rowIndex = 0;
+        return frame.replace(/<a:tr\b[^>]*>[\s\S]*?<\/a:tr>/g, rowXml => {
+          const currentRow = rowIndex++;
+          const cells = table.layout.rows[currentRow].cells;
+          let column = 0;
+          return rowXml.replace(/<a:tc\b[^>]*>[\s\S]*?<\/a:tc>/g, cellXml => {
+            const currentColumn = column++;
+            const cell = cells.find(cell => cell.column === currentColumn);
+            const owner = cell ?? ownerAt(currentRow,currentColumn);
+            if (!owner) return cellXml;
+            // PowerPoint reads each physical continuation's perimeter border.
+            // Anchor-only styling truncates dashes and restores hidden segments.
+            const perimeter = {left:currentColumn === owner.column, right:currentColumn === owner.column + owner.colSpan - 1,
+              top:currentRow === owner.row, bottom:currentRow === owner.row + owner.rowSpan - 1};
+            const style = cell ? {...cell.style} : {borders:Object.fromEntries(Object.keys(perimeter).map(edge => [edge,perimeter[edge] ? owner.style?.borders?.[edge] ?? table.defaultBorder : {color:'#000000',width:0}]))};
+            style.borders = {...style.borders};
+            // Native shared-edge precedence can let an implicit neighbor cover
+            // an explicit merge border. Give both physical sides that border.
+            for (const [edge,opposite,dr,dc] of [['left','right',0,-1],['right','left',0,1],['top','bottom',-1,0],['bottom','top',1,0]]) {
+              if (!perimeter[edge] || style.borders[edge] || owner.rowSpan > 1 || owner.colSpan > 1) continue;
+              const neighbor = ownerAt(currentRow+dr,currentColumn+dc);
+              if (neighbor?.style?.borders?.[opposite]) style.borders[edge] = neighbor.style.borders[opposite];
+            }
+            cellXml = cellXml.replace(/<a:tcPr\b([^>]*)\/>/, '<a:tcPr$1></a:tcPr>');
+            return cellXml.replace(/<a:tcPr\b([^>]*)>([\s\S]*?)<\/a:tcPr>/, (properties, attributes, contents) => {
+              if (style.padding) {
+                const padding = {top:8, right:10, bottom:4, left:10, ...style.padding};
+                for (const [edge, key] of [['top','marT'],['right','marR'],['bottom','marB'],['left','marL']]) {
+                  attributes = attributes.replace(new RegExp(` ${key}="[^"]*"`), '');
+                  attributes += ` ${key}="${Math.round(padding[edge] * table.scale * 9525)}"`;
+                }
+              }
+              for (const [edge, native] of [['left','lnL'],['right','lnR'],['top','lnT'],['bottom','lnB']]) {
+                const border = style.borders?.[edge];
+                if (!border) continue;
+                const fill = border.width === 0 ? '<a:noFill/>' : nativeBackgroundFill({type:'solid',color:border.color},{width:1,height:1});
+                const dash = {solid:'solid',dash:'dash',dot:'sysDot'}[border.dash ?? 'solid'];
+                const line = `<a:${native} w="${Math.round(border.width * table.scale * 9525)}" cap="flat" cmpd="sng" algn="ctr">${fill}<a:prstDash val="${dash}"/></a:${native}>`;
+                const existing = new RegExp(`<a:${native}\\b[^>]*>[\\s\\S]*?<\\/a:${native}>`);
+                contents = existing.test(contents) ? contents.replace(existing, line) : contents + line;
+              }
+              return `<a:tcPr${attributes}>${contents}</a:tcPr>`;
+            });
+          });
+        });
       });
       // Image data is already resolved and embedded by PptxGenJS. Read those
       // exact bytes instead of fetching or resolving the source a second time.

package/dist/table-border-import.js

@@ -0,0 +1,73 @@
+import {readBackgroundColor} from './background.js';
+
+const has=(value,key)=>Object.hasOwn(value??{},key);
+const fills=['a:solidFill','a:noFill','a:gradFill','a:blipFill','a:pattFill','a:grpFill'];
+
+export function mergeNativeLine(...levels){
+  const result={};
+  for(const level of levels){
+    if(!level)continue;
+    if(fills.some(key=>has(level,key)))for(const key of fills)delete result[key];
+    if(has(level,'a:prstDash')||has(level,'a:custDash')){delete result['a:prstDash'];delete result['a:custDash'];}
+    // A complete direct line or an invisible line masks an unavailable theme
+    // reference; partial overrides still need the missing inherited properties.
+    if(has(level,'a:noFill')||Number(level.w)===0||(has(level,'w')&&fills.some(key=>has(level,key))&&has(level,'a:prstDash')))delete result._opfUnresolvedTableLine;
+    Object.assign(result,level);
+  }
+  return result;
+}
+
+function nativeStyleLine(border,context){
+  if(border['a:ln'])return border['a:ln'];
+  const reference=border['a:lnRef'];
+  if(!reference)return undefined;
+  const unresolved={_opfUnresolvedTableLine:true};
+  if(!/^\d+$/.test(reference.idx??''))return unresolved;
+  const index=Number(reference.idx);
+  if(index===0)return undefined;
+  const lines=context.format?.['a:lnStyleLst']?.['a:ln'];
+  const selected=(Array.isArray(lines)?lines:lines?[lines]:[])[index-1];
+  if(!selected)return unresolved;
+  const line={...selected};
+  if(line['a:solidFill']){
+    const color=readBackgroundColor(line['a:solidFill'],{...context,placeholder:readBackgroundColor(reference,context)});
+    if(!color)return {...line,...unresolved};
+    line['a:solidFill']={'a:srgbClr':{val:color.hex.slice(1),'a:alpha':{val:String(Math.round(color.alpha*100000))}}};
+  }
+  return line;
+}
+
+export function nativeCellExtent(row,column,rowCount,columnCount,geometry={}){
+  const span=(value,remaining)=>{const n=Number(value??1);return Number.isSafeInteger(n)&&n>=1&&n<=remaining?n:1;};
+  return {top:row===0,left:column===0,bottom:row+span(geometry.rowSpan,rowCount-row)===rowCount,right:column+span(geometry.gridSpan,columnCount-column)===columnCount};
+}
+
+/** Keep named edge and interior properties distinct until inheritance finishes.
+ * wholeTbl edges belong to its outer frame; conditional explicit edges belong
+ * to the selected cell. Interior lines apply only away from the outer frame. */
+export function inheritNativeBorders(previous,decoration,name,extent,context){
+  const result={...previous},borders=decoration['a:tcBdr']??{};
+  for(const key of ['left','right','top','bottom','insideH','insideV','tl2br','tr2bl']){
+    const border=borders['a:'+key];
+    if(!border || name==='wholeTbl'&&has(extent,key)&&!extent[key])continue;
+    const line=nativeStyleLine(border,context);
+    if(line!==undefined)result[key]=mergeNativeLine(result[key],line);
+  }
+  return result;
+}
+
+export function nativeBorderProperties(borders,extent){
+  const result={};
+  for(const [edge,key,inside] of [['left','a:lnL','insideV'],['right','a:lnR','insideV'],['top','a:lnT','insideH'],['bottom','a:lnB','insideH']]){
+    const base=extent[edge]?undefined:borders[inside],line=borders[edge];
+    if(base||line)result[key]=mergeNativeLine(base,line);
+  }
+  for(const [edge,key] of [['tl2br','a:lnTlToBr'],['tr2bl','a:lnBlToTr']])if(borders[edge])result[key]=borders[edge];
+  return result;
+}
+
+export function mergeCellBorderOverrides(inherited,direct,merged){
+  const result={...merged};
+  for(const key of ['a:lnL','a:lnR','a:lnT','a:lnB','a:lnTlToBr','a:lnBlToTr'])if(inherited[key]&&direct[key])result[key]=mergeNativeLine(inherited[key],direct[key]);
+  return result;
+}

package/dist/table-cell-import.js

@@ -0,0 +1,138 @@
+import {drawingObject} from './background-import.js';
+import {readBackgroundColor} from './background.js';
+
+const has = (value, key) => Object.hasOwn(value ?? {}, key);
+const nodes = (tree, tag) => (tree ?? []).filter(node => has(node, tag));
+const child = (tree, tag) => nodes(tree, tag)[0]?.[tag];
+const truth = value => ['1','true','on'].includes(value);
+const text = value => Array.isArray(value) ? value.map(run => typeof run === 'string' ? run : run.text).join('') : value ?? '';
+const hex = color => color.hex + (color.alpha < 1 ? Math.round(color.alpha * 255).toString(16).padStart(2,'0').toUpperCase() : '');
+
+// Preserve ordered fill-style indexes: grouping XML tags would reorder mixed
+// solid/gradient/image entries. Resolve phClr against this reference only.
+export function nativeStyleFill(style, context) {
+  if (style['a:fill']) return style['a:fill'];
+  const reference=style['a:fillRef'];
+  if (!reference) return {};
+  const unresolved={_opfUnresolvedTableFill:true};
+  if (!/^\d+$/.test(reference.idx ?? '')) return unresolved;
+  const index=Number(reference.idx);
+  if (index===0 || index===1000) return {'a:noFill':{}};
+  const tree=context.formatPath && context.parsedPart(context.formatPath)?.tree;
+  const theme=child(tree,'a:theme'),elements=theme?child(theme,'a:themeElements'):child(tree,'a:themeOverride');
+  const format=child(elements,'a:fmtScheme');
+  const entries=child(format,index<1000?'a:fillStyleLst':'a:bgFillStyleLst')?.filter(node=>Object.keys(node).some(key=>key!=='#text'&&key!==':@'));
+  const entry=entries?.[index<1000?index-1:index-1001];
+  if (!entry) return unresolved;
+  const properties=drawingObject([entry]);
+  if (properties['a:solidFill']) {
+    const color=readBackgroundColor(properties['a:solidFill'],{...context,placeholder:readBackgroundColor(reference,context)});
+    if (!color) return unresolved;
+    return {'a:solidFill':{'a:srgbClr':{val:color.hex.slice(1),'a:alpha':{val:String(Math.round(color.alpha*100000))}}}};
+  }
+  return properties;
+}
+
+function solid(properties, context, report, kind) {
+  if (has(properties,'a:noFill')) return '#00000000';
+  if (properties['a:solidFill']) {
+    const color = readBackgroundColor(properties['a:solidFill'], context);
+    if (color) return hex(color);
+    report(`unsupported-table-${kind}`, 'The native solid color or its transforms could not be resolved.');
+  } else if (['a:gradFill','a:blipFill','a:pattFill','a:grpFill'].some(key => has(properties,key))) {
+    report(`unsupported-table-${kind}`, 'Only solid cell fills and border colors are represented by OPF table styles.');
+  }
+  return undefined;
+}
+
+export function nativeCellStyle(properties, body, context, scale, report) {
+  const style = {fill:'#00000000', align:'left', verticalAlign:'top', padding:{}, borders:{}};
+  const fill = solid(properties, context, report, 'cell-fill');
+  if (properties._opfUnresolvedTableFill) report('unsupported-table-cell-fill','The native fill style reference or placeholder color could not be resolved from this archive.');
+  if (fill !== undefined) style.fill = fill;
+  // DrawingML defaults are 0.1 inch horizontally and 0.05 inch vertically.
+  for (const [edge,key,fallback] of [['top','marT',45720],['right','marR',91440],['bottom','marB',45720],['left','marL',91440]]) {
+    const value = Number(properties[key] ?? fallback) / (9525 * scale);
+    if (Number.isFinite(value) && value >= 0 && value <= 200) style.padding[edge] = value;
+    else {style.padding[edge] = Math.min(200,fallback / (9525 * scale));report('unsupported-table-padding','The native cell margin is outside the canonical 0–200 reference-pixel range.');}
+  }
+  const vertical = {t:'top',ctr:'middle',b:'bottom'}[properties.anchor ?? 't'];
+  if (vertical) style.verticalAlign = vertical;
+  else report('unsupported-table-alignment','Distributed or justified vertical cell alignment is not represented.');
+  if (truth(properties.anchorCtr) || properties.vert && properties.vert !== 'horz') report('unsupported-table-alignment','Centered anchoring or vertical text direction is not represented.');
+  const listStyle = drawingObject(child(body,'a:lstStyle'));
+  const alignments = nodes(body,'a:p').map(paragraph => {
+    const p = drawingObject(paragraph['a:p'])['a:pPr'] ?? {};
+    return p.algn ?? listStyle[`a:lvl${Number(p.lvl ?? 0)+1}pPr`]?.algn ?? listStyle['a:defPPr']?.algn ?? 'l';
+  });
+  const alignment = {l:'left',ctr:'center',r:'right'}[alignments[0] ?? 'l'];
+  if (alignment) style.align = alignment;
+  if (!alignment || new Set(alignments).size > 1) report('unsupported-table-alignment','Mixed or justified paragraph alignment cannot be represented by one cell alignment.');
+  for (const [edge,key] of [['left','a:lnL'],['right','a:lnR'],['top','a:lnT'],['bottom','a:lnB']]) {
+    const line = properties[key];
+    style.borders[edge] = {color:'#00000000',width:0};
+    if (!line) continue;
+    if (has(line,'a:noFill') || line.w === '0') continue;
+    if (line._opfUnresolvedTableLine) report('unsupported-table-border','The native line style reference or placeholder color could not be resolved from this archive.');
+    const hasFill=['a:solidFill','a:noFill','a:gradFill','a:blipFill','a:pattFill','a:grpFill'].some(key=>has(line,key));
+    const color = solid(line,context,report,'border') ?? (!hasFill&&!line._opfUnresolvedTableLine?'#000000':undefined);
+    const width = Number(line.w ?? 12700) / (9525 * scale);
+    const dash = {solid:'solid',dash:'dash',sysDash:'dash',sysDot:'dot',dot:'dot'}[line['a:prstDash']?.val ?? 'solid'];
+    if (color !== undefined && Number.isFinite(width) && width >= 0 && width <= 32 && dash) style.borders[edge] = {color,width,...(dash === 'solid' ? {} : {dash})};
+    else report('unsupported-table-border','The native border color, width or dash pattern cannot be represented.');
+    if (line.cmpd && line.cmpd !== 'sng' || line.algn && line.algn !== 'ctr' || has(line,'a:custDash')) report('unsupported-table-border','Compound, inset or custom-dash border geometry is not represented.');
+  }
+  if (['a:lnTlToBr','a:lnBlToTr','a:cell3D'].some(key => has(properties,key))) report('unsupported-table-cell-effect','Diagonal cell borders and 3D cell effects are not represented.');
+  return style;
+}
+
+/** Accept a native dense merge only when every covered position is empty and
+ * carries the corresponding continuation flags. On malformed input, retain all
+ * source cells without merges rather than hiding text behind a guessed anchor. */
+export function nativeTableGrid(cells, columnCount, headers, report) {
+  const owners = cells.map(row => Array(row.length));
+  let malformed = false;
+  const bad = (r,c,message) => {malformed=true;report(`rows.${r}.${c}`,'unsupported-table-merge',message);};
+  const rows = cells.map(row => row.map(cell => ({value:cell.value,style:cell.style})));
+  for (let r=0;r<cells.length;r++) for (let c=0;c<cells[r].length;c++) {
+    const cell=cells[r][c], geometry=cell.geometry, owner=owners[r][c];
+    const horizontal=truth(geometry.hMerge),vertical=truth(geometry.vMerge);
+    if (owner) {
+      if (text(cell.value) !== '' || horizontal !== (c > owner.c) || vertical !== (r > owner.r)) bad(r,c,'Native merge continuations conflict with their anchor or contain text; all source cell text is retained.');
+      rows[r][c]=null;
+      continue;
+    }
+    const rowSpan=Number(geometry.rowSpan ?? 1),colSpan=Number(geometry.gridSpan ?? 1);
+    if (horizontal || vertical || !Number.isSafeInteger(rowSpan) || !Number.isSafeInteger(colSpan) || rowSpan<1 || colSpan<1 || r+rowSpan>cells.length || c+colSpan>columnCount) {
+      bad(r,c,'Native merge geometry is incomplete or outside the table grid; all source cell text is retained.');continue;
+    }
+    if (rowSpan>1) rows[r][c].rowSpan=rowSpan;
+    if (colSpan>1) rows[r][c].colSpan=colSpan;
+    if (rowSpan === 1 && colSpan === 1) continue;
+    for (let y=r;y<r+rowSpan;y++) for (let x=c;x<c+colSpan;x++) {
+      if (!cells[y]?.[x] || owners[y][x]) bad(r,c,'Native merge rectangles overlap or omit covered cells; all source cell text is retained.');
+      else owners[y][x]={r,c};
+    }
+  }
+  if (malformed) return {headers,rows:cells.map(row=>row.map(cell=>({value:cell.value,style:cell.style})))};
+  // A canonical merged cell has one border per full edge. Native continuation
+  // cells can specify different edge segments; retain the anchor and report
+  // the loss rather than silently claiming that segmented border is preserved.
+  for (let r=0;r<cells.length;r++) for (let c=0;c<cells[r].length;c++) {
+    const owner=owners[r][c];
+    if (!owner || owner.r===r && owner.c===c) continue;
+    const anchor=rows[owner.r][owner.c],cell=cells[r][c];
+    const perimeter={top:r===owner.r,left:c===owner.c,bottom:r===owner.r+(anchor.rowSpan??1)-1,right:c===owner.c+(anchor.colSpan??1)-1};
+    const differs=edge=>{
+      const a=anchor.style.borders[edge],b=cell.style.borders[edge];
+      if (a.width===0 && b.width===0) return false;
+      return a.width!==b.width || a.color!==b.color || (a.dash??'solid')!==(b.dash??'solid');
+    };
+    if ((cell.borderEdges??[]).some(edge=>perimeter[edge]&&differs(edge))) report(`rows.${r}.${c}`,'unsupported-table-merge-border','Native continuation cells specify differing border segments around a merged cell. The merge and anchor borders are retained; segmented borders are not represented.');
+  }
+  if (headers && rows[0]?.some(cell=>cell?.rowSpan>1)) {
+    headers=false;
+    report('','table-header-in-body','A native merge crosses the first row. It is retained in body rows with explicit formatting, because canonical repeated headers cannot span into body rows.');
+  }
+  return {headers,rows};
+}

package/dist/table-import.js

@@ -1,11 +1,13 @@
 import {drawingObject, readSlideTheme} from './background-import.js';
 import {readBackgroundColor} from './background.js';
+import {nativeCellStyle, nativeTableGrid, nativeStyleFill} from './table-cell-import.js';
+import {nativeCellExtent,inheritNativeBorders,nativeBorderProperties,mergeCellBorderOverrides} from './table-border-import.js';
 
 const nodes = (tree, tag) => (tree ?? []).filter(node => Object.hasOwn(node, tag));
 const child = (tree, tag) => nodes(tree, tag)[0]?.[tag];
 const attrs = (tree, tag) => nodes(tree, tag)[0]?.[':@'] ?? {};
 const text = tree => (tree ?? []).map(node => node['#text'] ?? '').join('');
-const boolean = value => value === '1' || value === 'true' ? true : value === '0' || value === 'false' ? false : undefined;
+const boolean = value => ['1','true','on'].includes(value) ? true : ['0','false','off'].includes(value) ? false : undefined;
 
 function runStyle(properties, context, relationships, report) {
   const result = {};
@@ -24,6 +26,7 @@ function runStyle(properties, context, relationships, report) {
     result.subscript = baseline < 0;
   }
   const font = properties['a:latin']?.typeface;
+  if (properties['a:latin'] && !font) report('unsupported-table-font', 'The native text font has no usable Latin face or theme reference.');
   if (font) {
     const match = font.match(/^\+(mj|mn)-(lt|ea|cs)$/);
     const family = match ? context.fonts?.[match[1] === 'mj' ? 'a:majorFont' : 'a:minorFont']?.[{lt:'a:latin',ea:'a:ea',cs:'a:cs'}[match[2]]]?.typeface : font;
@@ -51,7 +54,7 @@ function runStyle(properties, context, relationships, report) {
 // overrides a bold paragraph default, and a new fill replaces the inherited fill.
 function mergeProperties(...levels) {
   const result = {};
-  const fills = ['a:solidFill','a:noFill','a:gradFill','a:blipFill','a:pattFill','a:grpFill'];
+  const fills = ['a:solidFill','a:noFill','a:gradFill','a:blipFill','a:pattFill','a:grpFill','_opfUnresolvedTableFill'];
   for (const level of levels) {
     if (!level) continue;
     if (fills.some(key => Object.hasOwn(level, key))) for (const key of fills) delete result[key];
@@ -60,7 +63,7 @@ function mergeProperties(...levels) {
   return result;
 }
 
-function cellText(body, context, relationships, report, header) {
+function cellText(body, context, relationships, report, header, tableDefaults) {
   const listStyle = drawingObject(child(body, 'a:lstStyle'));
   const paragraphs = nodes(body, 'a:p');
   const runs = [];
@@ -73,7 +76,7 @@ function cellText(body, context, relationships, report, header) {
     if (index) append('\n');
     const pPr = drawingObject(content)['a:pPr'] ?? {};
     const level = Number(pPr.lvl ?? 0) + 1;
-    const defaults = mergeProperties(header ? {b:'0'} : undefined, listStyle['a:defPPr']?.['a:defRPr'], listStyle[`a:lvl${level}pPr`]?.['a:defRPr'], pPr['a:defRPr']);
+    const defaults = mergeProperties(header ? {b:'0'} : undefined, tableDefaults, listStyle['a:defPPr']?.['a:defRPr'], listStyle[`a:lvl${level}pPr`]?.['a:defRPr'], pPr['a:defRPr']);
     for (const node of content) {
       const tag = ['a:r', 'a:fld', 'a:br'].find(tag => Object.hasOwn(node, tag));
       if (!tag) continue;
@@ -84,25 +87,126 @@ function cellText(body, context, relationships, report, header) {
   return runs.some(run => typeof run !== 'string') ? runs : runs.join('');
 }
 
+// Table styles are archive data, resolved through the presentation relationship.
+// The list's def attribute is an insertion default, not an implicit style for
+// existing unstyled tables. Built-in IDs without archive definitions stay explicit
+// diagnostics; do not substitute a guessed theme or download style definitions.
+function tableStyle(props, archive, context, report) {
+  const inline = child(props, 'a:tableStyle');
+  if (inline) return drawingObject(inline);
+  const id = text(child(props, 'a:tableStyleId')).trim().toLowerCase();
+  if (!id) return undefined;
+  const relationship = [...archive.relationships('ppt/presentation.xml').values()]
+    .find(rel => rel.type.endsWith('/tableStyles') && rel.targetMode !== 'External' && archive.bytes(rel.path));
+  const list = relationship && child(context.parsedPart(relationship.path)?.tree, 'a:tblStyleLst');
+  const selected = nodes(list, 'a:tblStyle').find(node => node[':@']?.styleId?.trim().toLowerCase() === id);
+  if (selected) return drawingObject(selected['a:tblStyle']);
+  report('unsupported-table-style', 'The referenced native table style has no definition in this archive; direct text formatting is retained.');
+  return undefined;
+}
+
+const colorKinds = ['a:srgbClr','a:sysClr','a:schemeClr','a:scrgbClr','a:hslClr','a:prstClr'];
+function tableTextProperties(style, context) {
+  const result = {};
+  for (const key of ['b','i']) {
+    const value = boolean(style[key]);
+    if (value !== undefined) result[key] = value ? '1' : '0';
+  }
+  if (style['a:font']) {
+    result['a:latin'] = style['a:font']['a:latin'] ?? {};
+  } else if (style['a:fontRef']) {
+    const index = style['a:fontRef'].idx;
+    result['a:latin'] = {typeface:index === 'major' ? '+mj-lt' : index === 'minor' ? '+mn-lt' : ''};
+  }
+  const color = Object.fromEntries(colorKinds.filter(key => Object.hasOwn(style, key)).map(key => [key, style[key]]));
+  if (Object.keys(color).length) {
+    const placeholder = readBackgroundColor(style['a:fontRef'], context);
+    const resolved = readBackgroundColor(color, {...context, placeholder});
+    // Normalize style placeholder colors before merging direct paragraph/run fills.
+    result['a:solidFill'] = resolved ? {'a:srgbClr':{val:resolved.hex.slice(1), 'a:alpha':{val:String(Math.round(resolved.alpha * 100000))}}} : color;
+  }
+  return result;
+}
+
+function conditionalProperties(style, properties, row, column, rowCount, columnCount, context, report, geometry) {
+  if (!style) return {text:undefined,cell:{}};
+  const enabled = key => boolean(properties[key]) === true;
+  const firstRow = enabled('firstRow') && row === 0;
+  const lastRow = enabled('lastRow') && row === rowCount - 1;
+  const firstCol = enabled('firstCol') && column === 0;
+  const lastCol = enabled('lastCol') && column === columnCount - 1;
+  // DrawingML / MS-OI29500 2.1.1265 order (not WordprocessingML order).
+  const parts = ['wholeTbl'];
+  if (enabled('bandRow') && !firstRow && !lastRow) parts.push((row + Number(enabled('firstRow'))) % 2 ? 'band2H' : 'band1H');
+  if (enabled('bandCol') && !firstCol && !lastCol) parts.push((column + Number(enabled('firstCol'))) % 2 ? 'band2V' : 'band1V');
+  if (lastCol) parts.push('lastCol');
+  if (firstCol) parts.push('firstCol');
+  if (lastRow) parts.push('lastRow');
+  if (lastRow && lastCol) parts.push('seCell');
+  if (lastRow && firstCol) parts.push('swCell');
+  if (firstRow) parts.push('firstRow');
+  if (firstRow && lastCol) parts.push('neCell');
+  if (firstRow && firstCol) parts.push('nwCell');
+  const textStyle = {};
+  let cellStyle = {};
+  let borders = {};
+  const extent=nativeCellExtent(row,column,rowCount,columnCount,geometry);
+  for (const name of parts) {
+    const part = style['a:' + name];
+    if (!part) continue;
+    const decoration=part['a:tcStyle'] ?? {};
+    cellStyle=mergeProperties(cellStyle,nativeStyleFill(decoration,context));
+    borders=inheritNativeBorders(borders,decoration,name,extent,context);
+    if (Object.keys(decoration).some(key=>!['a:fill','a:fillRef','a:tcBdr'].includes(key))) report('unsupported-table-cell-style','The conditional cell style includes effects that are not represented; supported fills, borders and character styles are retained.');
+    const current = part['a:tcTxStyle'] ?? {};
+    // Resolve choices after inheritance so a later phClr can use an inherited
+    // fontRef, and an explicit font collection replaces a themed reference.
+    if (current['a:font'] || current['a:fontRef']) {delete textStyle['a:font'];delete textStyle['a:fontRef'];}
+    if (colorKinds.some(key => Object.hasOwn(current, key))) for (const key of colorKinds) delete textStyle[key];
+    for (const [key, value] of Object.entries(current)) {
+      if (['b','i'].includes(key) && value === 'def') continue;
+      textStyle[key] = value;
+    }
+  }
+  return {text:tableTextProperties(textStyle, context),cell:{...cellStyle,...nativeBorderProperties(borders,extent)}};
+}
+
 // Use the same direct graphic-frame ordering as the slide collector. The ordered
 // reader retains interleaved runs, fields, breaks, empty paragraphs and spaces.
-export function importTableFrames(slidePath, archive, relationships, report) {
+export function importTableFrames(slidePath, archive, relationships, report, dimensions) {
   const context = readSlideTheme(slidePath, archive);
+  const scale = Math.min(dimensions.widthInches,dimensions.heightInches) * 96 / 720;
   const root = child(context.parsedPart(slidePath)?.tree, 'p:sld');
   const tree = child(child(root, 'p:cSld'), 'p:spTree');
   return nodes(tree, 'p:graphicFrame').map((frame, frameIndex) => {
     const table = child(child(child(frame['p:graphicFrame'], 'a:graphic'), 'a:graphicData'), 'a:tbl');
     if (!table) return undefined;
     const props = child(table, 'a:tblPr');
-    if (child(props, 'a:tableStyleId') || child(props, 'a:tableStyle')) report(frameIndex, '', 'unsupported-table-style', 'Conditional native table styles are not applied; direct cell and paragraph text formatting is retained.');
-    const headers = boolean(attrs(table, 'a:tblPr').firstRow) === true;
-    const rows = nodes(table, 'a:tr').map((row, rowIndex) => nodes(row['a:tr'], 'a:tc').map((cell, columnIndex) => {
+    const style = tableStyle(props, archive, context, (code, message) => report(frameIndex, '', code, message));
+    if (style?.['a:tblBg']) report(frameIndex, '', 'unsupported-table-cell-style', 'The native table style background is not represented; supported character styles are retained.');
+    const properties = attrs(table, 'a:tblPr');
+    if (boolean(properties.rtl) === true) report(frameIndex, '', 'unsupported-table-direction', 'Right-to-left table geometry is not represented; cells retain native source order.');
+    const headers = boolean(properties.firstRow) === true;
+    const nativeRows = nodes(table, 'a:tr');
+    const columnCount = nodes(child(table, 'a:tblGrid'), 'a:gridCol').length;
+    const rows = nativeRows.map((row, rowIndex) => nodes(row['a:tr'], 'a:tc').map((cell, columnIndex) => {
       const cellPath = `rows.${rowIndex}.${columnIndex}`;
-      const emit = (code, message) => report(frameIndex, cellPath, code, message);
+      const reported = new Set();
+      const emit = (code, message) => {if (!reported.has(code)) {reported.add(code);report(frameIndex, cellPath, code, message);}};
       const geometry = cell[':@'] ?? {};
-      if (['gridSpan','rowSpan'].some(key => Number(geometry[key] ?? 1) > 1) || ['hMerge','vMerge'].some(key => boolean(geometry[key]) === true)) emit('unsupported-table-merge', 'Merged-cell geometry is not represented; the native cell text is retained.');
-      return cellText(child(cell['a:tc'], 'a:txBody'), context, relationships, emit, headers && rowIndex === 0);
+      const defaults = conditionalProperties(style, properties, rowIndex, columnIndex, nativeRows.length, columnCount, context, emit, geometry);
+      const body = child(cell['a:tc'],'a:txBody');
+      const cellProperties = {...attrs(cell['a:tc'],'a:tcPr'),...drawingObject(child(cell['a:tc'],'a:tcPr'))};
+      const inherited=mergeProperties(defaults.cell,cellProperties);
+      return {
+        geometry,
+        value:cellText(body, context, relationships, emit, headers && rowIndex === 0, defaults.text),
+        style:nativeCellStyle(mergeCellBorderOverrides(defaults.cell,cellProperties,inherited),body,context,scale,emit),
+        borderEdges:[['left','a:lnL'],['right','a:lnR'],['top','a:lnT'],['bottom','a:lnB']]
+          .filter(([,key])=>Object.hasOwn(inherited,key)).map(([edge])=>edge),
+      };
     }));
-    return headers && rows.length ? {columns:rows[0], rows:rows.slice(1)} : {rows};
+    const grid = nativeTableGrid(rows,columnCount,headers,(cell,code,message)=>report(frameIndex,cell,code,message));
+    return grid.headers && grid.rows.length ? {columns:grid.rows[0], rows:grid.rows.slice(1)} : {rows:grid.rows};
   });
 }