reamkit 1.26.0 → 1.28.0

package/dist/esm/pdf-reader/cie-color.d.ts

@@ -0,0 +1,33 @@
+/** §8.6.5.6/§8.6.5.7 — what a CIE-based space states about itself. */
+export interface CieSpace {
+    /** `/WhitePoint` — the colour of the illuminant, in XYZ. */
+    readonly white: readonly [number, number, number];
+    /** `/Gamma` — one per component. */
+    readonly gamma: ReadonlyArray<number>;
+    /** §8.6.5.7 `/Matrix` — components to XYZ, column-major as the PDF states it. */
+    readonly matrix?: ReadonlyArray<number>;
+}
+/**
+ * One colour in a CIE-based space, as sRGB in 0..1.
+ *
+ * @param space The space's own parameters.
+ * @param abc   Its components: one for a grey space, three for an RGB one.
+ * @returns The sRGB triple a viewer shows for it.
+ */
+export declare function cieToSrgb(space: CieSpace, abc: ReadonlyArray<number>): [number, number, number];
+/**
+ * §8.6.5.8 — one colour in a `Lab` space, as sRGB in 0..1.
+ *
+ * Lab is the one CIE space a file states in absolute terms: `L*` from 0 to 100
+ * is lightness and `a*`/`b*` are the two opponent axes, and unlike `CalRGB`
+ * (see the note above) there is no argument about the way out — every renderer
+ * takes it through XYZ against the stated white and adapts to the screen's.
+ * issue10339_reduced.pdf paints two grids of blue swatches through an `Indexed`
+ * palette whose base is one, and read as anything else the page came back
+ * blank.
+ *
+ * @param white The space's `/WhitePoint`, in XYZ.
+ * @param lab   `L*`, `a*`, `b*`.
+ * @returns The sRGB triple a viewer shows for it.
+ */
+export declare function labToSrgb(white: readonly [number, number, number], lab: readonly [number, number, number]): [number, number, number];

package/dist/esm/pdf-reader/cie-color.js

