@shbernal/ts-pptx 4.1.0 → 4.2.0

package/dist/{font-metrics-CBGmhLo0.d.ts → font-metrics-DTppw4t3.d.ts}

@@ -1,16 +1,15 @@
-import { c as PLACEHOLDER_TYPE, d as SHAPE_NAME, g as TextAnchor, i as CHART_NAME, m as SlideObjectType, o as ChartType, t as AlignH } from "./enums-DQRpVOLh.js";
-import { $ as ChartOpts, E as Margin, Ht as TextProps, Jt as MediaProps, Pt as SlideComment, Q as ChartMulti, Sn as TextShapeType, St as OptsChartData, Ut as TextPropsOptions, Yt as MediaType, a as PresentationProps, i as PresLayout, j as TextVertType, o as SectionProps, p as BackgroundOption, q as ChartErrorBarOptions, z as HyperlinkProps } from "./pres-BA9_lJbY.js";
-import { O as TableCell, S as AnimationProps, _ as MasterTextStyleProps, a as Slide, i as ObjectOptions, o as SlideLayout, x as SlideNumberProps } from "./slide-BqPtyKmb.js";
-import { t as EmbeddedFont } from "./embedded-fonts-CI_YGW2d.js";
-//#region src/types/internal.d.ts
+import { c as PLACEHOLDER_TYPE, d as SHAPE_NAME, g as TextAnchor, i as CHART_NAME, m as SlideObjectType, o as ChartType, t as AlignH } from "./enums-PcXr3o3J.js";
+import { An as TextShapeType, Cn as PlaceholderXmlType, Dt as OptsChartData, E as Margin, H as HyperlinkProps, M as TextVertType, Q as ChartErrorBarOptions, Vt as SlideComment, Xt as TextPropsOptions, Yt as TextProps, a as PresentationProps, i as PresLayout, it as ChartOpts, nn as MediaType, o as SectionProps, p as BackgroundOption, rt as ChartMulti, tn as MediaProps } from "./pres-BkEkUAEM.js";
+import { O as TableCell, S as AnimationProps, _ as MasterTextStyleProps, a as Slide, i as ObjectOptions, o as SlideLayout, x as SlideNumberProps } from "./slide-BmT4kMoO.js";
+import { t as EmbeddedFont } from "./embedded-fonts-U7HIIhPO.js";
 /** The keys of `T` that are declared optional. */
 type OptionalKeysOf<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never; }[keyof T];
 /**
  * `T`, but every *optional* property may also be spelled as a present `undefined`.
  *
  * Under `exactOptionalPropertyTypes` a `foo?: T` says the key is either absent or holds a `T`.
- * That distinction is real for a bag that is **stored, spread or enumerated** — `{ ...defaults,
- * ...options }` inherits from an absent key and is overridden by a present `undefined` — and
+ * That distinction is real for a bag that is **stored, spread or enumerated** (`{ ...defaults,
+ * ...options }` inherits from an absent key and is overridden by a present `undefined`), and
  * those bags keep the strict declaration, with `delete` as their one spelling of absent (the
  * write-side twin of `compact()` in `script/from-read/values.ts`).
  *
@@ -26,7 +25,7 @@ type MaybeUndefined<T> = Omit<T, OptionalKeysOf<T>> & { [K in OptionalKeysOf<T>]
  * Text options carrying the two members the emitters write onto them.
  *
  * `_bodyProp` is the normalized `a:bodyPr` the definer builds out of the caller's `align`,
- * `valign`, `margin`, `columns`, `textDirection` and `textWarp` — a *derived* shape, not an
+ * `valign`, `margin`, `columns`, `textDirection` and `textWarp`: a *derived* shape, not an
  * input, which is what made its presence on the public interface a de-facto API nobody
  * intended. `_lineIdx` is the paragraph index the run emitter stamps while walking an array
  * of runs.
@@ -53,6 +52,18 @@ interface TextPropsOptionsInternal extends TextPropsOptions {
     prstTxWarp?: TextShapeType;
   };
   _lineIdx?: number;
+  /**
+   * Set by the definer on text that would otherwise be written black: no colour of its own, none
+   * on its shape, not a placeholder, not a link. The emitter paints it in the slide's
+   * {@link Slide.color}, else black. It is a flag rather than the colour because the slide's
+   * colour is read when the slide is written, not when the text is added (#88).
+   */
+  _slideColor?: true;
+  /**
+   * Set by the emitter on a run whose `hyperlink` it took from the shape, so the run writes no
+   * show jump of its own: the shape's lives on its `p:cNvPr`.
+   */
+  _shapeHyperlink?: true;
 }
 /**
  * A slide object's options carrying the six members the definers and emitters write onto them.
@@ -66,7 +77,7 @@ interface TextPropsOptionsInternal extends TextPropsOptions {
  */
 interface ObjectOptionsInternal extends ObjectOptions, TextPropsOptionsInternal {
   _placeholderIdx?: number;
-  _placeholderType?: PLACEHOLDER_TYPE;
+  _placeholderType?: PLACEHOLDER_TYPE | PlaceholderXmlType;
   /** Connector adjust-guide values (OOXML 1000ths-of-a-percent), one per bend; emitted as `<a:gd name="adjN">` */
   _connectorAdj?: number[];
   /** Connector start-point binding: target shape `objectName` (raw, as the caller spelled it) + connection-site index; resolved to `<a:stCxn>` at serialize time */
@@ -110,7 +121,7 @@ interface ChartOptsInternal extends ChartOpts {
   _type?: ChartType | ChartMultiInternal[];
 }
 /**
- * A combo subchart's option overrides after `addChartDefinition` vetted them — the one bag in the
+ * A combo subchart's option overrides after `addChartDefinition` vetted them: the one bag in the
  * generator where a key may be *present* and hold `undefined`.
  *
  * Everywhere else "unset" has exactly one spelling, an absent key: `compact()` enforces it on the
@@ -119,7 +130,7 @@ interface ChartOptsInternal extends ChartOpts {
  * chart-level options at emit time (`{ ...rel.opts, ...type.options }` in `gen/chart/chart-xml.ts`),
  * where a present `undefined` suppresses the chart-level value and an absent key inherits it.
  * Suppressing is the intent: the subchart supplied an override the schema rejects, and the
- * chart-level value is one it never asked for — inheriting it would be a different chart than
+ * chart-level value is one it never asked for. Inheriting it would be a different chart than
  * either party described. For a combo chart the chart-level pass cannot vet these itself, since
  * `_type` is an array there and every type-keyed correction matches no branch.
  */
@@ -148,6 +159,15 @@ interface SlideRelChart extends OptsChartData {
    * via `<mc:AlternateContent>`. Set at define time from {@link isChartExType}.
    */
   isChartEx?: boolean;
+  /**
+   * The pictures the chart part references (a chart or plot area's picture fill), each under the
+   * relationship id the chart part gives it. The media rel is the slide's, marked
+   * {@link SlideRelMedia.chartOwned}, so its `Target` is read at write time, after media dedupe.
+   */
+  media?: Array<{
+    rId: number;
+    rel: SlideRelMedia;
+  }>;
 }
 interface SlideRel {
   type: SlideObjectType;
@@ -155,7 +175,7 @@ interface SlideRel {
    * Relationship target, stored **unescaped**. Every emitter escapes it on the way out
    * (`gen/slide/object.ts`, `gen/slide/notes.ts`, and `read/opc/relationships.ts` for the
    * append path). Escaping at definition time instead would double-escape on append,
-   * where the serializer escapes again — so `&` in a hyperlink or online-video URL must
+   * where the serializer escapes again, so `&` in a hyperlink or online-video URL must
    * arrive here verbatim.
    */
   Target: string;
@@ -171,12 +191,12 @@ interface SlideRelMedia {
   type: string;
   opts?: MediaProps;
   path?: string;
-  extn?: string;
-  data?: string | ArrayBuffer;
+  extn: string;
+  data: string;
   /**
    * An `addMedia` poster frame the caller supplied no `cover` for, so it takes the library's
-   * default play-button artwork. `addMediaDefinition` pushes the rel with this flag and no
-   * `data`; `encodeSlideMediaRels` fills the bytes in during the async media pass, behind the
+   * default play-button artwork. `addMediaDefinition` pushes the rel with this flag and an
+   * empty `data`; `encodeSlideMediaRels` fills the bytes in during the async media pass, behind the
    * dynamic import that keeps the artwork out of every consumer's entry chunk. Every rel
    * carrying it has its `data` resolved before any part is emitted.
    */
@@ -189,7 +209,7 @@ interface SlideRelMedia {
     h: number;
   };
   /**
-   * Embedded OLE object part (`addOleObject`): the `.rels` `Type` URI to emit — `.../package` for
+   * Embedded OLE object part (`addOleObject`): the `.rels` `Type` URI to emit: `.../package` for
    * an embedded OPC package (xlsx/docx/pptx, themselves zips) or `.../oleObject` for a generic OLE
    * server blob (ECMA-376 Part 1 §15.2.10). Present only on OLE payload rels, where it takes
    * precedence over the image/audio/video branch in `slideObjectRelationsToXml` and `type` carries
@@ -198,7 +218,7 @@ interface SlideRelMedia {
    */
   oleRelType?: string;
   /**
-   * Embedded 3D model part (`addModel3d`): the `.rels` `Type` URI to emit — the Microsoft
+   * Embedded 3D model part (`addModel3d`): the `.rels` `Type` URI to emit: the Microsoft
    * `…/office/2017/06/relationships/model3d` type, which no `includes('image'|'audio'|'video')`
    * sniff would ever reach. Present only on the `.glb` payload rel, where it takes precedence
    * over the image/audio/video branch in `slideObjectRelationsToXml` and `type` carries the
@@ -206,8 +226,14 @@ interface SlideRelMedia {
    * separate, perfectly ordinary image rel. Same escape hatch as {@link oleRelType}.
    */
   model3dRelType?: string;
+  /**
+   * The picture of a chart's area fill, registered on the slide so the media pass loads, dedupes and
+   * writes its part like any other picture. The chart part references it (see
+   * {@link SlideRelChart.media}); the slide does not, so the slide's `.rels` leaves it out.
+   */
+  chartOwned?: true;
   rId: number;
-  /** Unescaped — see {@link SlideRel.Target}. Doubles as the zip entry name for embedded media. */
+  /** Unescaped; see {@link SlideRel.Target}. Doubles as the zip entry name for embedded media. */
   Target: string;
 }
 interface SlideObject {
@@ -229,6 +255,7 @@ interface SlideObject {
   zoom?: ZoomInternal;
   ole?: OleInternal;
   model3d?: Model3dInternal;
+  _seeded?: boolean;
 }
 /**
  * Resolved 3D-model payload carried on a {@link SlideObject} until `gen/slide/objects/model3d.ts`
@@ -239,7 +266,7 @@ interface SlideObject {
 interface Model3dInternal {
   /** rId of the embedded `.glb` part rel (see {@link SlideRelMedia.model3dRelType}). */
   modelRid: number;
-  /** rId of the preview picture's image rel — shared by `am3d:blip` and the `mc:Fallback` `p:pic`. */
+  /** rId of the preview picture's image rel, shared by `am3d:blip` and the `mc:Fallback` `p:pic`. */
   previewRid: number;
   /** `am3d:camera/am3d:pos` (`@x`/`@y`/`@z`). */
   pos: {
@@ -270,9 +297,9 @@ interface OleInternal {
   objectRid: number;
   /** rId of the preview picture's image rel (`p:pic > a:blip@r:embed`). */
   previewRid: number;
-  /** `p:oleObj@progId` — the OLE server PowerPoint launches on double-click. */
+  /** `p:oleObj@progId`: the OLE server PowerPoint launches on double-click. */
   progId: string;
-  /** `p:oleObj@name` — the object's kind as PowerPoint labels it (`Worksheet`, `Document`, …). */
+  /** `p:oleObj@name`: the object's kind as PowerPoint labels it (`Worksheet`, `Document`, …). */
   name: string;
   /** `p:oleObj@showAsIcon`; omitted when false, matching PowerPoint. */
   showAsIcon: boolean;
@@ -349,6 +376,8 @@ interface PresSlideInternal extends SlideBaseProps, Slide {
   _rId: number;
   _slideLayout: SlideLayoutInternal | null;
   _slideId: number;
+  /** Review comments; a slide always has the list, empty until `addComment` pushes one. */
+  _comments: SlideComment[];
   /** Preset build animations on this slide, in play order (see {@link Slide.addAnimation}). */
   _animations: AnimationProps[];
 }
@@ -372,11 +401,9 @@ interface PresentationPropsInternal extends PresentationProps {
   sections: SectionInternalProps[];
   slideLayouts: SlideLayoutInternal[];
   slides: PresSlideInternal[];
-  /** Author-side embedded fonts (see {@link TsPptx.embedFont}); empty when none. */
+  /** Author-side embedded fonts (see {@link PptxTs.embedFont}); empty when none. */
   embeddedFonts: EmbeddedFont[];
 }
-//#endregion
-//#region src/measure/text-fit.d.ts
 /**
  * PowerPoint single-spacing line pitch as a multiple of font size.
  *
@@ -395,7 +422,7 @@ declare const MIN_FONT_SCALE_PCT = 25;
  * Conservative safety factors applied by the shrink solver (not by the pure
  * `measureHeightPt`). Raw `hmtx` advances summed without shaping still pack a line
  * a little tighter than PowerPoint, which lays text out at a device DPI and rounds
- * each glyph advance up — so PowerPoint wraps marginally earlier and its fitted
+ * each glyph advance up, so PowerPoint wraps marginally earlier and its fitted
  * box is marginally taller. Inflating measured width and height by these factors
  * makes the computed `fontScale` ≤ PowerPoint's across the calibration oracle
  * (`test/read/autofit-calibration-oracle.test.ts`: 0 violations over the Aptos
@@ -420,7 +447,7 @@ interface FitRun {
  * generator's option bags follow (`options-internal.ts`): these are measurement records, built in
  * one place by `paragraphs.ts` and read in one place by the solver below, with `??` and
  * truthiness. Nothing spreads or enumerates them, so a key holding `undefined` cannot mean
- * anything different from an absent one — and the builder does produce every key on every run.
+ * anything different from an absent one, and the builder does produce every key on every run.
  * Saying so is more honest than making the builder omit keys nothing distinguishes.
  */
 interface FitParagraph {
@@ -440,7 +467,7 @@ interface FitBox {
    * `false` when the frame does not wrap (`wrap:false` / `wrap="none"`): text lays
    * out as one line per paragraph (no width-wrapping), and the shrink solver must
    * additionally keep the widest line within `innerWidthPt`. A too-wide line
-   * overflows HORIZONTALLY — `normAutofit`'s vertical shrink never catches it, so
+   * overflows HORIZONTALLY. `normAutofit`'s vertical shrink never catches it, so
    * without this check a non-wrapping line is never shrunk and spills out of the box
    * in PowerPoint. Defaults to wrapping (`true`), so table cells and `measureText`
    * are unaffected.
@@ -494,10 +521,10 @@ type ResizeOutcome = {
   neededInnerHeightPt: number;
 };
 /**
- * Inner height (points) the text needs at full size — the value to bake into the
+ * Inner height (points) the text needs at full size: the value to bake into the
  * shape's `a:ext/@cy` for `fit: 'resize'` (`spAutoFit`). Unlike shrink, resize has
  * **no safety net**: an under-estimate overflows (there is no text scaling
- * fallback), so this errs **tall** — width is inflated (earlier wrap ⇒ more lines)
+ * fallback), so this errs **tall**. Width is inflated (earlier wrap ⇒ more lines)
  * and the laid-out height by the calibrated height factor, so the computed `cy` is
  * ≥ PowerPoint's and ≥ the LibreOffice-rendered height across the resize oracle.
  */
@@ -507,14 +534,12 @@ declare function solveResize(paragraphs: FitParagraph[], box: FitBox, resolve: M
  * Width and height both re-measured per scale. Conservative: because the model
  * over-estimates, the returned scale is ≤ PowerPoint's and the text never overflows.
  *
- * `lnSpcReduction` is left at 0 — dropping `fontScale` alone is provably
+ * `lnSpcReduction` is left at 0: dropping `fontScale` alone is provably
  * conservative (PowerPoint trades line-spacing reduction to keep the font *larger*,
  * so a reduction-free fit is always ≤ PowerPoint's scale). The reduction ramp
  * PowerPoint applies is recorded in `docs/contributing/design/text-fit.md`.
  */
 declare function solveShrink(paragraphs: FitParagraph[], box: FitBox, resolve: MetricsResolver): ShrinkOutcome;
-//#endregion
-//#region src/measure/font-metrics.d.ts
 /** Per-(face,bold,italic) advance-width source backed by a parsed font file. */
 interface FontMetrics {
   /** Font design units per em (advances are in these units). */
@@ -536,7 +561,7 @@ interface FontMetrics {
 /**
  * Shared, font-independent `FontMetrics` used when a named face has no registered
  * metrics but the deck has opted into measured fit (some other face is registered).
- * Approximate but conservative — see `heuristicCharRatio`. A deck with no
+ * Approximate but conservative; see `heuristicCharRatio`. A deck with no
  * registered metrics at all does not engage measured fit, so this never fires there.
  */
 declare function getHeuristicFontMetrics(): FontMetrics;
@@ -587,7 +612,7 @@ declare class FontMetricsRegistry {
    * Coverage of code point `cp` for `face`, read from the registered font's cmap:
    * `true`/`false` when a variant of `face` is registered (see {@link get} for the
    * exact→regular→any-variant fallback), or `undefined` when the face has **no**
-   * registered metrics — "unknown", deliberately distinct from a `false`
+   * registered metrics: "unknown", deliberately distinct from a `false`
    * "registered but not covered". A coverage audit must not treat an unregistered
    * face as fully covered, so callers get `undefined` here rather than the per-face
    * {@link FontMetrics.hasCodepoint} boolean (which, for the heuristic fallback,
@@ -608,6 +633,5 @@ declare class FontMetricsRegistry {
  * no `fontFace` at all resolves to `undefined`, which the callers treat as unmeasurable.
  */
 declare function makeRegistryResolver(registry: FontMetricsRegistry, onHeuristic?: (face: string) => void): MetricsResolver;
-//#endregion
 export { SlideObject as A, solveShrink as C, SectionInternalProps as D, PresentationPropsInternal as E, SlideRelChart as M, SlideRelMedia as N, SlideLayoutInternal as O, solveResize as S, PresSlideInternal as T, ShrinkOutcome as _, makeRegistryResolver as a, measureHeightPt as b, FitBox as c, HEIGHT_SAFETY_FACTOR as d, LayoutResult as f, SINGLE_LINE_PITCH as g, ResizeOutcome as h, getHeuristicFontMetrics as i, SlideRel as j, SlideMasterInternal as k, FitParagraph as l, MetricsResolver as m, FontMetricsRegistry as n, parseFontMetrics as o, MIN_FONT_SCALE_PCT as p, ParseFontMetricsOptions as r, FONT_SCALE_STEP_PCT as s, FontMetrics as t, FitRun as u, ShrinkResult as v, ObjectOptionsInternal as w, measureLayout as x, WIDTH_SAFETY_FACTOR as y };
-//# sourceMappingURL=font-metrics-CBGmhLo0.d.ts.map
+//# sourceMappingURL=font-metrics-DTppw4t3.d.ts.map

package/dist/font-metrics-DTppw4t3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-metrics-DTppw4t3.d.ts","names":[],"sources":["../src/types/internal.ts","../src/measure/text-fit.ts","../src/measure/font-metrics.ts"],"mappings":"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"}

package/dist/{grid-9B2w5EaY.js → grid-DUIMxjfl.js}

@@ -1,5 +1,5 @@
-import { l as warn } from "./errors-Da2nXCJm.js";
-//#region src/gen/table/spans.ts
+import { u as warn } from "./entry-errors-JMthgJ2g.js";
+// src/gen/table/spans.ts
 /**
 * The largest `colspan`/`rowspan` this library will honour.
 *
@@ -14,14 +14,14 @@ const MAX_TABLE_SPAN = 1e3;
 * Validate one cell's `colspan`/`rowspan`, warning and falling back to `1` when it is not a whole
 * number in `1..MAX_TABLE_SPAN`.
 *
-* `undefined` is the common case and means "no span" — it warns about nothing and returns `1`.
+* `undefined` is the common case and means "no span": it warns about nothing and returns `1`.
 * Everything else is caller error: `NaN`, a negative, a fraction and a span past the ceiling all
 * describe a table that cannot be built (a fractional span silently truncates, a negative one
 * shifts every column after it, an enormous one is the allocation above).
 *
 * The parameter is typed `unknown` because this is also **the** reading of a span for the six
 * sites that consume one after {@link withCheckedSpans} has run. Those had six different
-* coercions — `Number(x) ? … : 1`, `Math.max(1, Number(x) || 1)`, `x ?? 1` — which agreed only
+* coercions (`Number(x) ? … : 1`, `Math.max(1, Number(x) || 1)`, `x ?? 1`), which agreed only
 * on the values that were already valid, and one of them let a non-numeric span reach a grid
 * column count as `NaN`. Reading a span through one function is what stops them drifting apart
 * again if the up-front check is ever moved.
@@ -45,7 +45,7 @@ function resolveSpan(value, kind) {
 * Re-clone `rows` with every out-of-range `colspan`/`rowspan` corrected to `1`.
 *
 * Runs once, up front, so the column count, the `_hmerge`/`_vmerge` dummies, the auto-pager's
-* grid and the emitted `gridSpan`/`rowSpan` attributes all read the same number — checking at
+* grid and the emitted `gridSpan`/`rowSpan` attributes all read the same number. Checking at
 * each of those sites instead would warn several times per bad cell and could still disagree.
 *
 * A cell whose spans are fine is passed through by identity, not copied: `_spanOrigin` links the
@@ -74,27 +74,25 @@ function withCheckedSpans(rows) {
 	}));
 }
 /**
-* Whether any cell in the grid carries a hyperlink — on the cell itself, or on any run of a
-* cell whose `text` is a run array.
+* Whether a cell carries a hyperlink, on the cell itself or on any run of its `text` when that
+* is a run array.
 *
-* `addTable` uses this to decide whether to stand its black text default down: the default is
-* direct formatting on the table, so it would paint the words *after* a link black rather than
-* letting them follow the link colour. The test used to be
-* `JSON.stringify({ arrRows }).includes('hyperlink')`, which matched the literal word anywhere
-* in the grid's *content* — a cell reading "see the hyperlink docs" suppressed the default for
-* the whole table — and serialized every cell on every `addTable` to ask.
-* @param rows - the table's rows
+* The table's black text default is direct formatting on the cell's runs, so on a linked cell it
+* would paint the words *after* the link black rather than letting them follow the link colour.
+* The emitter stands the default down for such a cell, and only for it: the test used to be
+* table-wide, so one link stripped the default from every cell in the grid and a cell's output
+* depended on its neighbours (#101). Before that it was
+* `JSON.stringify({ arrRows }).includes('hyperlink')`, which matched the literal word anywhere in
+* the grid's *content*.
+* @param cell - the cell, or a hole in the grid
 */
-function tableHasHyperlink(rows) {
-	return rows.some((cells) => cells.some((cell) => {
-		if (!cell) return false;
-		if (cell.options?.hyperlink) return true;
-		if (!Array.isArray(cell.text)) return false;
-		return cell.text.some((run) => !!run?.options?.hyperlink);
-	}));
+function cellHasHyperlink(cell) {
+	if (!cell) return false;
+	if (cell.options?.hyperlink) return true;
+	if (!Array.isArray(cell.text)) return false;
+	return cell.text.some((run) => !!run?.options?.hyperlink);
 }
-//#endregion
-//#region src/gen/table/grid.ts
+// src/gen/table/grid.ts
 /**
 * How many grid columns a table has: the sum of the first row's colspans.
 *
@@ -181,7 +179,6 @@ function* walkTableGrid(rows, numCols) {
 		occupancy.endRow();
 	}
 }
-//#endregion
-export { resolveSpan as a, MAX_TABLE_SPAN as i, tableColCount as n, tableHasHyperlink as o, walkTableGrid as r, withCheckedSpans as s, createRowSpanOccupancy as t };
+export { cellHasHyperlink as a, MAX_TABLE_SPAN as i, tableColCount as n, resolveSpan as o, walkTableGrid as r, withCheckedSpans as s, createRowSpanOccupancy as t };
 
-//# sourceMappingURL=grid-9B2w5EaY.js.map
+//# sourceMappingURL=grid-DUIMxjfl.js.map

package/dist/grid-DUIMxjfl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-DUIMxjfl.js","names":[],"sources":["../src/gen/table/spans.ts","../src/gen/table/grid.ts"],"sourcesContent":["/**\n * pptx-ts: table `colspan`/`rowspan` range checking.\n *\n * The spans decide two allocations, on two different paths, and both used to trust the caller:\n * the merge grid's `new Array(colspan - 1)` in `gen/slide/objects/table.ts`, and the auto-pager's\n * per-column depth array, sized from a column count that is a sum of colspans\n * (`gen/table/autopage.ts`). `new Array(4294967294).fill(undefined)` is not a slow path: V8\n * aborts on the allocation and there is no exception to catch. So a table built with\n * `autoPage: true` and one without needed the same guard, which is why it lives here rather than\n * in either of them.\n *\n * This is the write side, so the bad number comes from the calling program rather than from a\n * hostile file, which makes it far less serious than the read-side twin in the chart point caches\n * (`read/oxml/point-cache.ts`, the model this copies). It is still the project's stated line: warn\n * on out-of-range input rather than emit a degenerate result.\n */\n\nimport type { TableCellInternal } from '../../types/internal.js'\nimport { warn } from '../../diagnostics.js'\n\n/**\n * The largest `colspan`/`rowspan` this library will honour.\n *\n * Unlike the read side's point-cache ceiling there is no format number to borrow: `a:tc@gridSpan`\n * is a bare `xsd:int`. So this is a sanity bound rather than a schema one, and it is set an order\n * of magnitude past PowerPoint's own maximum table (its Insert Table dialog stops at 75 columns\n * and 75 rows), which is what makes it something no authored table can reach. What it stops is\n * the other end, where the allocation takes the host process with it.\n */\nexport const MAX_TABLE_SPAN = 1000\n\n/**\n * Validate one cell's `colspan`/`rowspan`, warning and falling back to `1` when it is not a whole\n * number in `1..MAX_TABLE_SPAN`.\n *\n * `undefined` is the common case and means \"no span\": it warns about nothing and returns `1`.\n * Everything else is caller error: `NaN`, a negative, a fraction and a span past the ceiling all\n * describe a table that cannot be built (a fractional span silently truncates, a negative one\n * shifts every column after it, an enormous one is the allocation above).\n *\n * The parameter is typed `unknown` because this is also **the** reading of a span for the six\n * sites that consume one after {@link withCheckedSpans} has run. Those had six different\n * coercions (`Number(x) ? … : 1`, `Math.max(1, Number(x) || 1)`, `x ?? 1`), which agreed only\n * on the values that were already valid, and one of them let a non-numeric span reach a grid\n * column count as `NaN`. Reading a span through one function is what stops them drifting apart\n * again if the up-front check is ever moved.\n * @param value - the raw option value, as the caller wrote it\n * @param kind - `'colspan'` or `'rowspan'`, for the diagnostic\n * @returns the span to use, at least 1\n */\nexport function resolveSpan(value: unknown, kind: 'colspan' | 'rowspan'): number {\n\tif (value === undefined || value === null || value === '') return 1\n\tif (typeof value !== 'number') {\n\t\twarn(\n\t\t\t'table/span-out-of-range',\n\t\t\t`table cell: ${kind} must be a whole number between 1 and ${MAX_TABLE_SPAN}; got ${String(value)}. Using 1.`\n\t\t)\n\t\treturn 1\n\t}\n\tif (!Number.isInteger(value) || value < 1 || value > MAX_TABLE_SPAN) {\n\t\twarn(\n\t\t\t'table/span-out-of-range',\n\t\t\t`table cell: ${kind} must be a whole number between 1 and ${MAX_TABLE_SPAN}; got ${String(value)}. Using 1.`\n\t\t)\n\t\treturn 1\n\t}\n\treturn value\n}\n\n/**\n * Re-clone `rows` with every out-of-range `colspan`/`rowspan` corrected to `1`.\n *\n * Runs once, up front, so the column count, the `_hmerge`/`_vmerge` dummies, the auto-pager's\n * grid and the emitted `gridSpan`/`rowSpan` attributes all read the same number. Checking at\n * each of those sites instead would warn several times per bad cell and could still disagree.\n *\n * A cell whose spans are fine is passed through by identity, not copied: `_spanOrigin` links the\n * merge dummies back to the origin *object*, and the all-valid path is every real table, which\n * must stay allocation-free and byte-identical.\n * @param rows - the rows to check; row arrays are never mutated\n * @returns the same rows with only the offending cells replaced\n */\nexport function withCheckedSpans(rows: TableCellInternal[][]): TableCellInternal[][] {\n\treturn rows.map((cells) =>\n\t\tcells.map((cell) => {\n\t\t\tconst opts = cell?.options\n\t\t\tif (!opts) return cell\n\t\t\tconst colspan = resolveSpan(opts.colspan, 'colspan')\n\t\t\tconst rowspan = resolveSpan(opts.rowspan, 'rowspan')\n\t\t\tconst colspanOk = opts.colspan === undefined || opts.colspan === colspan\n\t\t\tconst rowspanOk = opts.rowspan === undefined || opts.rowspan === rowspan\n\t\t\tif (colspanOk && rowspanOk) return cell\n\t\t\treturn {\n\t\t\t\t...cell,\n\t\t\t\toptions: {\n\t\t\t\t\t...opts,\n\t\t\t\t\t...(opts.colspan === undefined ? {} : { colspan }),\n\t\t\t\t\t...(opts.rowspan === undefined ? {} : { rowspan }),\n\t\t\t\t},\n\t\t\t}\n\t\t})\n\t)\n}\n\n/**\n * Whether a cell carries a hyperlink, on the cell itself or on any run of its `text` when that\n * is a run array.\n *\n * The table's black text default is direct formatting on the cell's runs, so on a linked cell it\n * would paint the words *after* the link black rather than letting them follow the link colour.\n * The emitter stands the default down for such a cell, and only for it: the test used to be\n * table-wide, so one link stripped the default from every cell in the grid and a cell's output\n * depended on its neighbours (#101). Before that it was\n * `JSON.stringify({ arrRows }).includes('hyperlink')`, which matched the literal word anywhere in\n * the grid's *content*.\n * @param cell - the cell, or a hole in the grid\n */\nexport function cellHasHyperlink(cell: TableCellInternal | undefined): boolean {\n\tif (!cell) return false\n\tif (cell.options?.hyperlink) return true\n\tif (!Array.isArray(cell.text)) return false\n\treturn cell.text.some((run) => !!run?.options?.hyperlink)\n}\n","/**\n * pptx-ts: a table's cell grid.\n *\n * Rows arrive lopsided -- `row1: [A, B, C]`, `row2: [D]` when the first two columns are held by\n * a rowspan from above -- so a cell's position in its row array is not its column. Four places\n * needed to know where a cell actually lands (the auto-pager, twice, in one function; the\n * measured-fit pass; the table emitter) and each walked the grid itself, tracking rowspan\n * occupancy in its own array with its own off-by-one convention.\n *\n * This is that traversal, once. It lives beside {@link resolveSpan} rather than in `measure/`\n * because the grid is a fact about the authored table, not a measurement of it -- the pager and\n * the emitter want it as much as the fitter does, and `measure/table-fit.ts` was already\n * reaching into `gen/table/` for the span reader it is built on.\n */\n\nimport type { TableCellInternal } from '../../types/internal.js'\nimport { resolveSpan } from './spans.js'\n\n/**\n * How many grid columns a table has: the sum of the first row's colspans.\n *\n * The count cannot come from `rows[0].length` -- a colspan makes one cell occupy several\n * columns -- and it is read off the first row alone, which is the writer's standing rule: a\n * later row wider than the first is ragged input, and the grid it is measured, paged and\n * emitted against is the one `a:tblGrid` declares.\n */\nexport function tableColCount(rows: TableCellInternal[][]): number {\n\tconst first = rows[0]\n\treturn first ? first.reduce((n, c) => n + resolveSpan(c?.options?.colspan, 'colspan'), 0) : 0\n}\n\n/** The bookkeeping a row-major grid walk needs to route around rowspans; see {@link createRowSpanOccupancy}. */\ninterface RowSpanOccupancy {\n\t/** The first column at or after `col` that no rowspan from above is holding. */\n\tnextFree: (col: number) => number\n\t/** Record that `colSpan` columns from `col` are held for `rowSpan` rows, this one included. */\n\thold: (col: number, colSpan: number, rowSpan: number) => void\n\t/** Close the current row: every held column has one fewer row left to hold. */\n\tendRow: () => void\n}\n\n/**\n * The rowspan-occupancy rule, stated once.\n *\n * A row states only the cells it *starts*: a column held by a `rowspan` from above is filled\n * without the row mentioning it, so a cell's position in its row array is not its column. Tracking\n * that is three operations -- skip what is held, mark what this cell holds, age the holds by a row\n * -- and getting the ageing off by one silently shifts every column below.\n *\n * It has two callers asking different questions on different input. {@link walkTableGrid} places\n * authored `TableCell`s into a grid whose width `a:tblGrid` already declares; `measureGridColumns`\n * (`gen/table/html-dom.ts`) measures how wide an imported HTML table's grid *is*, reading spans off\n * HTML attributes, with no width known up front. Neither can be expressed as the other without\n * giving one of them a mode it does not want -- but the rule underneath is the same rule, and it is\n * here rather than in both.\n *\n * The array is sparse and unbounded on purpose: a caller that knows its width clamps what it\n * `hold`s, and then nothing past that width is ever held, so an unbounded `nextFree` returns the\n * same answer a bounded one would.\n */\nexport function createRowSpanOccupancy(): RowSpanOccupancy {\n\t// held[c] = rows still covered by a rowspan started at or above the current row.\n\tconst held: number[] = []\n\treturn {\n\t\tnextFree(col) {\n\t\t\tlet free = col\n\t\t\twhile ((held[free] ?? 0) > 0) free++\n\t\t\treturn free\n\t\t},\n\t\thold(col, colSpan, rowSpan) {\n\t\t\tfor (let idx = 0; idx < colSpan; idx++) held[col + idx] = rowSpan\n\t\t},\n\t\tendRow() {\n\t\t\tfor (let idx = 0; idx < held.length; idx++) {\n\t\t\t\tconst rows = held[idx] ?? 0\n\t\t\t\tif (rows > 0) held[idx] = rows - 1\n\t\t\t}\n\t\t},\n\t}\n}\n\n/** A placed (non-merged origin) cell yielded by {@link walkTableGrid}. */\nexport interface GridPlacement {\n\tcell: TableCellInternal\n\t/** Zero-based grid row of the cell's top-left origin. */\n\trow: number\n\t/** Zero-based grid column of the cell's top-left origin. */\n\tcol: number\n\t/** Rows spanned, clamped to the available rows. */\n\trowSpan: number\n\t/** Columns spanned, clamped to the grid width. */\n\tcolSpan: number\n}\n\n/**\n * Walk a table's cell grid in row-major order, resolving each authored cell to its\n * grid origin (`row`/`col`) and clamped colspan/rowspan. Tracks rowspan occupancy so\n * a cell never lands beneath one spanned from above. This is the single traversal the\n * auto-pager, the measured-fit shrink pass, {@link computeTableLayout} and the table emitter's\n * merge grid all read, so the table that is paged and measured is the table that is written.\n *\n * A cell that starts past the last grid column is not yielded: a row longer than the first is\n * ragged input, and the grid is the one `a:tblGrid` declares.\n */\nexport function* walkTableGrid(rows: TableCellInternal[][], numCols: number): Generator<GridPlacement> {\n\tconst occupancy = createRowSpanOccupancy()\n\tfor (let r = 0; r < rows.length; r++) {\n\t\tconst row = rows[r]\n\t\tif (!row) continue\n\t\tlet col = 0\n\t\tfor (const cell of row) {\n\t\t\tcol = occupancy.nextFree(col)\n\t\t\tif (col >= numCols) break\n\t\t\tconst colspan = resolveSpan(cell?.options?.colspan, 'colspan')\n\t\t\tconst rowspan = Math.min(resolveSpan(cell?.options?.rowspan, 'rowspan'), rows.length - r)\n\t\t\tconst colStart = col\n\t\t\t// Clamped to the declared width, which is also what keeps `nextFree` unbounded and still\n\t\t\t// correct: nothing past `numCols` is ever held, so it never has a reason to walk past it.\n\t\t\tconst colEnd = Math.min(colStart + colspan, numCols)\n\t\t\toccupancy.hold(colStart, colEnd - colStart, rowspan)\n\t\t\tcol = colEnd\n\t\t\tyield { cell, row: r, col: colStart, rowSpan: rowspan, colSpan: colEnd - colStart }\n\t\t}\n\t\toccupancy.endRow()\n\t}\n}\n"],"mappings":";;;;;;;;;;;AA6BA,MAAa,iBAAiB;;;;;;;;;;;;;;;;;;;;AAqB9B,SAAgB,YAAY,OAAgB,MAAqC;CAChF,IAAI,UAAU,KAAA,KAAa,UAAU,QAAQ,UAAU,IAAI,OAAO;CAClE,IAAI,OAAO,UAAU,UAAU;EAC9B,KACC,2BACA,eAAe,KAAK,wCAAwC,eAAe,QAAQ,OAAO,KAAK,EAAE,WAClG;EACA,OAAO;CACR;CACA,IAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,KAAK,QAAA,KAAwB;EACpE,KACC,2BACA,eAAe,KAAK,wCAAwC,eAAe,QAAQ,OAAO,KAAK,EAAE,WAClG;EACA,OAAO;CACR;CACA,OAAO;AACR;;;;;;;;;;;;;;AAeA,SAAgB,iBAAiB,MAAoD;CACpF,OAAO,KAAK,KAAK,UAChB,MAAM,KAAK,SAAS;EACnB,MAAM,OAAO,MAAM;EACnB,IAAI,CAAC,MAAM,OAAO;EAClB,MAAM,UAAU,YAAY,KAAK,SAAS,SAAS;EACnD,MAAM,UAAU,YAAY,KAAK,SAAS,SAAS;EACnD,MAAM,YAAY,KAAK,YAAY,KAAA,KAAa,KAAK,YAAY;EACjE,MAAM,YAAY,KAAK,YAAY,KAAA,KAAa,KAAK,YAAY;EACjE,IAAI,aAAa,WAAW,OAAO;EACnC,OAAO;GACN,GAAG;GACH,SAAS;IACR,GAAG;IACH,GAAI,KAAK,YAAY,KAAA,IAAY,CAAC,IAAI,EAAE,QAAQ;IAChD,GAAI,KAAK,YAAY,KAAA,IAAY,CAAC,IAAI,EAAE,QAAQ;GACjD;EACD;CACD,CAAC,CACF;AACD;;;;;;;;;;;;;;AAeA,SAAgB,iBAAiB,MAA8C;CAC9E,IAAI,CAAC,MAAM,OAAO;CAClB,IAAI,KAAK,SAAS,WAAW,OAAO;CACpC,IAAI,CAAC,MAAM,QAAQ,KAAK,IAAI,GAAG,OAAO;CACtC,OAAO,KAAK,KAAK,MAAM,QAAQ,CAAC,CAAC,KAAK,SAAS,SAAS;AACzD;;;;;;;;;;AChGA,SAAgB,cAAc,MAAqC;CAClE,MAAM,QAAQ,KAAK;CACnB,OAAO,QAAQ,MAAM,QAAQ,GAAG,MAAM,IAAI,YAAY,GAAG,SAAS,SAAS,SAAS,GAAG,CAAC,IAAI;AAC7F;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,yBAA2C;CAE1D,MAAM,OAAiB,CAAC;CACxB,OAAO;EACN,SAAS,KAAK;GACb,IAAI,OAAO;GACX,QAAQ,KAAK,SAAS,KAAK,GAAG;GAC9B,OAAO;EACR;EACA,KAAK,KAAK,SAAS,SAAS;GAC3B,KAAK,IAAI,MAAM,GAAG,MAAM,SAAS,OAAO,KAAK,MAAM,OAAO;EAC3D;EACA,SAAS;GACR,KAAK,IAAI,MAAM,GAAG,MAAM,KAAK,QAAQ,OAAO;IAC3C,MAAM,OAAO,KAAK,QAAQ;IAC1B,IAAI,OAAO,GAAG,KAAK,OAAO,OAAO;GAClC;EACD;CACD;AACD;;;;;;;;;;;AAyBA,UAAiB,cAAc,MAA6B,SAA2C;CACtG,MAAM,YAAY,uBAAuB;CACzC,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACrC,MAAM,MAAM,KAAK;EACjB,IAAI,CAAC,KAAK;EACV,IAAI,MAAM;EACV,KAAK,MAAM,QAAQ,KAAK;GACvB,MAAM,UAAU,SAAS,GAAG;GAC5B,IAAI,OAAO,SAAS;GACpB,MAAM,UAAU,YAAY,MAAM,SAAS,SAAS,SAAS;GAC7D,MAAM,UAAU,KAAK,IAAI,YAAY,MAAM,SAAS,SAAS,SAAS,GAAG,KAAK,SAAS,CAAC;GACxF,MAAM,WAAW;GAGjB,MAAM,SAAS,KAAK,IAAI,WAAW,SAAS,OAAO;GACnD,UAAU,KAAK,UAAU,SAAS,UAAU,OAAO;GACnD,MAAM;GACN,MAAM;IAAE;IAAM,KAAK;IAAG,KAAK;IAAU,SAAS;IAAS,SAAS,SAAS;GAAS;EACnF;EACA,UAAU,OAAO;CAClB;AACD"}