@silurus/ooxml 0.63.0 → 0.64.1

package/dist/types/docx.d.ts

@@ -238,10 +238,25 @@ export declare class DocxDocument {
     private _mode;
     private _worker;
     private _bridge;
+    private _imageCache;
+    /** One stable closure per instance: core's path-keyed SVG cache namespaces on
+     *  this identity, so two open documents never swap a shared zip path (e.g.
+     *  word/media/image1.svg). Reusing one reference also lets the SVG cache hit
+     *  across page renders. */
+    private readonly _fetchImage;
     private constructor();
     static load(source: string | ArrayBuffer, opts?: LoadOptions): Promise<DocxDocument>;
     private _parse;
     destroy(): void;
+    /**
+     * Extract raw bytes for an embedded image by zip path (e.g.
+     * `word/media/image1.png`), wrapped in a Blob of the given MIME type. Routes
+     * through the persistent worker via the `extractImage` message (twin of
+     * pptx's `getImage`/`getMedia`); results are cached by path for the lifetime
+     * of this instance. The renderer's `fetchImage` option points here so images
+     * are decoded lazily rather than inlined as base64 at parse time.
+     */
+    getImage(imagePath: string, mimeType: string): Promise<Blob>;
     get pageCount(): number;
     /**
      * The raw parsed document model. Available only in `mode: 'main'`; in
@@ -484,7 +499,23 @@ export declare interface HeadersFooters {
 }
 
 export declare interface ImageRun {
-    dataUrl: string;
+    /**
+     * Embedded zip path of the raster blip (e.g. `word/media/image1.png`) — the
+     * raster fallback (PNG/JPEG), or the SVG part itself when no raster blip is
+     * embedded. The renderer fetches the bytes lazily by path (see {@link
+     * DocxDocument.getImage}) instead of inlining base64.
+     */
+    imagePath: string;
+    /** MIME type of the blip at {@link ImageRun.imagePath} (e.g. `image/png`, or
+     *  `image/svg+xml` for an svg-only picture). */
+    mimeType: string;
+    /**
+     * Vector original from the Microsoft `asvg:svgBlip` extension (MS-ODRAWXML) —
+     * the zip path of the `.svg` part. When present the renderer prefers it over
+     * {@link ImageRun.imagePath} (the raster fallback). Absent for a plain raster
+     * image. Its MIME is always `image/svg+xml` and is owned by the SVG decoder.
+     */
+    svgImagePath?: string;
     widthPt: number;
     heightPt: number;
     /** true = wp:anchor (absolute positioned), false/undefined = wp:inline (flows with text) */

package/dist/types/index.d.ts

@@ -1184,10 +1184,25 @@ declare class DocxDocument {
     private _mode;
     private _worker;
     private _bridge;
+    private _imageCache;
+    /** One stable closure per instance: core's path-keyed SVG cache namespaces on
+     *  this identity, so two open documents never swap a shared zip path (e.g.
+     *  word/media/image1.svg). Reusing one reference also lets the SVG cache hit
+     *  across page renders. */
+    private readonly _fetchImage;
     private constructor();
     static load(source: string | ArrayBuffer, opts?: LoadOptions_4): Promise<DocxDocument>;
     private _parse;
     destroy(): void;
+    /**
+     * Extract raw bytes for an embedded image by zip path (e.g.
+     * `word/media/image1.png`), wrapped in a Blob of the given MIME type. Routes
+     * through the persistent worker via the `extractImage` message (twin of
+     * pptx's `getImage`/`getMedia`); results are cached by path for the lifetime
+     * of this instance. The renderer's `fetchImage` option points here so images
+     * are decoded lazily rather than inlined as base64 at parse time.
+     */
+    getImage(imagePath: string, mimeType: string): Promise<Blob>;
     get pageCount(): number;
     /**
      * The raw parsed document model. Available only in `mode: 'main'`; in
@@ -1552,20 +1567,39 @@ declare interface ImageAnchor {
      *  size. Authoritative when `editAs === "oneCell"`. 0 = unavailable. */
     nativeExtCx: number;
     nativeExtCy: number;
-    /** Data URL (data:image/png;base64,...) */
-    dataUrl: string;
+    /** Zip path of the blip inside the package (e.g. `xl/media/image1.png`). The
+     *  blip's own `r:embed` raster fallback when an svgBlip extension is present;
+     *  otherwise the only source. Falls back to the SVG part itself when the
+     *  picture has no raster `r:embed`. Bytes are fetched lazily by path. */
+    imagePath: string;
+    /** MIME type of the blip at {@link ImageAnchor.imagePath} (e.g. `image/png`,
+     *  or `image/svg+xml` for the SVG-only fallback). */
+    mimeType: string;
+    /** Vector original from the Microsoft `asvg:svgBlip` extension (MS-ODRAWXML),
+     *  as a zip path. Preferred over `imagePath` (the raster fallback, or the SVG
+     *  itself when no raster blip is embedded). Absent when the picture carries no
+     *  svgBlip extension. Its MIME is always `image/svg+xml` and is owned by the
+     *  SVG decoder. */
+    svgImagePath?: string;
 }
 
 /**
  * Image fill — ECMA-376 §20.1.8.14 (CT_BlipFillProperties). The embedded blip
- * is resolved to a base64 data URL at parse time. Both fill-modes are modelled
- * and mutually exclusive: `stretch` (§20.1.8.56) carries {@link ImageFill.fillRect};
- * `tile` (§20.1.8.58) carries {@link ImageFill.tile}.
+ * is carried as a zip path + MIME; the renderer fetches the bytes on demand via
+ * {@link RenderOptions.fetchImage} (no base64 inlined at parse time). Both
+ * fill-modes are modelled and mutually exclusive: `stretch` (§20.1.8.56) carries
+ * {@link ImageFill.fillRect}; `tile` (§20.1.8.58) carries {@link ImageFill.tile}.
  */
 declare interface ImageFill {
     fillType: 'image';
-    /** `data:<mime>;base64,…` of the embedded blip. */
-    dataUrl: string;
+    /**
+     * Embedded zip path of the blip (e.g. "word/media/image1.png"), for the lazy
+     * byte-on-demand pipeline. The renderer fetches the bytes via a path-keyed
+     * loader ({@link RenderOptions.fetchImage}) instead of inlining base64.
+     */
+    imagePath: string;
+    /** MIME type of the blip at {@link ImageFill.imagePath} (e.g. `image/png`). */
+    mimeType: string;
     /**
      * `<a:stretch><a:fillRect>` insets. Absent → fills the whole box (or the
      * fill is tiled — see {@link ImageFill.tile}).
@@ -1581,7 +1615,23 @@ declare interface ImageFill {
 }
 
 declare interface ImageRun {
-    dataUrl: string;
+    /**
+     * Embedded zip path of the raster blip (e.g. `word/media/image1.png`) — the
+     * raster fallback (PNG/JPEG), or the SVG part itself when no raster blip is
+     * embedded. The renderer fetches the bytes lazily by path (see {@link
+     * DocxDocument.getImage}) instead of inlining base64.
+     */
+    imagePath: string;
+    /** MIME type of the blip at {@link ImageRun.imagePath} (e.g. `image/png`, or
+     *  `image/svg+xml` for an svg-only picture). */
+    mimeType: string;
+    /**
+     * Vector original from the Microsoft `asvg:svgBlip` extension (MS-ODRAWXML) —
+     * the zip path of the `.svg` part. When present the renderer prefers it over
+     * {@link ImageRun.imagePath} (the raster fallback). Absent for a plain raster
+     * image. Its MIME is always `image/svg+xml` and is owned by the SVG decoder.
+     */
+    svgImagePath?: string;
     widthPt: number;
     heightPt: number;
     /** true = wp:anchor (absolute positioned), false/undefined = wp:inline (flows with text) */
@@ -2165,18 +2215,35 @@ declare interface PictureElement {
     rotation: number;
     flipH: boolean;
     flipV: boolean;
-    /** Data URL, e.g. "data:image/png;base64,..." */
-    dataUrl: string;
+    /**
+     * Embedded zip path of the raster blip (e.g. "ppt/media/image1.png"). The
+     * renderer fetches the bytes lazily by path (see {@link
+     * PptxPresentation.getImage}) instead of inlining base64. When the picture is
+     * a pure SVG with no raster blip this falls back to the SVG part's path and
+     * {@link PictureElement.mimeType} is `image/svg+xml`.
+     */
+    imagePath: string;
+    /** MIME type of the blip at {@link PictureElement.imagePath} (e.g. `image/png`). */
+    mimeType: string;
     /**
      * Microsoft 2016 SVG extension (`<a:blip><a:extLst><a:ext
      * uri="{96DAC541-7B7A-43D3-8B79-37D633B846F1}"><asvg:svgBlip r:embed>`). When
-     * PowerPoint embeds an SVG image, `dataUrl` above is only the PNG fallback it
-     * rasterizes for compatibility; this is the original vector image as a
-     * `data:image/svg+xml;base64,…` URL. The renderer prefers this and falls back
-     * to `dataUrl` if the SVG fails to decode. Omitted when the picture has no
-     * svgBlip extension (the common case).
+     * PowerPoint embeds an SVG image, `imagePath` above is only the PNG fallback
+     * it rasterizes for compatibility; this is the zip path of the original
+     * vector `.svg` part. The renderer prefers this and falls back to the raster
+     * if the SVG fails to decode. Omitted when the picture has no svgBlip
+     * extension (the common case). Its MIME is always `image/svg+xml` and is
+     * owned by the SVG decoder.
+     */
+    svgImagePath?: string;
+    /**
+     * Intrinsic pixel width of the raster blip, read from the PNG IHDR at parse
+     * time. Omitted for non-PNG payloads. Used internally for the ink-fallback
+     * (empty-stroke PNG centering).
      */
-    svgDataUrl?: string;
+    intrinsicWidthPx?: number;
+    /** Intrinsic pixel height of the raster blip (PNG IHDR). Omitted for non-PNG. */
+    intrinsicHeightPx?: number;
     /**
      * Border line from `<p:pic><p:spPr><a:ln>` (ECMA-376 §20.1.2.2.24). A
      * `p:pic`'s spPr is `CT_ShapeProperties` (§19.3.1.37), so a picture carries
@@ -2336,6 +2403,12 @@ declare class PptxPresentation {
     private _presentation;
     private _meta;
     private _mediaCache;
+    private _imageCache;
+    /** One stable closure per instance: the decoded-bitmap and SVG caches key on
+     *  this identity to scope decodes per deck (so two open decks never swap
+     *  images for a shared zip path like ppt/media/image1.png). Reusing the same
+     *  reference across every render also lets those caches hit across slides. */
+    private readonly _fetchImage;
     private _workerReady;
     private _workerReadyCallbacks;
     /** Opt-in OMML equation engine, injected once at {@link load}. Every
@@ -2391,6 +2464,14 @@ declare class PptxPresentation {
      */
     getMedia(mediaPath: string): Promise<Blob>;
     private _findMimeTypeForPath;
+    /**
+     * Extract raw bytes for an embedded image by zip path (e.g.
+     * "ppt/media/image1.png"), wrapped in a Blob of the given MIME type. Mirrors
+     * {@link getMedia}; results are cached by path for the lifetime of this
+     * instance. The renderer routes its `fetchImage` option here so images are
+     * decoded lazily rather than inlined as base64 at parse time.
+     */
+    getImage(imagePath: string, mimeType: string): Promise<Blob>;
     /**
      * Render a slide and attach canvas-native playback controls for any
      * embedded audio/video. Returns a {@link PresentationHandle} that owns the
@@ -2572,6 +2653,13 @@ declare interface RenderOptions {
      * demand, keeping the parse output free of inlined base64.
      */
     fetchMedia?: (path: string) => Promise<Blob>;
+    /**
+     * Lazily resolve an embedded image (by zip path + MIME) to a Blob. Twin of
+     * {@link RenderOptions.fetchMedia} for pictures and blip fills: the renderer
+     * fetches raster/SVG bytes on demand and decodes them (`createImageBitmap` /
+     * path-keyed `<img>`), so the parse output carries only paths, never base64.
+     */
+    fetchImage?: (path: string, mimeType: string) => Promise<Blob>;
     /**
      * When true, renderMedia draws only the poster frame — play/pause badges
      * and progress bars are left to the caller. Set by the pptx presentSlide
@@ -2645,8 +2733,15 @@ declare interface RenderViewportOptions {
     freezeCols?: number;
     /** Scale factor applied to all cell/header dimensions (default 1). */
     cellScale?: number;
-    /** Pre-decoded image sources keyed by their dataUrl (for ImageAnchor rendering). */
+    /** Pre-decoded image sources keyed by their zip `imagePath` (for ImageAnchor
+     *  and group-leaf image rendering). */
     loadedImages?: Map<string, CanvasImageSource>;
+    /** Fetch an embedded image's bytes by zip path, wrapped in a Blob of the given
+     *  MIME (twin of pptx/docx `fetchImage`). The orchestrator decodes these into
+     *  {@link loadedImages} before the synchronous draw. Supplied by
+     *  {@link XlsxWorkbook} (routing through the worker) or the render worker
+     *  (reading its retained buffer). Absent ⇒ no images are decoded. */
+    fetchImage?: (path: string, mimeType: string) => Promise<Blob>;
     /** Called once per cell that contains text, with canvas-pixel position and cell address. */
     onTextRun?: (info: XlsxTextRunInfo) => void;
     /** Highlighted row range for selected row headers (1-indexed inclusive).
@@ -2893,12 +2988,22 @@ declare type ShapeGeom = {
     type: 'custom';
     paths: PathInfo[];
 }
-/** Bitmap picture leaf inside a `<xdr:grpSp>`. `dataUrl` is a pre-encoded
-*  `data:<mime>;base64,…` produced by the Rust parser from the drawing's
-*  relationship target. */
+/** Bitmap (or vector) picture leaf inside a `<xdr:grpSp>`. `imagePath` is the
+*  zip path of the drawing's relationship target — the blip's raster `r:embed`
+*  fallback, or the SVG itself when no raster is embedded — and `mimeType` its
+*  MIME. Bytes are fetched lazily by path; nothing is inlined as base64. */
 | {
     type: 'image';
-    dataUrl: string;
+    imagePath: string;
+    /** MIME type of the blip at {@link imagePath} (e.g. `image/png`, or
+     *  `image/svg+xml` for the SVG-only fallback). */
+    mimeType: string;
+    /** Vector original from the Microsoft `asvg:svgBlip` extension
+     *  (MS-ODRAWXML), as a zip path. Prefer this over `imagePath` (the raster
+     *  fallback, or the SVG itself when no raster blip is embedded). Absent
+     *  when the picture carries no svgBlip extension. Its MIME is always
+     *  `image/svg+xml` and is owned by the SVG decoder. */
+    svgImagePath?: string;
 };
 
 declare interface ShapeInfo {
@@ -3510,6 +3615,17 @@ declare interface TextRunData {
      * fill-only.
      */
     outline?: TextOutline;
+    /**
+     * Run-level text highlight / marker colour (`<a:rPr><a:highlight>`),
+     * ECMA-376 §21.1.2.3.4. In DrawingML this is a full CT_Color (any
+     * srgbClr / schemeClr / sysClr / prstClr + transforms), unlike
+     * WordprocessingML's fixed 16-name highlight enum — so the parser already
+     * resolves it through the theme/clrMap. The value is a hex string without
+     * `#` (6-char opaque, or 8-char RRGGBBAA when an alpha transform applies);
+     * the renderer paints a background rectangle behind the run's glyphs.
+     * Absent means no highlight.
+     */
+    highlight?: string;
 }
 
 /**
@@ -3545,9 +3661,10 @@ declare interface ViewportRange {
 /** Serializable subset of RenderPageOptions (callbacks cannot cross the wire). */
 declare type WireRenderPageOptions = Omit<RenderPageOptions, 'onTextRun'>;
 
-/** Serializable subset of RenderViewportOptions: drop the callback and the
- *  image cache (the worker owns its own). */
-declare type WireRenderViewportOptions = Omit<RenderViewportOptions, 'onTextRun' | 'loadedImages'>;
+/** Serializable subset of RenderViewportOptions: drop the callback, the image
+ *  cache, and the `fetchImage` loader (all non-cloneable; the worker owns its
+ *  own cache and supplies its own in-worker fetchImage). */
+declare type WireRenderViewportOptions = Omit<RenderViewportOptions, 'onTextRun' | 'loadedImages' | 'fetchImage'>;
 
 declare interface Workbook {
     sheets: SheetMeta[];
@@ -4072,8 +4189,19 @@ declare class XlsxWorkbook {
     private bridge;
     private parsedWorkbook;
     private sheetCache;
-    /** Cache of decoded image bitmaps keyed by their data URL. Shared across sheets. */
+    /** Cache of decoded image sources keyed by their zip `imagePath`. Shared
+     *  across sheets. */
     private imageCache;
+    /** Cache of fetched image *bytes* (as Blobs) keyed by zip path, populated by
+     *  {@link XlsxWorkbook.getImage}. Twin of pptx/docx's per-instance
+     *  `_imageCache`; kept separate from {@link XlsxWorkbook.imageCache} (decoded
+     *  sources) so each layer dedupes independently. */
+    private imageBlobCache;
+    /** One stable closure per instance: core's path-keyed SVG cache namespaces on
+     *  this identity, so two open workbooks never swap a shared zip path (e.g.
+     *  xl/media/image1.svg). Reusing one reference also lets the SVG cache hit
+     *  across viewport renders. */
+    private readonly _fetchImage;
     private rawData;
     private maxZipEntryBytes;
     /** Opt-in OMML equation engine, injected once at {@link load}. Every
@@ -4091,6 +4219,19 @@ declare class XlsxWorkbook {
      *  `null` for sheets that declare no tab color. */
     get tabColors(): (string | null)[];
     getWorksheet(sheetIndex: number): Promise<Worksheet>;
+    /**
+     * Fetch an embedded image's bytes by zip path (e.g. `xl/media/image1.png`),
+     * wrapped in a Blob of the given MIME. The bytes are pulled through the
+     * persistent worker via the `extractImage` message (twin of pptx/docx's
+     * `getImage`/`getMedia`); results are cached by path for the lifetime of this
+     * instance. The renderer's `fetchImage` option points here so image bytes are
+     * extracted lazily rather than inlined as base64 at parse time.
+     *
+     * Routed through the worker even though the main thread also retains
+     * `rawData`, to keep all WASM `extract_image` decoding on the worker (the
+     * route-through-worker decision).
+     */
+    getImage(imagePath: string, mimeType: string): Promise<Blob>;
     /**
      * Resolve a `list`-type data-validation `formula1` (ECMA-376 §18.3.1.32) into
      * the set of allowed values to display, evaluated relative to `sheetIndex`

package/dist/types/pptx.d.ts

@@ -606,14 +606,21 @@ export declare interface GradientStop {
 
 /**
  * Image fill — ECMA-376 §20.1.8.14 (CT_BlipFillProperties). The embedded blip
- * is resolved to a base64 data URL at parse time. Both fill-modes are modelled
- * and mutually exclusive: `stretch` (§20.1.8.56) carries {@link ImageFill.fillRect};
- * `tile` (§20.1.8.58) carries {@link ImageFill.tile}.
+ * is carried as a zip path + MIME; the renderer fetches the bytes on demand via
+ * {@link RenderOptions.fetchImage} (no base64 inlined at parse time). Both
+ * fill-modes are modelled and mutually exclusive: `stretch` (§20.1.8.56) carries
+ * {@link ImageFill.fillRect}; `tile` (§20.1.8.58) carries {@link ImageFill.tile}.
  */
 export declare interface ImageFill {
     fillType: 'image';
-    /** `data:<mime>;base64,…` of the embedded blip. */
-    dataUrl: string;
+    /**
+     * Embedded zip path of the blip (e.g. "word/media/image1.png"), for the lazy
+     * byte-on-demand pipeline. The renderer fetches the bytes via a path-keyed
+     * loader ({@link RenderOptions.fetchImage}) instead of inlining base64.
+     */
+    imagePath: string;
+    /** MIME type of the blip at {@link ImageFill.imagePath} (e.g. `image/png`). */
+    mimeType: string;
     /**
      * `<a:stretch><a:fillRect>` insets. Absent → fills the whole box (or the
      * fill is tiled — see {@link ImageFill.tile}).
@@ -960,18 +967,35 @@ export declare interface PictureElement {
     rotation: number;
     flipH: boolean;
     flipV: boolean;
-    /** Data URL, e.g. "data:image/png;base64,..." */
-    dataUrl: string;
+    /**
+     * Embedded zip path of the raster blip (e.g. "ppt/media/image1.png"). The
+     * renderer fetches the bytes lazily by path (see {@link
+     * PptxPresentation.getImage}) instead of inlining base64. When the picture is
+     * a pure SVG with no raster blip this falls back to the SVG part's path and
+     * {@link PictureElement.mimeType} is `image/svg+xml`.
+     */
+    imagePath: string;
+    /** MIME type of the blip at {@link PictureElement.imagePath} (e.g. `image/png`). */
+    mimeType: string;
     /**
      * Microsoft 2016 SVG extension (`<a:blip><a:extLst><a:ext
      * uri="{96DAC541-7B7A-43D3-8B79-37D633B846F1}"><asvg:svgBlip r:embed>`). When
-     * PowerPoint embeds an SVG image, `dataUrl` above is only the PNG fallback it
-     * rasterizes for compatibility; this is the original vector image as a
-     * `data:image/svg+xml;base64,…` URL. The renderer prefers this and falls back
-     * to `dataUrl` if the SVG fails to decode. Omitted when the picture has no
-     * svgBlip extension (the common case).
+     * PowerPoint embeds an SVG image, `imagePath` above is only the PNG fallback
+     * it rasterizes for compatibility; this is the zip path of the original
+     * vector `.svg` part. The renderer prefers this and falls back to the raster
+     * if the SVG fails to decode. Omitted when the picture has no svgBlip
+     * extension (the common case). Its MIME is always `image/svg+xml` and is
+     * owned by the SVG decoder.
+     */
+    svgImagePath?: string;
+    /**
+     * Intrinsic pixel width of the raster blip, read from the PNG IHDR at parse
+     * time. Omitted for non-PNG payloads. Used internally for the ink-fallback
+     * (empty-stroke PNG centering).
      */
-    svgDataUrl?: string;
+    intrinsicWidthPx?: number;
+    /** Intrinsic pixel height of the raster blip (PNG IHDR). Omitted for non-PNG. */
+    intrinsicHeightPx?: number;
     /**
      * Border line from `<p:pic><p:spPr><a:ln>` (ECMA-376 §20.1.2.2.24). A
      * `p:pic`'s spPr is `CT_ShapeProperties` (§19.3.1.37), so a picture carries
@@ -1071,6 +1095,12 @@ export declare class PptxPresentation {
     private _presentation;
     private _meta;
     private _mediaCache;
+    private _imageCache;
+    /** One stable closure per instance: the decoded-bitmap and SVG caches key on
+     *  this identity to scope decodes per deck (so two open decks never swap
+     *  images for a shared zip path like ppt/media/image1.png). Reusing the same
+     *  reference across every render also lets those caches hit across slides. */
+    private readonly _fetchImage;
     private _workerReady;
     private _workerReadyCallbacks;
     /** Opt-in OMML equation engine, injected once at {@link load}. Every
@@ -1126,6 +1156,14 @@ export declare class PptxPresentation {
      */
     getMedia(mediaPath: string): Promise<Blob>;
     private _findMimeTypeForPath;
+    /**
+     * Extract raw bytes for an embedded image by zip path (e.g.
+     * "ppt/media/image1.png"), wrapped in a Blob of the given MIME type. Mirrors
+     * {@link getMedia}; results are cached by path for the lifetime of this
+     * instance. The renderer routes its `fetchImage` option here so images are
+     * decoded lazily rather than inlined as base64 at parse time.
+     */
+    getImage(imagePath: string, mimeType: string): Promise<Blob>;
     /**
      * Render a slide and attach canvas-native playback controls for any
      * embedded audio/video. Returns a {@link PresentationHandle} that owns the
@@ -1307,6 +1345,13 @@ export declare interface RenderOptions {
      * demand, keeping the parse output free of inlined base64.
      */
     fetchMedia?: (path: string) => Promise<Blob>;
+    /**
+     * Lazily resolve an embedded image (by zip path + MIME) to a Blob. Twin of
+     * {@link RenderOptions.fetchMedia} for pictures and blip fills: the renderer
+     * fetches raster/SVG bytes on demand and decodes them (`createImageBitmap` /
+     * path-keyed `<img>`), so the parse output carries only paths, never base64.
+     */
+    fetchImage?: (path: string, mimeType: string) => Promise<Blob>;
     /**
      * When true, renderMedia draws only the poster frame — play/pause badges
      * and progress bars are left to the caller. Set by the pptx presentSlide
@@ -1743,6 +1788,17 @@ export declare interface TextRunData {
      * fill-only.
      */
     outline?: TextOutline;
+    /**
+     * Run-level text highlight / marker colour (`<a:rPr><a:highlight>`),
+     * ECMA-376 §21.1.2.3.4. In DrawingML this is a full CT_Color (any
+     * srgbClr / schemeClr / sysClr / prstClr + transforms), unlike
+     * WordprocessingML's fixed 16-name highlight enum — so the parser already
+     * resolves it through the theme/clrMap. The value is a hex string without
+     * `#` (6-char opaque, or 8-char RRGGBBAA when an alpha transform applies);
+     * the renderer paints a background rectangle behind the run's glyphs.
+     * Absent means no highlight.
+     */
+    highlight?: string;
 }
 
 /**

package/dist/types/xlsx.d.ts

@@ -462,8 +462,20 @@ export declare interface ImageAnchor {
      *  size. Authoritative when `editAs === "oneCell"`. 0 = unavailable. */
     nativeExtCx: number;
     nativeExtCy: number;
-    /** Data URL (data:image/png;base64,...) */
-    dataUrl: string;
+    /** Zip path of the blip inside the package (e.g. `xl/media/image1.png`). The
+     *  blip's own `r:embed` raster fallback when an svgBlip extension is present;
+     *  otherwise the only source. Falls back to the SVG part itself when the
+     *  picture has no raster `r:embed`. Bytes are fetched lazily by path. */
+    imagePath: string;
+    /** MIME type of the blip at {@link ImageAnchor.imagePath} (e.g. `image/png`,
+     *  or `image/svg+xml` for the SVG-only fallback). */
+    mimeType: string;
+    /** Vector original from the Microsoft `asvg:svgBlip` extension (MS-ODRAWXML),
+     *  as a zip path. Preferred over `imagePath` (the raster fallback, or the SVG
+     *  itself when no raster blip is embedded). Absent when the picture carries no
+     *  svgBlip extension. Its MIME is always `image/svg+xml` and is owned by the
+     *  SVG decoder. */
+    svgImagePath?: string;
 }
 
 export declare interface LegendManualLayout {
@@ -743,8 +755,15 @@ export declare interface RenderViewportOptions {
     freezeCols?: number;
     /** Scale factor applied to all cell/header dimensions (default 1). */
     cellScale?: number;
-    /** Pre-decoded image sources keyed by their dataUrl (for ImageAnchor rendering). */
+    /** Pre-decoded image sources keyed by their zip `imagePath` (for ImageAnchor
+     *  and group-leaf image rendering). */
     loadedImages?: Map<string, CanvasImageSource>;
+    /** Fetch an embedded image's bytes by zip path, wrapped in a Blob of the given
+     *  MIME (twin of pptx/docx `fetchImage`). The orchestrator decodes these into
+     *  {@link loadedImages} before the synchronous draw. Supplied by
+     *  {@link XlsxWorkbook} (routing through the worker) or the render worker
+     *  (reading its retained buffer). Absent ⇒ no images are decoded. */
+    fetchImage?: (path: string, mimeType: string) => Promise<Blob>;
     /** Called once per cell that contains text, with canvas-pixel position and cell address. */
     onTextRun?: (info: XlsxTextRunInfo) => void;
     /** Highlighted row range for selected row headers (1-indexed inclusive).
@@ -857,12 +876,22 @@ export declare type ShapeGeom = {
     type: 'custom';
     paths: PathInfo[];
 }
-/** Bitmap picture leaf inside a `<xdr:grpSp>`. `dataUrl` is a pre-encoded
-*  `data:<mime>;base64,…` produced by the Rust parser from the drawing's
-*  relationship target. */
+/** Bitmap (or vector) picture leaf inside a `<xdr:grpSp>`. `imagePath` is the
+*  zip path of the drawing's relationship target — the blip's raster `r:embed`
+*  fallback, or the SVG itself when no raster is embedded — and `mimeType` its
+*  MIME. Bytes are fetched lazily by path; nothing is inlined as base64. */
 | {
     type: 'image';
-    dataUrl: string;
+    imagePath: string;
+    /** MIME type of the blip at {@link imagePath} (e.g. `image/png`, or
+     *  `image/svg+xml` for the SVG-only fallback). */
+    mimeType: string;
+    /** Vector original from the Microsoft `asvg:svgBlip` extension
+     *  (MS-ODRAWXML), as a zip path. Prefer this over `imagePath` (the raster
+     *  fallback, or the SVG itself when no raster blip is embedded). Absent
+     *  when the picture carries no svgBlip extension. Its MIME is always
+     *  `image/svg+xml` and is owned by the SVG decoder. */
+    svgImagePath?: string;
 };
 
 export declare interface ShapeInfo {
@@ -1073,9 +1102,10 @@ export declare interface ViewportRange {
     cols: number;
 }
 
-/** Serializable subset of RenderViewportOptions: drop the callback and the
- *  image cache (the worker owns its own). */
-export declare type WireRenderViewportOptions = Omit<RenderViewportOptions, 'onTextRun' | 'loadedImages'>;
+/** Serializable subset of RenderViewportOptions: drop the callback, the image
+ *  cache, and the `fetchImage` loader (all non-cloneable; the worker owns its
+ *  own cache and supplies its own in-worker fetchImage). */
+export declare type WireRenderViewportOptions = Omit<RenderViewportOptions, 'onTextRun' | 'loadedImages' | 'fetchImage'>;
 
 export declare interface Workbook {
     sheets: SheetMeta[];
@@ -1528,8 +1558,19 @@ export declare class XlsxWorkbook {
     private bridge;
     private parsedWorkbook;
     private sheetCache;
-    /** Cache of decoded image bitmaps keyed by their data URL. Shared across sheets. */
+    /** Cache of decoded image sources keyed by their zip `imagePath`. Shared
+     *  across sheets. */
     private imageCache;
+    /** Cache of fetched image *bytes* (as Blobs) keyed by zip path, populated by
+     *  {@link XlsxWorkbook.getImage}. Twin of pptx/docx's per-instance
+     *  `_imageCache`; kept separate from {@link XlsxWorkbook.imageCache} (decoded
+     *  sources) so each layer dedupes independently. */
+    private imageBlobCache;
+    /** One stable closure per instance: core's path-keyed SVG cache namespaces on
+     *  this identity, so two open workbooks never swap a shared zip path (e.g.
+     *  xl/media/image1.svg). Reusing one reference also lets the SVG cache hit
+     *  across viewport renders. */
+    private readonly _fetchImage;
     private rawData;
     private maxZipEntryBytes;
     /** Opt-in OMML equation engine, injected once at {@link load}. Every
@@ -1547,6 +1588,19 @@ export declare class XlsxWorkbook {
      *  `null` for sheets that declare no tab color. */
     get tabColors(): (string | null)[];
     getWorksheet(sheetIndex: number): Promise<Worksheet>;
+    /**
+     * Fetch an embedded image's bytes by zip path (e.g. `xl/media/image1.png`),
+     * wrapped in a Blob of the given MIME. The bytes are pulled through the
+     * persistent worker via the `extractImage` message (twin of pptx/docx's
+     * `getImage`/`getMedia`); results are cached by path for the lifetime of this
+     * instance. The renderer's `fetchImage` option points here so image bytes are
+     * extracted lazily rather than inlined as base64 at parse time.
+     *
+     * Routed through the worker even though the main thread also retains
+     * `rawData`, to keep all WASM `extract_image` decoding on the worker (the
+     * route-through-worker decision).
+     */
+    getImage(imagePath: string, mimeType: string): Promise<Blob>;
     /**
      * Resolve a `list`-type data-validation `formula1` (ECMA-376 §18.3.1.32) into
      * the set of allowed values to display, evaluated relative to `sheetIndex`