@@ -0,0 +1,112 @@
+//#region src/pdf-reader/cie-color.ts
+/**
+* One colour in a CIE-based space, as sRGB in 0..1.
+*
+* @param space The space's own parameters.
+* @param abc   Its components: one for a grey space, three for an RGB one.
+* @returns The sRGB triple a viewer shows for it.
+*/
+function cieToSrgb(space, abc) {
+	const clamp01 = (v) => Math.min(1, Math.max(0, v));
+	if (space.matrix === void 0 || abc.length < 3) {
+		const v = srgbTransfer(clamp01(abc[0] ?? 0) ** (space.gamma[0] ?? 1));
+		return [
+			v,
+			v,
+			v
+		];
+	}
+	const m = space.matrix;
+	const a = clamp01(abc[0]) ** (space.gamma[0] ?? 1);
+	const b = clamp01(abc[1]) ** (space.gamma[1] ?? 1);
+	const c = clamp01(abc[2]) ** (space.gamma[2] ?? 1);
+	const [ax, ay, az] = adaptToD65((m[0] ?? 0) * a + (m[3] ?? 0) * b + (m[6] ?? 0) * c, (m[1] ?? 0) * a + (m[4] ?? 0) * b + (m[7] ?? 0) * c, (m[2] ?? 0) * a + (m[5] ?? 0) * b + (m[8] ?? 0) * c, space.white);
+	const r = 3.2404542 * ax - 1.5371385 * ay - .4985314 * az;
+	const g = -.969266 * ax + 1.8760108 * ay + .041556 * az;
+	const bl = .0556434 * ax - .2040259 * ay + 1.0572252 * az;
+	return [
+		srgbTransfer(clamp01(r)),
+		srgbTransfer(clamp01(g)),
+		srgbTransfer(clamp01(bl))
+	];
+}
+/**
+* §8.6.5.8 — one colour in a `Lab` space, as sRGB in 0..1.
+*
+* Lab is the one CIE space a file states in absolute terms: `L*` from 0 to 100
+* is lightness and `a*`/`b*` are the two opponent axes, and unlike `CalRGB`
+* (see the note above) there is no argument about the way out — every renderer
+* takes it through XYZ against the stated white and adapts to the screen's.
+* issue10339_reduced.pdf paints two grids of blue swatches through an `Indexed`
+* palette whose base is one, and read as anything else the page came back
+* blank.
+*
+* @param white The space's `/WhitePoint`, in XYZ.
+* @param lab   `L*`, `a*`, `b*`.
+* @returns The sRGB triple a viewer shows for it.
+*/
+function labToSrgb(white, lab) {
+	const m = (Math.min(100, Math.max(0, lab[0])) + 16) / 116;
+	const l = m + lab[1] / 500;
+	const n = m - lab[2] / 200;
+	const [ax, ay, az] = adaptToD65(white[0] * inverseTransfer(l), white[1] * inverseTransfer(m), white[2] * inverseTransfer(n), white);
+	const r = 3.2404542 * ax - 1.5371385 * ay - .4985314 * az;
+	const g = -.969266 * ax + 1.8760108 * ay + .041556 * az;
+	const b = .0556434 * ax - .2040259 * ay + 1.0572252 * az;
+	const clamp01 = (v) => Math.min(1, Math.max(0, v));
+	return [
+		srgbTransfer(clamp01(r)),
+		srgbTransfer(clamp01(g)),
+		srgbTransfer(clamp01(b))
+	];
+}
+/** §8.6.5.8 — the `g` of the Lab definition, which is a cube with a linear toe. */
+function inverseTransfer(v) {
+	return v >= 6 / 29 ? v ** 3 : 108 / 841 * (v - 4 / 29);
+}
+/** The D65 white every sRGB screen is referred to. */
+var D65 = [
+	.9505,
+	1,
+	1.089
+];
+/**
+* Bradford chromatic adaptation from the space's own white to D65.
+*
+* A file may state any illuminant — calrgb.pdf states several — and a colour
+* measured against one white shown against another is the wrong colour. The
+* Bradford transform is the one every colour-managed renderer uses for this.
+*/
+function adaptToD65(x, y, z, white) {
+	const [sx, sy, sz] = coneResponse(white[0], white[1], white[2]);
+	const [dx, dy, dz] = coneResponse(D65[0], D65[1], D65[2]);
+	if (sx === 0 || sy === 0 || sz === 0) return [
+		x,
+		y,
+		z
+	];
+	const [cx, cy, cz] = coneResponse(x, y, z);
+	return fromConeResponse(cx * dx / sx, cy * dy / sy, cz * dz / sz);
+}
+/** XYZ into the Bradford cone-response space. */
+function coneResponse(x, y, z) {
+	return [
+		.8951 * x + .2664 * y - .1614 * z,
+		-.7502 * x + 1.7135 * y + .0367 * z,
+		.0389 * x - .0685 * y + 1.0296 * z
+	];
+}
+/** …and back out of it. */
+function fromConeResponse(l, m, s) {
+	return [
+		.9869929 * l - .1470543 * m + .1599627 * s,
+		.4323053 * l + .5183603 * m + .0492912 * s,
+		-.0085287 * l + .0400428 * m + .9684867 * s
+	];
+}
+/** IEC 61966-2-1 — linear light to the sRGB signal a screen takes. */
+function srgbTransfer(v) {
+	return v <= .0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - .055;
+}
+//#endregion
+export { cieToSrgb, labToSrgb };

package/dist/esm/pdf-reader/cmap.js

@@ -74,8 +74,11 @@ function utf16be(bytes) {
 }
 function incString(base, i) {
 	if (i === 0) return base;
-	if (base.length === 1) return String.fromCharCode(base.charCodeAt(0) + i);
-	return base;
+	const chars = [...base];
+	if (chars.length === 0) return base;
+	const last = chars[chars.length - 1].codePointAt(0) + i;
+	if (last > 1114111 || last >= 55296 && last <= 57343) return base;
+	return chars.slice(0, -1).join("") + String.fromCodePoint(last);
 }
 //#endregion
 export { parseToUnicodeCMap };

package/dist/esm/pdf-reader/content.d.ts

@@ -1,4 +1,5 @@
-import { ColorSpaceInfo } from './shading.js';
+import { ColorSpaceInfo, GsPaint } from './shading.js';
+import { TextMarkup } from './annot-draw.js';
 import { ShapeGradient } from '../core/vector.js';
 import { PdfDict, PdfStream } from '../pdf/objects.js';
 /**
@@ -10,10 +11,25 @@ import { PdfDict, PdfStream } from '../pdf/objects.js';
 export interface ContentFont {
     /** Bytes per character code: simple fonts read 1 byte/code, Type0 reads 2. */
     readonly bytesPerCode: 1 | 2;
+    /**
+     * §9.7.6.2 — how a shown string breaks into codes, where the CMap is not
+     * fixed-width. A named CMap like `90ms-RKSJ-H` mixes one-byte and two-byte
+     * codes, and split down the middle a Japanese line came apart into nonsense.
+     * Absent means the fixed width above.
+     */
+    readonly splitCodes?: (bytes: Uint8Array) => Array<number>;
     /** Decode a sequence of character codes to a Unicode string. */
     decode: (codes: ReadonlyArray<number>) => string;
     /** Glyph advance for one code, in 1000-unit text space. */
     width: (code: number) => number;
