@silurus/ooxml 0.71.0 → 0.72.0

package/dist/types/pptx.d.ts

@@ -61,11 +61,18 @@ export declare interface BlipBullet {
     /** MIME type of the blip at {@link BlipBullet.imagePath} (e.g. `image/png`). */
     mimeType: string;
     /**
-     * `<a:buSzPct val>` (ECMA-376 §21.1.2.4.3) as a percentage of the text size
+     * `<a:buSzPct val>` (ECMA-376 §21.1.2.4.9) as a percentage of the text size
      * (100 = same size). `null` when no explicit `<a:buSzPct>` is present, in
      * which case the renderer uses the spec default of 100%.
      */
     sizePct: number | null;
+    /**
+     * `<a:buSzPts val>` (ECMA-376 §21.1.2.4.10) — an ABSOLUTE marker size in
+     * points, independent of the text size. Mutually exclusive with {@link
+     * BlipBullet.sizePct} (both are the one `EG_TextBulletSize` choice). Omitted
+     * when no explicit `<a:buSzPts>` is present; when present it takes precedence.
+     */
+    sizePts?: number;
 }
 
 /**
@@ -73,11 +80,16 @@ export declare interface BlipBullet {
  * by shape frame (with the shape's rotation) so each box lands on the drawn
  * glyphs.
  *
- * @param layer     the overlay div (cleared + re-sized here).
+ * All coordinates are PERCENTAGES of `cssWidth`/`cssHeight`, and the container's
+ * own size is left untouched (`width:100%;height:100%` from the caller), so the
+ * highlights track the canvas's ACTUAL rendered box even when a consumer scales
+ * the canvas down with external CSS — mirroring {@link buildPptxTextLayer}.
+ *
+ * @param layer     the overlay div (cleared here; sized `100%` by the caller).
  * @param runs      the slide's runs (same array the slide was rendered from).
  * @param matches   the slide's matches (run-slices + active flag).
- * @param cssWidth  rendered canvas CSS width (px, number).
- * @param cssHeight rendered canvas CSS height (px, number).
+ * @param cssWidth  the slide's intended CSS width (px, number) — the % denominator.
+ * @param cssHeight the slide's intended CSS height (px, number) — the % denominator.
  * @param measureForFont returns a width-measurer primed with a run's font.
  * @param colors    optional colour overrides.
  */
