@pixerate/editor 0.112.0 → 0.114.0

package/dist/builtin-CY97ppKM.d.cts

@@ -0,0 +1,354 @@
+/**
+ * Small colour-science helpers: 3×3 matrices, CIE XYZ ↔ L*a*b*, chromatic adaptation. All from
+ * public standards: CIE 15 (L*a*b*), ICC.1:2010 Annex A (PCS, D50) and the Bradford matrix
+ * (Lam 1985).
+ */
+/** The ICC PCS illuminant (D50) as the header stores it: X 0.9642, Y 1, Z 0.8249. */
+declare const D50: readonly [number, number, number];
+/** CIE D65 chromaticity (sRGB, Display P3, Adobe RGB). */
+declare const D65_XY: readonly [number, number];
+/** Row-major 3×3 matrix. */
+type Mat3 = [[number, number, number], [number, number, number], [number, number, number]];
+type Vec3 = [number, number, number];
+declare const IDENTITY: Mat3;
+declare function mul(a: Mat3, b: Mat3): Mat3;
+declare function apply(m: Mat3, v: readonly number[]): Vec3;
+declare function det(m: Mat3): number;
+/** Inverse, or `null` when (nearly) singular. */
+declare function invert(m: Mat3): Mat3 | null;
+/** XYZ (Y = 1) of a chromaticity. */
+declare function xyToXyz(xy: readonly number[]): Vec3;
+/** Bradford chromatic adaptation from white `src` to white `dst` (XYZ). */
+declare function bradford(src: readonly number[], dst: readonly number[]): Mat3;
+/** RGB → XYZ matrix (relative to `white`) from primaries' chromaticities, or `null` when they are dependent. */
+declare function rgbToXyzMatrix(r: readonly number[], g: readonly number[], b: readonly number[], white: readonly number[]): Mat3 | null;
+/** CIE XYZ → L*a*b* relative to `white` (CIE 15). */
+declare function xyzToLab(xyz: readonly number[], white?: readonly number[]): Vec3;
+/** CIE L*a*b* → XYZ relative to `white`. */
+declare function labToXyz(lab: readonly number[], white?: readonly number[]): Vec3;
+/** CIE 1976 colour difference. */
+declare function deltaE76(a: readonly number[], b: readonly number[]): number;
+/** Rounds to ICC s15Fixed16 (what a profile can store). */
+declare const s15f16Round: (v: number) => number;
+/** D50 exactly as an ICC header stores it. */
+declare const d50Quantized: () => Vec3;
+
+/**
+ * One-dimensional tone curves (ICC `curv` and `para`) and their inverses. Gamma and parametric
+ * curves evaluate analytically, also outside 0..1 (negatives mirror, values above 1 extend the
+ * formula), so float transforms keep HDR values. Tables clamp their input to 0..1.
+ */
+type Curve = {
+    type: 'identity';
+} | {
+    type: 'gamma';
+    gamma: number;
+}
+/** ICC `parametricCurveType` function `kind` (0–4), parameters `[g, a, b, c, d, e, f]`. */
+ | {
+    type: 'parametric';
+    kind: number;
+    p: number[];
+}
+/** Samples at evenly spaced inputs over 0..1. */
+ | {
+    type: 'table';
+    table: Float32Array;
+};
+declare const IDENTITY_CURVE: Curve;
+/** The sRGB transfer function (IEC 61966-2.1) as ICC parametric type 3. */
+declare function srgbTrc(): Curve;
+declare const gammaCurve: (g: number) => Curve;
+/** Parameters stored for a parametric function type. */
+declare function paramCount(kind: number): number;
+declare function isIdentityCurve(c: Curve): boolean;
+/** Evaluates a curve at `x`. */
+declare function evalCurve(c: Curve, x: number): number;
+/** Evaluates the inverse curve at `y`. */
+declare function evalCurveInverse(c: Curve, y: number): number;
+/** `n` evenly spaced samples over 0..1. */
+declare function sampleCurve(c: Curve, n: number): Float32Array;
+
+/**
+ * Multidimensional colour lookup tables (ICC CLUTs): node values normalised to 0..1, evaluated
+ * with tetrahedral interpolation for 3 inputs, two tetrahedra lerped along the first input for 4,
+ * and multilinear otherwise.
+ */
+declare const MAX_CHANNELS = 15;
+declare class Clut {
+    readonly grid: number[];
+    readonly outputs: number;
+    readonly data: Float32Array;
+    readonly inputs: number;
+    readonly strides: number[];
+    constructor(grid: number[], outputs: number, data: Float32Array);
+    get nodes(): number;
+    /** A table sampled from `f` at every node. */
+    static sample(grid: number[], outputs: number, f: (input: Float32Array, out: Float32Array) => void): Clut;
+    /** Base offset, fraction and stride along input `d` at `v`. */
+    locate(d: number, v: number, out: number[], k: number): void;
+    private readonly loc;
+    private readonly lo;
+    private readonly hi;
+    eval(input: ArrayLike<number>, out: Float32Array | number[]): void;
+    /** Tetrahedral interpolation in one cube at `base` with strides `sx, sy, sz` and fractions `rx, ry, rz`. */
+    tetra(base: number, sx: number, sy: number, sz: number, rx: number, ry: number, rz: number, out: Float32Array | number[]): void;
+    evalMultilinear(input: ArrayLike<number>, out: Float32Array | number[]): void;
+}
+
+/**
+ * Float evaluation pipelines: stages mapping normalised device values to the profile connection
+ * space (or back). This is the exact path; `Transform` builds faster tables from it.
+ */
+
+/** Largest channel count flowing through a pipeline. */
+declare const MAX_PIPE = 16;
+type Stage = {
+    kind: 'curves';
+    curves: Curve[];
+} | {
+    kind: 'inv-curves';
+    curves: Curve[];
+}
+/** `out[r] = Σ m[r·cols + c]·in[c] + offset[r]`. */
+ | {
+    kind: 'matrix';
+    rows: number;
+    cols: number;
+    m: number[];
+    offset: number[];
+} | {
+    kind: 'clut';
+    clut: Clut;
+}
+/** Float Lab (L 0–100) → XYZ (D50, Y = 1), and back. */
+ | {
+    kind: 'lab-to-xyz';
+} | {
+    kind: 'xyz-to-lab';
+}
+/** ICC v4 / 8-bit Lab encoding (normalised) ↔ float Lab. */
+ | {
+    kind: 'decode-lab-v4';
+} | {
+    kind: 'encode-lab-v4';
+}
+/** ICC v2 legacy 16-bit Lab encoding (`lut16Type`) ↔ float Lab. */
+ | {
+    kind: 'decode-lab-v2';
+} | {
+    kind: 'encode-lab-v2';
+}
+/** u1Fixed15 XYZ encoding ↔ XYZ. */
+ | {
+    kind: 'decode-xyz';
+} | {
+    kind: 'encode-xyz';
+} | {
+    kind: 'clamp01';
+};
+declare function matrix3(m: Mat3): Stage;
+/** Output channels of a stage given `n` inputs. */
+declare function stageOutputs(s: Stage, n: number): number;
+/** A sequence of stages with fixed input and output channel counts. */
+declare class Pipeline {
+    readonly inputs: number;
+    stages: Stage[];
+    outputs: number;
+    private readonly v;
+    private readonly tmp;
+    private readonly tmpIn;
+    private readonly tmpOut;
+    constructor(inputs: number, stages: Stage[]);
+    extend(stages: Stage[]): void;
+    /** Evaluates one colour: `input` has `inputs` values, `out` receives `outputs`. */
+    eval(input: ArrayLike<number>, out: Float32Array | Float64Array | number[]): void;
+    /** Removes no-op stages, cancels adjacent inverse pairs and merges consecutive 3×3 matrices. */
+    optimize(): void;
+}
+
+/** ICC rendering intent. */
+type Intent = 'perceptual' | 'relative' | 'saturation' | 'absolute';
+declare const INTENTS: readonly Intent[];
+declare const intentCode: (i: Intent) => number;
+declare const intentFromCode: (n: number) => Intent | null;
+/** Errors from parsing profiles or building transforms. */
+declare class CmsError extends Error {
+    constructor(message: string);
+}
+type ProfileClass = 'input' | 'display' | 'output' | 'link' | 'colorspace' | 'abstract' | 'named' | 'unknown';
+declare const classSig: (c: ProfileClass) => string;
+/** Data colour space. */
+type ColorSpace = 'xyz' | 'lab' | 'luv' | 'ycbcr' | 'yxy' | 'rgb' | 'gray' | 'hsv' | 'hls' | 'cmyk' | 'cmy' | `${number}clr` | 'unknown';
+declare function spaceSig(c: ColorSpace): string;
+/** Channels of a colour space. */
+declare function spaceChannels(c: ColorSpace): number;
+/** The PCS a stage list ends in (XYZ with Y = 1 for the white, or Lab with L 0–100). */
+type Pcs = 'xyz' | 'lab';
+/** Encoding family of a LUT tag, which fixes how its PCS side is encoded. */
+type LutKind = 'lut8' | 'lut16' | 'ab';
+/** A parsed `AToB` / `BToA` tag: device and PCS values normalised to 0..1. */
+interface Lut {
+    kind: LutKind;
+    inputs: number;
+    outputs: number;
+    stages: Stage[];
+}
+/** A parsed ICC profile. */
+interface Profile {
+    /** Major version and minor.bugfix byte (`[4, 0x30]` for 4.3). */
+    version: [number, number];
+    profileClass: ProfileClass;
+    colorSpace: ColorSpace;
+    pcs: Pcs;
+    renderingIntent: Intent;
+    description: string;
+    copyright: string;
+    /** `wtpt` (D50 when absent). */
+    whitePoint: Vec3;
+    blackPoint: Vec3 | null;
+    /** `chad` chromatic adaptation. */
+    chad: Mat3 | null;
+    /** Colorant matrix (columns rXYZ, gXYZ, bXYZ), D50-adapted. */
+    matrix: Mat3 | null;
+    trc: [Curve, Curve, Curve] | null;
+    grayTrc: Curve | null;
+    /** AToB0/1/2 (perceptual, colorimetric, saturation). */
+    a2b: [Lut | null, Lut | null, Lut | null];
+    b2a: [Lut | null, Lut | null, Lut | null];
+    /** The bytes it was parsed from (or encoded to), for byte-exact embedding. */
+    bytes: Uint8Array | null;
+}
+declare function profileChannels(p: Profile): number;
+/** Largest ΔE*ab at which `sameColors` treats two profiles as one colour space. */
+declare const SAME_COLORS_MAX_DELTA_E = 0.5;
+/**
+ * Media white for ICC-absolute colorimetry: `wtpt`, except for v2 display profiles, whose
+ * `wtpt` records the unadapted display white; those count as D50.
+ */
+declare function mediaWhite(p: Profile): Vec3;
+/** True for matrix/TRC RGB or grey TRC profiles without LUTs. */
+declare function isMatrixShaper(p: Profile): boolean;
+/** Whether the profile has its own table for `intent` (matrix profiles serve every intent). */
+declare function supportsIntent(p: Profile, intent: Intent, input: boolean): boolean;
+/** Stages mapping normalised device values to the float PCS. */
+declare function deviceToPcs(p: Profile, intent: Intent): {
+    stages: Stage[];
+    pcs: Pcs;
+};
+/** Stages mapping the float PCS (of the returned kind) to normalised device values. */
+declare function pcsToDevice(p: Profile, intent: Intent): {
+    stages: Stage[];
+    pcs: Pcs;
+};
+/** Whether colours can be converted into this profile for every intent (input-only profiles cannot). */
+declare function canBeDestination(p: Profile): boolean;
+/**
+ * An RGB view of a grey TRC profile: R, G and B each carry the grey curve and a third of the
+ * white, so (v, v, v) has exactly the colour of grey v.
+ */
+declare function grayAsRgb(p: Profile): Profile | null;
+/** Parses ICC profile bytes. Throws `CmsError` for anything that is not a usable profile. */
+declare function parseProfile(bytes: Uint8Array): Profile;
+
+interface TransformOptions {
+    intent: Intent;
+    /** Black point compensation (ignored for absolute colorimetric). Default true. */
+    bpc: boolean;
+    /** Float buffers through the exact pipeline (default true) rather than the tables. */
+    preciseFloat: boolean;
+}
+declare const DEFAULT_TRANSFORM_OPTIONS: Readonly<TransformOptions>;
+/** A colour transform from one profile's device space to another's. Build once, apply often. */
+declare class Transform {
+    readonly pipeline: Pipeline;
+    readonly options: TransformOptions;
+    readonly inputs: number;
+    readonly outputs: number;
+    private core;
+    private post;
+    private readonly mid;
+    private readonly tmp;
+    private readonly inp;
+    constructor(pipeline: Pipeline, options: TransformOptions);
+    /** From `src` to `dst` with `intent` (and black point compensation). */
+    static create(src: Profile, dst: Profile, options?: Partial<TransformOptions>): Transform;
+    /**
+     * Soft proof `src → proof → dst` (View › Proof Setup): `intent` / `bpc` apply to the
+     * document → proof step; proof → display is relative colorimetric with BPC, or absolute
+     * colorimetric without it when `simulatePaper` (paper colour and black ink simulated).
+     */
+    static proof(src: Profile, proof: Profile, dst: Profile, intent: Intent, bpc: boolean, simulatePaper: boolean): Transform;
+    /** The device-link node at the source's device white gets exactly the destination's white. */
+    private fixWhite;
+    /** Exact evaluation of one colour. */
+    eval(input: ArrayLike<number>, out: Float32Array | number[]): void;
+    /** Table evaluation of one colour (what integer buffers use). */
+    evalFast(input: ArrayLike<number>, out: Float32Array | number[]): void;
+    private finish;
+    /**
+     * Converts 8-bit interleaved pixels: `src` has `srcStride` samples per pixel (colour first),
+     * `dst` `dstStride`. With `copyExtra`, trailing channels (alpha) are copied.
+     */
+    convert8(src: ArrayLike<number>, srcStride: number, dst: Uint8Array | Uint8ClampedArray, dstStride: number, copyExtra?: boolean): void;
+    /** Converts 16-bit interleaved pixels (see `convert8`). */
+    convert16(src: ArrayLike<number>, srcStride: number, dst: Uint16Array, dstStride: number, copyExtra?: boolean): void;
+    /** Converts float interleaved pixels (exact unless `preciseFloat` is off). */
+    convertFloat(src: ArrayLike<number>, srcStride: number, dst: Float32Array, dstStride: number, copyExtra?: boolean): void;
+    private check;
+}
+/** Stages from `src` device values to `dst` device values. */
+declare function linkStages(src: Profile, dst: Profile, intent: Intent, bpc: boolean): Stage[];
+/** Luminance (Y, D50-relative) of a profile's black point for `intent`. */
+declare function blackPoint(p: Profile, intent: Intent): number;
+/** A transform from a small cache keyed by the profile objects and the options. */
+declare function cachedTransform(src: Profile, dst: Profile, options?: Partial<TransformOptions>): Transform;
+/**
+ * Whether two profiles describe the same colours: same colour space, and every sample of a
+ * device grid lands within ΔE*ab 0.5 through both (relative colorimetric), whatever their
+ * encodings (Photoshop's v2 sRGB and a v4 parametric sRGB are the same colours).
+ */
+declare function sameColors(a: Profile, b: Profile, lab: Profile): boolean;
+/** Out-of-gamut test (Photoshop's Gamut Warning): ΔE between a colour and its round trip through a proof profile. */
+declare class GamutCheck {
+    /** ΔE*ab above which a colour is out of gamut (default 4). */
+    readonly threshold: number;
+    private readonly grid;
+    private readonly direct;
+    private readonly via;
+    constructor(src: Profile, proof: Profile, lab: Profile, 
+    /** ΔE*ab above which a colour is out of gamut (default 4). */
+    threshold?: number);
+    /** ΔE*ab of a colour (normalised device values). */
+    deltaE(px: ArrayLike<number>): number;
+    outOfGamut(px: ArrayLike<number>): boolean;
+}
+/** A 3D lookup table of an RGB → RGB transform (`size`³ RGB triples, red fastest), for fast display paths. */
+declare class Lut3d {
+    readonly size: number;
+    readonly data: Float32Array;
+    constructor(t: Transform, size?: number);
+    /** Trilinear sample of 0..1 RGB into `out`. */
+    sample(r: number, g: number, b: number, out: number[] | Float32Array): void;
+    /** Applies the table to 8-bit RGBA in place (alpha kept), through a per-code 8-bit cache of the lattice. */
+    apply8(data: Uint8ClampedArray | Uint8Array): void;
+}
+
+declare const BUILTIN_COPYRIGHT = "No copyright: CC0-1.0 public domain dedication. Generated by Pixerate.";
+/** Identifiers of the built-in profiles. */
+type BuiltinProfileId = 'srgb' | 'display-p3' | 'adobe-rgb-compat' | 'prophoto-compat' | 'linear-srgb' | 'rec2020' | 'gray-gamma-2.2' | 'sgray' | 'dot-gain-20-compat' | 'lab-d50' | 'coated-cmyk';
+declare const BUILTIN_PROFILES: readonly {
+    id: BuiltinProfileId;
+    description: string;
+    colorSpace: ColorSpace;
+}[];
+/** Looks up a built-in id (case-insensitive; a few aliases and the descriptions too). */
+declare function builtinProfileId(s: string): BuiltinProfileId | null;
+/** A built-in profile (built once; the synthetic CMYK takes about a second the first time). */
+declare function builtinProfile(id: BuiltinProfileId): Profile;
+/** sRGB IEC 61966-2.1, the default working space. */
+declare const srgbProfile: () => Profile;
+/** The default profile of a colour space: sRGB, Dot Gain 20 %-compatible grey, the coated CMYK, Lab D50. */
+declare function defaultProfileFor(cs: ColorSpace): Profile | null;
+
+export { linkStages as $, classSig as A, BUILTIN_COPYRIGHT as B, Clut as C, D50 as D, d50Quantized as E, defaultProfileFor as F, GamutCheck as G, deltaE76 as H, IDENTITY as I, det as J, deviceToPcs as K, type Lut as L, MAX_CHANNELS as M, evalCurve as N, evalCurveInverse as O, type Profile as P, gammaCurve as Q, grayAsRgb as R, SAME_COLORS_MAX_DELTA_E as S, Transform as T, intentCode as U, type Vec3 as V, intentFromCode as W, invert as X, isIdentityCurve as Y, isMatrixShaper as Z, labToXyz as _, BUILTIN_PROFILES as a, matrix3 as a0, mediaWhite as a1, mul as a2, paramCount as a3, parseProfile as a4, pcsToDevice as a5, profileChannels as a6, rgbToXyzMatrix as a7, s15f16Round as a8, sameColors as a9, sampleCurve as aa, spaceChannels as ab, spaceSig as ac, srgbProfile as ad, srgbTrc as ae, stageOutputs as af, supportsIntent as ag, xyToXyz as ah, xyzToLab as ai, type BuiltinProfileId as b, CmsError as c, type ColorSpace as d, type Curve as e, D65_XY as f, DEFAULT_TRANSFORM_OPTIONS as g, IDENTITY_CURVE as h, INTENTS as i, type Intent as j, Lut3d as k, type LutKind as l, MAX_PIPE as m, type Mat3 as n, type Pcs as o, Pipeline as p, type ProfileClass as q, type Stage as r, type TransformOptions as s, apply as t, blackPoint as u, bradford as v, builtinProfile as w, builtinProfileId as x, cachedTransform as y, canBeDestination as z };