+    /**
+     * §9.4.4 / §9.7.4.3 — the face sets its text DOWN the page, not across, and
+     * the pen advances by the vertical displacement `w1` rather than by `w0`.
+     * A `…-V` CMap asks for this; `/DW2`'s default `[880 -1000]` is one em down.
+     * The number here is that displacement in 1000-unit text space, and it is
+     * negative because the page's y runs up.
+     */
+    readonly verticalAdvance?: (code: number) => number;
     /** §9.6.2 — the face's own `/BaseFont` name, for a document that embeds it. */
     readonly name?: string;
     /** §9.8.1 — the face is a bold one (weight, the ForceBold flag, or its name). */
@@ -26,6 +42,19 @@ export interface ContentFont {
      * procedure paints, in the resources the font states.
      */
     readonly type3?: Type3Face;
+    /**
+     * §9.6.6 — the OUTLINE a code draws, for a code that stands for no
+     * character. A face that can say what its characters are never has one:
+     * this is the last resort before a blank page.
+     */
+    readonly outline?: GlyphOutline;
+}
+/** §9.6.6 — the outlines of a face read by glyph index, and their glyph space. */
+export interface GlyphOutline {
+    /** Glyph space to text space, as a Type 3 font's `/FontMatrix` is. */
+    readonly matrix: Matrix;
+    /** The contours one code draws, or `undefined` where it draws none. */
+    readonly path: (code: number) => Array<PathSeg> | undefined;
 }
 /** §9.6.5 — the parts of a Type 3 font a caller needs to run its glyphs. */
 export interface Type3Face {
@@ -72,14 +101,33 @@ export interface TextRun {
      * than in a substitute (see `./embedded-fonts`).
      */
     readonly fontName?: string;
+    /**
+     * §9.4.4 — the advance of this face's SPACE at the size the run was shown
+     * at, which is what says whether a gap between two runs was a word space.
+     * Absent where the face states no width for it.
+     */
+    readonly spaceWidthPt?: number;
     /** §9.8.1 — the face the glyphs were shown in is a bold one. */
     readonly bold?: boolean;
+    /**
+     * §12.5.6.10 — a text-markup annotation marks these glyphs: highlighted,
+     * underlined, struck through. Applied after extraction, from the page's
+     * `/Annots` (see `./text`), because it is stated about the words rather than
+     * painted among them.
+     */
+    readonly markup?: TextMarkup;
     /**
      * §8.6.6.2 — the glyphs are filled with a tiling PATTERN, named here for the
      * caller to resolve: a pattern is a content stream, not a colour, and the
      * fill colour still standing from before is not what the page shows.
      */
     readonly fillPatternName?: string;
+    /**
+     * §8.7.4.5 — the glyphs are filled with a SHADING pattern: a sweep from one
+     * colour to another, of which the run carries the middle. The colour is not
+     * lost, the shape of it is.
+     */
+    readonly gradientFill?: boolean;
     /**
      * §9.3.6 — the page painted these glyphs NOWHERE: mode 3 shows nothing and
      * mode 7 only adds to the clip. A scanned page carries its recognised words
@@ -120,13 +168,35 @@ export interface TextRun {
  * square to page space, so it carries both the placement and the size; the
  * `mcid` links the paint to its structure element (a `/Figure`, E-PDF EP6).
  */
+/** §8.9.7 — an image written into the content stream rather than named. */
+export interface InlineImage {
+    /** Its dictionary, keys as written — the abbreviated ones (`/W`, `/CS`, `/F`). */
+    readonly dict: PdfDict;
+    /** Its bytes, still filtered as the dictionary says. */
+    readonly data: Uint8Array;
+}
 export interface ImagePlacement {
     /** Where the `Do` fell in the stream's painting order — see {@link VectorPlacement.order}. */
     readonly order: number;
-    /** XObject resource name (no leading slash). */
+    /** XObject resource name (no leading slash), empty for an inline image. */
     readonly name: string;
+    /** §8.9.7 — the image itself, where it was written into the stream. */
+    readonly inline?: InlineImage;
     readonly ctm: Matrix;
+    /** §8.5.4 — the clip in force when it was painted, when there was one. */
+    readonly clip?: ClipRegion;
+    /**
+     * §8.9.6.2 — the non-stroking colour in force. A stencil `/ImageMask` carries
+     * no colour of its own: it says only WHERE to paint, and this is what.
+     */
+    readonly fillHex: string;
     readonly mcid?: number;
+    /** §11.6.4.4 `/ca` — how opaque the picture is drawn, when the page asked for less. */
+    readonly alpha?: number;
+    /** §11.3.5 `/BM` — a blend the page asked for that nothing here performs. */
+    readonly blend?: string;
+    /** §11.6.5 `/SMask` — the paint faded from place to place; nothing here does. */
+    readonly masked?: boolean;
 }
 /**
  * One segment of a painted path (E-PDF EP10/EP11), in page space (y-up): a
@@ -178,6 +248,23 @@ export interface VectorPlacement {
     readonly gradient?: ShapeGradient;
     /** §11.6.4.4 `/ca` — how opaque the fill is, when the page asked for less. */
     readonly alpha?: number;
+    /**
+     * §11.3.5 `/BM` — the fill only DARKENS what it covers (`Multiply`,
+     * `Darken`), so the marks under it read through. A highlighter is this and
+     * nothing else.
+     */
+    readonly darkens?: boolean;
+    /** §11.3.5 `/BM` — a blend the page asked for that nothing here performs. */
+    readonly blend?: string;
+    /** §11.6.5 `/SMask` — the paint faded from place to place; nothing here does. */
+    readonly masked?: boolean;
+    /**
+     * §9.6.6 — this path is a GLYPH, traced from the face because its code stands
+     * for no character. It is type, not artwork, so the de-cluttering a page's
+     * paths go through does not apply: a full stop is a mark one point across and
+     * every filter there would throw it out.
+     */
+    readonly glyph?: boolean;
     /**
      * §8.7.3 — the TILING pattern resource name the path is filled with. Its
      * content is a stream of its own, so what the fill actually shows is only
@@ -197,11 +284,44 @@ export interface InterpretResult {
     readonly vectors: Array<VectorPlacement>;
     /** §9.6.5 — every Type 3 glyph the stream showed, with where to run it. */
     readonly glyphs: Array<Type3Call>;
+    /**
+     * §8.7.4.3 — every region the stream painted with a bare `sh`, which fills
+     * the CLIP rather than a path. What a caller can do with one depends on the
+     * shading's own type, so the placement is carried rather than counted.
+     */
+    readonly shadings: Array<ShadingPaint>;
+    /**
+     * §9.6.6 — every glyph the stream showed that stands for NO character, as
+     * the path it draws in page space. There is nothing to write for one, and
+     * there is something to draw.
+     */
+    readonly outlines: Array<VectorPlacement>;
 }
 /**
  * §9.6.5 — one showing of a Type 3 glyph: which procedure, and the matrix that
  * puts glyph space on the page.
  */
+/** §8.7.4.3 — one `sh`: which shading, where the CTM put it, what bounded it. */
+export interface ShadingPaint {
+    /** The `/Shading` resource name (no leading slash). */
+    readonly name: string;
+    /** The CTM in force, which maps the shading's own space onto the page. */
+    readonly ctm: Matrix;
+    /** §8.5.4 — the clip the paint was bounded by, which is its whole extent. */
+    readonly clip?: ClipRegion;
+    /**
+     * §11.6.5 `/SMask` — the paint was faded from place to place. For a `sh` that
+     * is not a detail: the mask is the SHAPE, and the clip is only its outer
+     * bound.
+     */
+    readonly masked?: boolean;
+    /** §11.6.4.4 `/ca` — how opaque the paint is, when the page asked for less. */
+    readonly alpha?: number;
+    /** §11.3.5 `/BM` — the paint only DARKENS what it covers. */
+    readonly darkens?: boolean;
+    /** Where it fell in the painting order (§8.5.3). */
+    readonly order: number;
+}
 export interface Type3Call {
     readonly stream: PdfStream;
     readonly resources: PdfDict | undefined;
@@ -222,7 +342,7 @@ export type Matrix = readonly [number, number, number, number, number, number];
 export declare const IDENTITY: Matrix;
 /** Compose two {@link Matrix matrices}: `a` applied first, then `b`. */
 export declare function multiply(a: Matrix, b: Matrix): Matrix;
-export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>, alphas?: ReadonlyMap<string, number>, spaces?: ReadonlyMap<string, ColorSpaceInfo>): InterpretResult;
+export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>, alphas?: ReadonlyMap<string, GsPaint>, spaces?: ReadonlyMap<string, ColorSpaceInfo>, hiddenOc?: ReadonlySet<string>): InterpretResult;
 /**
  * Whether a string is wholly right-to-left: at least one letter of an RTL
  * script and nothing of any other, spaces and joiners aside.