@@ -102,10 +114,19 @@ export declare function buildPptxHighlightLayer(layer: HTMLDivElement, runs: Ppt
  * (no hyperlink) is byte-identical to before. A JS click handler is used rather
  * than an `<a href>` so the URL never bypasses the viewer's sanitisation.
  *
- * @param layer     the overlay div.
+ * The overlay's coordinates are all PERCENTAGES of `cssWidth`/`cssHeight` (the
+ * slide's intended CSS-px box), never literal px, and the container's own
+ * `width`/`height` are left untouched (the caller sizes it `width:100%;
+ * height:100%` so it fills the wrapper). This lets the overlay track the canvas's
+ * ACTUAL rendered box even when a consumer scales the canvas down with external
+ * CSS (e.g. `width:100%!important;height:auto`): the wrapper (and therefore the
+ * `100%` container) shrinks with the canvas, and every `%`-placed child scales
+ * with it, so nothing overflows the wrapper into an ancestor's scroll area.
+ *
+ * @param layer     the overlay div (sized `width:100%;height:100%` by the caller).
  * @param runs      per-run + per-shape geometry from `renderSlide({ onTextRun })`.
- * @param cssWidth  the rendered canvas's CSS width (px, number).
- * @param cssHeight the rendered canvas's CSS height (px, number).
+ * @param cssWidth  the slide's intended CSS width (px, number) — the % denominator.
+ * @param cssHeight the slide's intended CSS height (px, number) — the % denominator.
  * @param onHyperlinkClick called with the run's resolved {@link HyperlinkTarget}
  *                         when a hyperlink span is clicked. Omit to leave links
  *                         non-interactive (spans stay plain, selectable text).
@@ -120,6 +141,13 @@ export declare function buildPptxTextLayer(layer: HTMLDivElement, runs: PptxText
  */
 export declare type Bullet = Bullet_2 | BlipBullet;
 
+/**
+ * A paragraph's bullet marker. For `char`, the marker size is EITHER `sizePct`
+ * (a percentage of the run size — ECMA-376 §21.1.2.4.9 `<a:buSzPct>`) OR `sizePts`
+ * (an absolute size in points — §21.1.2.4.10 `<a:buSzPts>`), never both: they are
+ * the one `EG_TextBulletSize` xsd:choice. `sizePts` is optional (absent when no
+ * `<a:buSzPts>` was declared); when present it takes precedence over `sizePct`.
+ */
 declare type Bullet_2 = {
     type: 'none';
 } | {
@@ -129,11 +157,13 @@ declare type Bullet_2 = {
     char: string;
     color: string | null;
     sizePct: number | null;
+    sizePts?: number;
     fontFamily: string | null;
 } | {
     type: 'autoNum';
     numType: string;
     startAt: number | null;
+    color: string | null;
 };
 
 /**
@@ -334,6 +364,14 @@ export declare interface ChartModel {
     title: string | null;
     categories: string[];
     series: ChartSeries[];
+    /**
+     * §21.2.2.227 `<c:varyColors val="1"/>` on a SINGLE-series bar/column chart:
+     * color each data point (bar) from the theme/palette sequence and list one
+     * legend entry per point, matching Office. Set by the shared parser ONLY for
+     * that non-pie, single-series case (pie/doughnut already vary by point via
+     * `chartType` + `dataPointColors`); absent/false otherwise.
+     */
+    varyColors?: boolean | null;
     /** Show data labels on bars / points / slices. */
     showDataLabels: boolean;
     /** Explicit Y-axis minimum (OOXML `<c:valAx><c:min>`). */
@@ -1103,6 +1141,14 @@ export declare interface ImageFill {
     tile?: TileInfo;
     /** `a:blip > a:alphaModFix@amt` as a fraction (0.0–1.0). Absent = opaque. */
     alpha?: number;
+    /**
+     * ECMA-376 §20.1.8.23 `<a:duotone>` recolour, resolved to its two endpoint
+     * colours (through the slide theme). Absent ⇒ no duotone. When present the
+     * renderer maps the blip's luminance ramp between the two colours (core
+     * `applyDuotone`) — the same recolour a `<p:pic>` duotone applies, wired onto
+     * the picture-FILL path (§20.1.8.14) by issue #889.
+     */
+    duotone?: Duotone;
 }
 
 declare interface LegendManualLayout {
@@ -1540,6 +1586,14 @@ export declare interface Paragraph extends Paragraph_2 {
      * emits an effective boolean.
      */
     eaLnBrk: boolean;
+    /**
+     * `<a:pPr defTabSz>` (ECMA-376 §21.1.2.2.7) — the default tab-stop interval in
+     * EMU. When a `\t` has no reachable explicit `a:tabLst` stop, it advances to
+     * the next multiple of this grid (issue #1006). Absent ⇒ the renderer uses the
+     * PowerPoint universal default of 914400 EMU (1 inch). Omitted from JSON when
+     * the parser found no explicit value.
+     */
+    defTabSz?: number;
 }
 
 declare interface Paragraph_2 {
@@ -2346,6 +2400,15 @@ export declare class PptxScrollViewer implements ZoomableViewer {
      * to the target slide via {@link scrollToSlide} once the action resolves to a
      * slide index (a jump resolving to no reachable slide is a safe no-op).
      */
+    /**
+     * IX1 — the click handler passed to the text-layer overlay, or `undefined` when
+     * `enableHyperlinks` is `false`. This is the single gate that disables hyperlink
+     * interactivity: {@link buildPptxTextLayer} renders link runs exactly like plain
+     * runs when no handler is supplied, so no hit region, cursor, tooltip, listener,
+     * or navigation is wired (a custom `onHyperlinkClick` is suppressed too). When
+     * enabled, the returned handler dispatches through {@link _onHyperlinkClick}.
+     */
+    private _hyperlinkHandler;
     private _onHyperlinkClick;
     /** Populate an internal {@link HyperlinkTarget}'s `slideIndex` from its `ref`
      *  via the engine's stamped part names. Relative `hlinkshowjump` verbs are
@@ -2512,6 +2575,13 @@ export declare interface PptxScrollViewerOptions extends Omit<RenderSlideOptions
      * instead and takes NO default action.
      */
     onHyperlinkClick?: (target: HyperlinkTarget) => void;
+    /** IX1 — master switch for hyperlink interactivity. Default `true`. When
+     *  `false`, the hyperlink machinery is not wired at all: the overlay's link
+     *  spans are non-interactive, so there is no pointer cursor, no title tooltip,
+     *  no default navigation (external new-tab / internal slide jump), and
+     *  `onHyperlinkClick` is never called. Links still render exactly as authored
+     *  but are inert, like plain text. */
+    enableHyperlinks?: boolean;
 }
 
 /** Information about a rendered text segment for building a transparent selection overlay. */
@@ -2751,6 +2821,15 @@ export declare class PptxViewer implements ZoomableViewer {
     /** Rebuild the highlight overlay for the current slide from cached runs. */
     private _redrawHighlights;
     private _buildTextLayer;
+    /**
+     * IX1 — the click handler passed to the text-layer overlay, or `undefined` when
+     * `enableHyperlinks` is `false`. This is the single gate that disables hyperlink
+     * interactivity: {@link buildPptxTextLayer} renders link runs exactly like plain
+     * runs when no handler is supplied, so no hit region, cursor, tooltip, listener,
+     * or navigation is wired (a custom `onHyperlinkClick` is suppressed too). When
+     * enabled, the returned handler dispatches through {@link _onHyperlinkClick}.
+     */
+    private _hyperlinkHandler;
     /**
      * IX1/IX-nav hyperlink click dispatch. An internal target is first *enriched*
      * with its resolved 0-based `slideIndex` (via
@@ -2847,6 +2926,14 @@ export declare interface PptxViewerOptions extends RenderOptions, LoadOptions {
      * viewer calls this instead and takes NO default action.
      */
     onHyperlinkClick?: (target: HyperlinkTarget) => void;
+    /** IX1 — master switch for hyperlink interactivity. Default `true`. When
+     *  `false`, the hyperlink machinery is not wired at all: the overlay's link
+     *  spans are non-interactive, so there is no pointer cursor, no title tooltip,
+     *  no default navigation (external new-tab / internal slide jump), and
+     *  `onHyperlinkClick` is never called. Links still render exactly as authored
+     *  (theme `hlink` colour + underline are painted on the canvas) but are inert,
+     *  like plain text. */
+    enableHyperlinks?: boolean;
 }
 
 export declare interface Presentation {
@@ -3105,6 +3192,14 @@ export declare interface ShapeElement {
     /** `<a:sp3d>` 3D shape properties (ECMA-376 §20.1.5.12). Parsed but not
      *  rendered in Phase A. */
     sp3d?: Sp3d;
+    /** `<p:nvSpPr><p:cNvPr @id>` — DrawingML cNvPr id. Present for file-authored
+     *  shapes (the attribute is schema-required); absent on parser-synthesized
+     *  shapes such as the SmartArt data-model fallback. */
+    id?: string;
+    /** `<p:nvSpPr><p:cNvPr @name>` — author-visible shape name (e.g. "Title 1").
+     *  The SmartArt data-model fallback synthesizes `name: "SmartArt"` with no
+     *  {@link ShapeElement.id} (see smartart-fallback-contrast.ts). */
+    name?: string;
     /** Shape-level hyperlink target resolved from `<p:cNvPr><a:hlinkClick @r:id>`
      *  via slide _rels (ECMA-376 §21.1.2.3.5). For an external link this is the
      *  URL; for an internal slide jump it is the resolved internal part name.
@@ -3281,7 +3376,10 @@ export declare interface TableRow {
 }
 
 export declare interface TabStop {
-    /** Position in EMU from the left edge of the text area (after lIns) */
+    /** Position in EMU from the LEADING text-inset edge of the text area —
+     *  logical, not physical (ECMA-376 §21.1.2.1): the left edge (after lIns)
+     *  in an LTR paragraph, the right edge (before rIns) in an RTL
+     *  (`<a:pPr rtl="1">`) paragraph. */
     pos: number;
     /** Alignment: "l" | "r" | "ctr" | "dec" */
     algn: string;

package/dist/types/xlsx.d.ts

@@ -400,6 +400,14 @@ export declare interface ChartModel {
     title: string | null;
     categories: string[];
     series: ChartSeries[];
+    /**
+     * §21.2.2.227 `<c:varyColors val="1"/>` on a SINGLE-series bar/column chart:
+     * color each data point (bar) from the theme/palette sequence and list one
+     * legend entry per point, matching Office. Set by the shared parser ONLY for
+     * that non-pie, single-series case (pie/doughnut already vary by point via
+     * `chartType` + `dataPointColors`); absent/false otherwise.
+     */
+    varyColors?: boolean | null;
     /** Show data labels on bars / points / slices. */
     showDataLabels: boolean;
     /** Explicit Y-axis minimum (OOXML `<c:valAx><c:min>`). */
@@ -2829,7 +2837,13 @@ export declare class XlsxViewer implements ZoomableViewer {
      *  match the renderer's `hyperlinkMap` exactly (`${hl.row}:${hl.col}`). */
     private buildHyperlinkMap;
     /** IX1 — the hyperlink at a cell, or null. `getCellAt` returns 1-based
-     *  {row,col}, matching the parser/renderer keying. */
+     *  {row,col}, matching the parser/renderer keying.
+     *
+     *  Returns null unconditionally when `enableHyperlinks` is `false`: this is the
+     *  single gate that disables hyperlink interactivity. Both consumers — the
+     *  pointermove pointer-cursor affordance and the click dispatch
+     *  ({@link dispatchHyperlink}) — funnel through this hit-test, so a null result
+     *  means no cursor change, no default navigation, and no `onHyperlinkClick`. */
     private hyperlinkAtCell;
     /**
      * IX1 — dispatch a click on a hyperlinked cell. Builds a
@@ -3016,6 +3030,13 @@ export declare interface XlsxViewerOptions extends LoadOptions_2 {
      * default handler's job, so a blocked scheme still reaches a custom callback).
      */
     onHyperlinkClick?: (target: HyperlinkTarget) => void;
+    /** IX1 — master switch for hyperlink interactivity. Default `true`. When
+     *  `false`, the cell hit-test reports no hyperlink under any cell, so hyperlink
+     *  interactivity is disabled entirely: no pointer cursor over a link, no default
+     *  navigation (external new-tab / internal sheet jump), and `onHyperlinkClick`
+     *  is never called. Hyperlinked cells still render exactly as authored but are
+     *  inert. */
+    enableHyperlinks?: boolean;
     /**
      * Color of the cell-selection highlight. A single CSS color drives both the
      * selection rectangle's border (drawn in this color) and its fill (the same
@@ -3161,6 +3182,14 @@ export declare class XlsxWorkbook {
      * validation-list expansion use). Returns `''` before the workbook is loaded.
      */
     cellText(ws: Worksheet, cell: Cell): string;
+    /**
+     * Render a sheet viewport into `target`. Note: `opts.fetchImage` is ignored
+     * here — image bytes always come from this workbook's own archive through its
+     * stable per-instance loader, whose closure identity keys the shared decoded
+     * caches, the render-pass lease, and {@link destroy}'s cache drops. Callers
+     * needing a custom byte source should use the standalone
+     * `renderWorksheetViewport` orchestrator directly.
+     */
     renderViewport(target: HTMLCanvasElement | OffscreenCanvas, sheetIndex: number, viewport: ViewportRange, opts?: RenderViewportOptions): Promise<void>;
     /**
      * Render a sheet viewport and return it as an ImageBitmap (both modes; in

package/dist/visible-index-5hdq_oAL.js

@@ -0,0 +1,50 @@
+import { Y as e, at as t, et as n, rt as r } from "./find-cursor-DTrEBxjE.js";
+//#region packages/core/src/image/duotone-bitmap-by-path.ts
+function i(e, t) {
+	return t ? `${e}|duo:${t.clr1}:${t.clr2}` : e;
+}
+var a = /* @__PURE__ */ new WeakMap();
+function o(e) {
+	let t = a.get(e);
+	return t || (t = /* @__PURE__ */ new Map(), a.set(e, t)), t;
+}
+async function s(r, a, s, c, l = {}) {
+	let { offscreenFactory: u, ...d } = l, f = await t(r, a, c, d);
+	if (!s || !f) return f;
+	let p = o(c), m = i(r, s), h = p.get(m);
+	return h || (h = (async () => {
+		let { w: t, h: r } = n(f);
+		return t <= 0 || r <= 0 ? f : await e(f, s, {
+			width: t,
+			height: r,
+			offscreenFactory: u
+		});
+	})(), h.catch(() => p.delete(m)), h.then((e) => {
+		e === f && p.delete(m);
+	}).catch(() => {}), p.set(m, h)), h;
+}
+function c(e) {
+	let t = a.get(e);
+	if (t) {
+		for (let n of t.values()) r(e, n);
+		t.clear(), a.delete(e);
+	}
+}
+//#endregion
+//#region packages/core/src/nav/visible-index.ts
+function l(e, t, n, r) {
+	for (let i = e + t; i >= 0 && i < r; i += t) if (!n(i)) return i;
+	return e;
+}
+function u(e, t, n) {
+	if (n === 0 || !t(e)) return e;
+	let r = l(e, 1, t, n);
+	return r === e ? l(e, -1, t, n) : r;
+}
+function d(e, t) {
+	let n = 0;
+	for (let r = 0; r < t; r++) e(r) || n++;
+	return n;
+}
+//#endregion
+export { s as a, c as i, l as n, u as r, d as t };