@pixerate/editor 0.113.0 → 0.115.0

package/dist/warp-DMN30aY6.d.ts

@@ -0,0 +1,348 @@
+import { B as BezierPath } from './bezier-DYBvLgUH.js';
+import { W as WarpStyle, a as WarpMesh, V as Vec2, B as Box } from './types-CwMPoRMU.js';
+
+/**
+ * Shared text model: character and paragraph styles over runs of plain text, and the `TextShaper`
+ * interface through which layout reaches fonts. Used by the image editor's type layers and the
+ * vector editor's text nodes, so both lay text out the same way. No DOM and no third-party code.
+ */
+
+/** An axis-aligned rectangle. */
+interface TextRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * The character style of a run of text (Photoshop's Character panel). Sizes are document pixels;
+ * tracking is in 1/1000 em.
+ */
+interface TextStyle {
+    /** Family name ("Inter"); fonts the system lacks fall back to a generic family, with a warning. */
+    fontFamily: string;
+    /** CSS weight, 100..900 (default 400). */
+    fontWeight: number;
+    /** Default false. */
+    italic?: boolean;
+    /** Font size in pixels. */
+    fontSize: number;
+    /** `#rrggbb`. */
+    color: string;
+    /** 0..1 (missing = 1). */
+    opacity?: number;
+    /** Letter spacing in 1/1000 em (missing = 0). */
+    tracking?: number;
+    /** Baseline-to-baseline distance in pixels; missing = auto (the paragraph's `autoLeading` × size). */
+    leading?: number;
+    /** Pixels; positive raises the text (missing = 0). */
+    baselineShift?: number;
+    underline?: boolean;
+    strikethrough?: boolean;
+    /** PostScript name from a PSD (`ArialMT`), kept so the exact face can be found and written back. */
+    postScriptName?: string;
+}
+/** A character style over `length` UTF-16 code units of the text, in order. */
+interface TextRun {
+    length: number;
+    style: TextStyle;
+}
+type TextAlign = 'left' | 'center' | 'right' | 'justify';
+declare const TEXT_ALIGNS: readonly TextAlign[];
+/** Paragraph style (Photoshop's Paragraph panel); lengths in pixels. */
+interface ParagraphStyle {
+    /** Default `left`. `justify` stretches every line of a paragraph box but the last. */
+    align?: TextAlign;
+    /** Auto leading as a multiple of the font size (default 1.2). */
+    autoLeading?: number;
+    firstLineIndent?: number;
+    startIndent?: number;
+    endIndent?: number;
+    spaceBefore?: number;
+    spaceAfter?: number;
+}
+/** A paragraph style over `length` UTF-16 code units (whole paragraphs, line break included). */
+interface ParagraphRun {
+    length: number;
+    style: ParagraphStyle;
+}
+/** A font as a shaper is asked for it (sizes in pixels). */
+interface TextFont {
+    family: string;
+    weight: number;
+    italic: boolean;
+    size: number;
+    postScriptName?: string;
+}
+/**
+ * What layout and rendering need from fonts. Implement `outline` (glyph outlines, pure) or `draw`
+ * (onto a 2D canvas), or both.
+ */
+interface TextShaper {
+    /** Identifies the shaper (part of the render cache key). */
+    readonly id: string;
+    /** The family that draws `font`: the family itself when available, else a fallback (`available: false`). */
+    resolve(font: TextFont): {
+        family: string;
+        available: boolean;
+    };
+    /** Ascent and descent (both positive, pixels) of the resolved font at `font.size`. */
+    metrics(font: TextFont): {
+        ascent: number;
+        descent: number;
+    };
+    /**
+     * Caret positions of `text` set in `font`: `text.length + 1` x offsets in pixels from the start
+     * (kerning included, tracking not).
+     */
+    measure(text: string, font: TextFont): ArrayLike<number>;
+    /** Glyph outlines of `text` with its start on the baseline at (`x`, `y`), pixels, y down. */
+    outline?(text: string, font: TextFont, x: number, y: number): BezierPath;
+    /** Draws `text` with its start on the baseline at (`x`, `y`) in the context's current transform, fill style and alpha. */
+    draw?(ctx: CanvasRenderingContext2D, text: string, font: TextFont, x: number, y: number): void;
+    /** Families this shaper can draw (for font pickers and agents), when it can tell. */
+    families?(): string[];
+}
+
+/**
+ * Text layout shared by the image editor's type layers and the vector editor's text nodes: styled
+ * runs, paragraphs, line breaking (at spaces and after break characters, and between wide CJK
+ * characters), alignment and justification, tracking, leading, indents, spacing, baseline shift,
+ * caret positions and hit testing. Everything that needs a font goes through a `TextShaper`, so
+ * the same measurements give the same lines in every host.
+ */
+
+/** What layout needs: the text, its character and paragraph runs and its frame. */
+interface TextBlock {
+    text: string;
+    runs: ReadonlyArray<{
+        length: number;
+        style: TextStyle;
+    }>;
+    paragraphs: readonly ParagraphRun[];
+    /**
+     * `point`: lines grow from the origin, one per paragraph; the first baseline is at y = 0, or one
+     * ascent down with `origin: 'top'`. `box`: lines wrap inside `width` and the first baseline is one
+     * ascent below the top (`height` bounds the layout's box; lines past it still lay out).
+     */
+    frame: {
+        kind: 'point';
+        origin?: 'baseline' | 'top';
+    } | {
+        kind: 'box';
+        width: number;
+        height: number;
+    };
+}
+declare const DEFAULT_TEXT_STYLE: TextStyle;
+declare const DEFAULT_AUTO_LEADING = 1.2;
+/** Runs fitted to a text of `length` (the last run stretches or is cut), never empty while there is text. */
+declare function fitRuns<R extends {
+    length: number;
+    style: object;
+}>(runs: readonly R[], length: number, fallback: R['style']): R[];
+/** The style of the run holding code unit `index` (the last run past the end). */
+declare function styleAt<S extends object>(runs: ReadonlyArray<{
+    length: number;
+    style: S;
+}>, index: number, fallback: S): S;
+/** Runs with `patch(style)` applied over [start, end). */
+declare function restyleRange<S extends object>(runs: ReadonlyArray<{
+    length: number;
+    style: S;
+}>, start: number, end: number, patch: (s: S) => S): Array<{
+    length: number;
+    style: S;
+}>;
+/** Runs after replacing [start, end) of the text with `inserted` code units styled `style`. */
+declare function spliceRuns<S extends object>(runs: ReadonlyArray<{
+    length: number;
+    style: S;
+}>, start: number, end: number, inserted: number, style: S): Array<{
+    length: number;
+    style: S;
+}>;
+/** Paragraph ranges [start, end) of the text, the line break included in the paragraph it ends. */
+declare function paragraphRanges(text: string): Array<{
+    start: number;
+    end: number;
+    content: number;
+}>;
+/** Paragraph runs snapped to whole paragraphs: each paragraph takes the style at its start. */
+declare function fitParagraphRuns(runs: readonly ParagraphRun[], text: string): ParagraphRun[];
+/** One laid-out character. */
+interface LaidChar {
+    /** Index in the text (UTF-16 code unit). */
+    index: number;
+    /** Text-space x of its start and its advance (tracking and justification included). */
+    x: number;
+    advance: number;
+}
+/** A run of characters on one line in one style. */
+interface LaidFragment {
+    start: number;
+    end: number;
+    style: TextStyle;
+    font: TextFont;
+    /** The family the shaper draws it with. */
+    family: string;
+    x: number;
+    /** Baseline in text space (baseline shift applied). */
+    y: number;
+    /** Per-character x positions relative to `x` (`end − start + 1` entries). */
+    carets: number[];
+    /** Whether characters are placed one by one (tracking or justification). */
+    spaced: boolean;
+}
+interface LaidLine {
+    start: number;
+    /** End of the line's characters (line break and trailing spaces excluded from `width`). */
+    end: number;
+    baseline: number;
+    ascent: number;
+    descent: number;
+    x: number;
+    width: number;
+    chars: LaidChar[];
+    fragments: LaidFragment[];
+}
+/** A laid-out type layer in text space. */
+interface TextLayout {
+    lines: LaidLine[];
+    /** Bounds of the lines (ascent to descent), text space; the box for paragraph text. */
+    bounds: TextRect;
+    /** Families replaced by a fallback. */
+    missingFonts: string[];
+}
+declare function fontOf(style: TextStyle): TextFont;
+/** Lays out a type layer with `shaper` (memoised per layer object and shaper). */
+declare function layoutText(layer: TextBlock, shaper: TextShaper): TextLayout;
+/** The text index nearest a text-space point (for clicks): the line under it, then the closest caret. */
+declare function textIndexAt(layout: TextLayout, p: {
+    x: number;
+    y: number;
+}): number;
+/** The caret at text index `index`: its x and the line's top and bottom, text space. */
+declare function caretAt(layout: TextLayout, index: number): {
+    x: number;
+    top: number;
+    bottom: number;
+    line: number;
+};
+
+/**
+ * Warp geometry shared by the vector editor's envelopes and the image editor's Free Transform
+ * warp: preset warp styles and editable Bézier meshes, both forward maps from a source box onto
+ * the plane.
+ *
+ * - **Presets** (`WarpStyle`, Photoshop's fifteen with bend and horizontal / vertical distortion
+ *   in percent): each is one bicubic Bézier patch whose 4 × 4 control grid follows the bend
+ *   (`warpPresetGrid`). Every preset is the identity at bend 0 and continuous in it.
+ * - **Meshes** (`WarpMesh`): a grid of bicubic patches. Splitting a mesh (`splitWarpMeshU` / `V`)
+ *   is an exact de Casteljau subdivision, so it never changes the shape, and a preset turns into
+ *   an editable mesh of any size exactly.
+ *
+ * Ported from ArtCraft (MIT OR Apache-2.0, © ArtCraft Team and contributors; see
+ * THIRD_PARTY_NOTICES.md): photocraft `crates/geom/src/warp.rs` (`WarpStyle`, `StyleWarp`,
+ * `rest_grid`, `edge_arc`, `arc_grid`, `blend_rows`, `preset_grid`, `bernstein`, `split_cubic`,
+ * `BERN_INV`, and `BezierMesh`: `identity`, `fit`, `eval`, `split_u`, `split_v`, `remove_split_u`,
+ * `transpose`, `map_points`, `param_at`, `pull`, `smooth_lines`, `drag_point`, `control_bounds`;
+ * `Warp::map` and `Warp::to_mesh`).
+ */
+
+/** The fifteen presets in Photoshop's menu order. */
+declare const WARP_STYLES: readonly WarpStyle[];
+declare const WARP_STYLE_LABELS: Readonly<Record<WarpStyle, string>>;
+/**
+ * A preset as a Bézier control grid (rows of `[x, y]` in box units, y down). `b`, `hd`, `vd` are
+ * the bend and the horizontal / vertical distortion as fractions (−1…1); `aspect` is the box's
+ * height over its width. The arc family stays circular in pixels, the other offsets scale with the
+ * box, and a vertical warp is the horizontal one with the axes (and distortions) swapped.
+ */
+declare function warpPresetGrid(style: WarpStyle, b: number, hd: number, vd: number, vertical: boolean, aspect: number): [number, number][][];
+/** A preset warp's settings (bend and distortions in percent, −100…100). */
+interface WarpPreset {
+    style: WarpStyle;
+    bend: number;
+    horizontal?: number;
+    vertical?: number;
+    /** Bend along the vertical axis. */
+    orientation?: 'horizontal' | 'vertical';
+}
+/**
+ * A preset as one Bézier patch over `bounds` (points in the bounds' space), or null when it
+ * changes nothing (an unknown style, all-zero amounts, or an empty box).
+ */
+declare function warpPresetMesh(preset: WarpPreset, bounds: Box): WarpMesh | null;
+/** Control points per row. */
+declare const warpMeshColumns: (m: WarpMesh) => number;
+/** Control point rows. */
+declare const warpMeshRows: (m: WarpMesh) => number;
+/** Whether a mesh is well formed: knots from 0 to 1 increasing, the right number of finite points. */
+declare function isValidWarpMesh(m: unknown): m is WarpMesh;
+/** Fits a mesh with patch boundaries `us` / `vs` to the map `f` (box fractions → output) by interpolating it at each patch's thirds. Exact for bicubic maps (affine maps included). */
+declare function fitWarpMesh(f: (s: number, t: number) => Vec2, us: readonly number[], vs: readonly number[]): WarpMesh;
+/** The identity mesh over `bounds` with `columns × rows` patches. */
+declare function identityWarpMesh(bounds: Box, columns?: number, rows?: number): WarpMesh;
+/** The surface at box fractions `(s, t)`. */
+declare function evalWarpMesh(m: WarpMesh, s: number, t: number): Vec2;
+/** The mesh with the patch column holding `s` split at `s` (exact). Null when `s` is on or too close to a boundary. */
+declare function splitWarpMeshU(m: WarpMesh, s: number): WarpMesh | null;
+/** The mesh with the patch row holding `t` split at `t` (exact). */
+declare function splitWarpMeshV(m: WarpMesh, t: number): WarpMesh | null;
+/**
+ * The mesh without interior vertical boundary `k` (1 … us.length − 2), its two patch columns
+ * merged: exact when they came from an unedited split; otherwise the outer control points stay and
+ * the inner handles are extrapolated.
+ */
+declare function removeWarpMeshSplitU(m: WarpMesh, k: number): WarpMesh | null;
+/** Removes interior horizontal boundary `k`. */
+declare function removeWarpMeshSplitV(m: WarpMesh, k: number): WarpMesh | null;
+/** Every control point through `f` (exact for affine maps). */
+declare function mapWarpMeshPoints(m: WarpMesh, f: (p: Vec2) => Vec2): WarpMesh;
+/**
+ * The mesh with `columns × rows` patches over the same surface: split exactly when its knots are
+ * a subset of the new even ones (a one-patch mesh always is), otherwise refitted.
+ */
+declare function resizeWarpMesh(m: WarpMesh, columns: number, rows: number): WarpMesh;
+/** Bounding box of the control points (the surface lies inside it). */
+declare function warpMeshControlBounds(m: WarpMesh): Box;
+/** Box fractions `(s, t)` whose surface point is nearest `p` (a coarse search, then Newton steps). */
+declare function warpMeshParamAt(m: WarpMesh, p: Vec2): {
+    s: number;
+    t: number;
+    distance: number;
+};
+/**
+ * `base` with control point `index` dragged by `d`, keeping the surface smooth across the grid
+ * lines: an anchor moves with the eight points around it as one block; a handle moves with the two
+ * points beside it across its line, and the handle opposite it on the same anchor turns the other
+ * way (with its two neighbours), so the line keeps passing straight through the anchor. An inner
+ * point of a patch moves alone.
+ */
+declare function dragWarpMeshPoint(base: WarpMesh, index: number, d: Vec2): WarpMesh;
+/**
+ * `base` with its surface point at box fractions `(s, t)` pulled by `d`, the way dragging inside a
+ * patch works: interior anchors within about two cells follow by a share of `d` that fades with
+ * distance (each with its block of handles, so grid lines stay smooth); the outer border stays
+ * pinned unless the grab is near it, and then it bows; the four corners never move. The grabbed
+ * patch's inner points (and, near the border, the border's handles) make up the rest, so the
+ * grabbed point lands exactly at its start + `d`.
+ */
+declare function pullWarpMesh(base: WarpMesh, s: number, t: number, d: Vec2): WarpMesh;
+/**
+ * The control points an editor shows: the anchors (where grid lines cross) and the handles along
+ * the grid lines, each with the anchor it belongs to. Points inside a patch are left out (drag
+ * inside a patch to pull the surface instead).
+ */
+declare function warpMeshEditPoints(m: WarpMesh): {
+    anchors: number[];
+    handles: {
+        index: number;
+        anchor: number;
+    }[];
+};
+/** The mesh's grid lines (patch borders) as cubics `[p0, p1, p2, p3]`. */
+declare function warpMeshGridCurves(m: WarpMesh): Vec2[][];
+
+export { warpPresetGrid as A, warpPresetMesh as B, type TextAlign as C, DEFAULT_AUTO_LEADING as D, DEFAULT_TEXT_STYLE as E, type LaidChar as F, TEXT_ALIGNS as G, caretAt as H, fitParagraphRuns as I, fitRuns as J, fontOf as K, type LaidFragment as L, layoutText as M, paragraphRanges as N, restyleRange as O, type ParagraphRun as P, spliceRuns as Q, styleAt as R, textIndexAt as S, type TextShaper as T, type WarpPreset as W, type TextFont as a, type TextRun as b, type ParagraphStyle as c, type TextStyle as d, type TextLayout as e, type LaidLine as f, WARP_STYLES as g, WARP_STYLE_LABELS as h, dragWarpMeshPoint as i, evalWarpMesh as j, fitWarpMesh as k, isValidWarpMesh as l, mapWarpMeshPoints as m, removeWarpMeshSplitV as n, resizeWarpMesh as o, pullWarpMesh as p, splitWarpMeshV as q, removeWarpMeshSplitU as r, splitWarpMeshU as s, identityWarpMesh as t, warpMeshControlBounds as u, warpMeshEditPoints as v, warpMeshColumns as w, warpMeshGridCurves as x, warpMeshParamAt as y, warpMeshRows as z };

package/dist/zlib-dxQdgHyN.d.cts

@@ -0,0 +1,95 @@
+/** Above this σ a Gaussian is approximated by three box passes (cost independent of σ). */
+declare const DIRECT_GAUSSIAN_MAX_SIGMA = 8;
+/** How a blur treats pixels beyond the image: `zero`, or `clamp` (replicate the border). */
+type BlurEdge = 'zero' | 'clamp';
+type Edge = BlurEdge;
+/**
+ * Separable Gaussian blur of a single-channel float image. `edge` `zero` treats pixels beyond
+ * the image as 0 (selection feather), `clamp` replicates the border (mask refinement). σ up to
+ * {@link DIRECT_GAUSSIAN_MAX_SIGMA} is convolved directly; wider blurs use three box passes, so
+ * the cost per pixel never grows with σ.
+ */
+declare function gaussianBlur(src: ArrayLike<number>, w: number, h: number, sigma: number, edge?: Edge): Float32Array;
+
+/**
+ * Curve lookup tables shared by Curves adjustments and layer-effect contours.
+ */
+/** Entries of a curve LUT (input 0..1 in `size - 1` steps). */
+declare const CURVE_LUT_SIZE = 4096;
+/**
+ * Photoshop curve: a natural cubic spline through the points (0..1 in and out; it may overshoot
+ * between points, as Photoshop's does), constant outside the first / last point, clamped to
+ * 0..1, sampled into a LUT. Fewer than two distinct points: the identity.
+ */
+declare function curveLut(points: ReadonlyArray<{
+    input: number;
+    output: number;
+}>, size?: number): Float32Array;
+
+/**
+ * Dependency-free, synchronous PNG encode / decode for layer pixels and masks, plus base64 and
+ * data-URL helpers. Canvas `toDataURL` is lossy for partly transparent pixels (it goes through
+ * premultiplied alpha), so layer assets use this codec and round-trip exactly.
+ *
+ * Encodes 8-bit greyscale (masks) or RGBA (layers). Decodes non-interlaced 1/2/4/8/16-bit
+ * greyscale, RGB, palette, grey + alpha and RGBA, always to 8-bit RGBA or grey.
+ */
+interface DecodedPng {
+    width: number;
+    height: number;
+    /** 4 for RGBA output, 1 for greyscale without alpha when `keepGray` was asked for. */
+    channels: 1 | 4;
+    data: Uint8ClampedArray;
+}
+/** PNG bytes for `width × height` pixels of 1 (grey) or 4 (RGBA) bytes each. */
+declare function encodePng(width: number, height: number, data: ArrayLike<number>, channels?: 1 | 4): Uint8Array;
+declare function isPng(bytes: Uint8Array): boolean;
+/**
+ * Decodes a PNG. Output is RGBA (4 channels) unless `keepGray` is set and the image is
+ * greyscale without alpha, in which case it is one byte per pixel.
+ */
+declare function decodePng(bytes: Uint8Array, options?: {
+    keepGray?: boolean;
+    maxPixels?: number;
+}): DecodedPng;
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function base64ToBytes(text: string): Uint8Array;
+/** The bytes and MIME type of a `data:` URL (base64 or percent-encoded). */
+declare function parseDataUrl(url: string): {
+    mime: string;
+    bytes: Uint8Array;
+} | null;
+declare function pngDataUrl(width: number, height: number, data: ArrayLike<number>, channels?: 1 | 4): string;
+
+/**
+ * Synchronous zlib (RFC 1950) and raw deflate (RFC 1951), dependency-free, for the image editor's
+ * layer PNGs and PSD ZIP channels. `CompressionStream` is asynchronous and not everywhere, and
+ * layer pixels must serialize inside the synchronous `toJSON()`.
+ *
+ * - `inflate` handles stored, fixed and dynamic blocks and refuses to produce more than
+ *   `maxOutput` bytes (a decompression bomb guard).
+ * - `deflate` is a greedy LZ77 (hash chains, 32 KiB window) with one dynamic Huffman block per
+ *   64 Ki symbols. It favours simplicity over the last few percent of ratio.
+ */
+declare class ZlibError extends Error {
+    constructor(message: string);
+}
+/** Inflates raw deflate data (no zlib header). */
+declare function inflateRaw(data: Uint8Array, options?: {
+    maxOutput?: number;
+    sizeHint?: number;
+}): Uint8Array;
+/** Adler-32 checksum (zlib trailer). */
+declare function adler32(data: Uint8Array): number;
+/** Inflates zlib data (header, deflate stream, Adler-32 trailer). */
+declare function inflate(data: Uint8Array, options?: {
+    maxOutput?: number;
+    sizeHint?: number;
+    verify?: boolean;
+}): Uint8Array;
+/** Raw deflate (no zlib header). `level` 0 stores the data uncompressed. */
+declare function deflateRaw(data: Uint8Array, level?: 0 | 1): Uint8Array;
+/** zlib stream: header, raw deflate, Adler-32. */
+declare function deflate(data: Uint8Array, level?: 0 | 1): Uint8Array;
+
+export { type BlurEdge as B, CURVE_LUT_SIZE as C, DIRECT_GAUSSIAN_MAX_SIGMA as D, ZlibError as Z, type DecodedPng as a, adler32 as b, base64ToBytes as c, bytesToBase64 as d, curveLut as e, decodePng as f, deflate as g, deflateRaw as h, encodePng as i, gaussianBlur as j, inflate as k, inflateRaw as l, isPng as m, pngDataUrl as n, parseDataUrl as p };

package/dist/zlib-dxQdgHyN.d.ts

@@ -0,0 +1,95 @@
+/** Above this σ a Gaussian is approximated by three box passes (cost independent of σ). */
+declare const DIRECT_GAUSSIAN_MAX_SIGMA = 8;
+/** How a blur treats pixels beyond the image: `zero`, or `clamp` (replicate the border). */
+type BlurEdge = 'zero' | 'clamp';
+type Edge = BlurEdge;
+/**
+ * Separable Gaussian blur of a single-channel float image. `edge` `zero` treats pixels beyond
+ * the image as 0 (selection feather), `clamp` replicates the border (mask refinement). σ up to
+ * {@link DIRECT_GAUSSIAN_MAX_SIGMA} is convolved directly; wider blurs use three box passes, so
+ * the cost per pixel never grows with σ.
+ */
+declare function gaussianBlur(src: ArrayLike<number>, w: number, h: number, sigma: number, edge?: Edge): Float32Array;
+
+/**
+ * Curve lookup tables shared by Curves adjustments and layer-effect contours.
+ */
+/** Entries of a curve LUT (input 0..1 in `size - 1` steps). */
+declare const CURVE_LUT_SIZE = 4096;
+/**
+ * Photoshop curve: a natural cubic spline through the points (0..1 in and out; it may overshoot
+ * between points, as Photoshop's does), constant outside the first / last point, clamped to
+ * 0..1, sampled into a LUT. Fewer than two distinct points: the identity.
+ */
+declare function curveLut(points: ReadonlyArray<{
+    input: number;
+    output: number;
+}>, size?: number): Float32Array;
+
+/**
+ * Dependency-free, synchronous PNG encode / decode for layer pixels and masks, plus base64 and
+ * data-URL helpers. Canvas `toDataURL` is lossy for partly transparent pixels (it goes through
+ * premultiplied alpha), so layer assets use this codec and round-trip exactly.
+ *
+ * Encodes 8-bit greyscale (masks) or RGBA (layers). Decodes non-interlaced 1/2/4/8/16-bit
+ * greyscale, RGB, palette, grey + alpha and RGBA, always to 8-bit RGBA or grey.
+ */
+interface DecodedPng {
+    width: number;
+    height: number;
+    /** 4 for RGBA output, 1 for greyscale without alpha when `keepGray` was asked for. */
+    channels: 1 | 4;
+    data: Uint8ClampedArray;
+}
+/** PNG bytes for `width × height` pixels of 1 (grey) or 4 (RGBA) bytes each. */
+declare function encodePng(width: number, height: number, data: ArrayLike<number>, channels?: 1 | 4): Uint8Array;
+declare function isPng(bytes: Uint8Array): boolean;
+/**
+ * Decodes a PNG. Output is RGBA (4 channels) unless `keepGray` is set and the image is
+ * greyscale without alpha, in which case it is one byte per pixel.
+ */
+declare function decodePng(bytes: Uint8Array, options?: {
+    keepGray?: boolean;
+    maxPixels?: number;
+}): DecodedPng;
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function base64ToBytes(text: string): Uint8Array;
+/** The bytes and MIME type of a `data:` URL (base64 or percent-encoded). */
+declare function parseDataUrl(url: string): {
+    mime: string;
+    bytes: Uint8Array;
+} | null;
+declare function pngDataUrl(width: number, height: number, data: ArrayLike<number>, channels?: 1 | 4): string;
+
+/**
+ * Synchronous zlib (RFC 1950) and raw deflate (RFC 1951), dependency-free, for the image editor's
+ * layer PNGs and PSD ZIP channels. `CompressionStream` is asynchronous and not everywhere, and
+ * layer pixels must serialize inside the synchronous `toJSON()`.
+ *
+ * - `inflate` handles stored, fixed and dynamic blocks and refuses to produce more than
+ *   `maxOutput` bytes (a decompression bomb guard).
+ * - `deflate` is a greedy LZ77 (hash chains, 32 KiB window) with one dynamic Huffman block per
+ *   64 Ki symbols. It favours simplicity over the last few percent of ratio.
+ */
+declare class ZlibError extends Error {
+    constructor(message: string);
+}
+/** Inflates raw deflate data (no zlib header). */
+declare function inflateRaw(data: Uint8Array, options?: {
+    maxOutput?: number;
+    sizeHint?: number;
+}): Uint8Array;
+/** Adler-32 checksum (zlib trailer). */
+declare function adler32(data: Uint8Array): number;
+/** Inflates zlib data (header, deflate stream, Adler-32 trailer). */
+declare function inflate(data: Uint8Array, options?: {
+    maxOutput?: number;
+    sizeHint?: number;
+    verify?: boolean;
+}): Uint8Array;
+/** Raw deflate (no zlib header). `level` 0 stores the data uncompressed. */
+declare function deflateRaw(data: Uint8Array, level?: 0 | 1): Uint8Array;
+/** zlib stream: header, raw deflate, Adler-32. */
+declare function deflate(data: Uint8Array, level?: 0 | 1): Uint8Array;
+
+export { type BlurEdge as B, CURVE_LUT_SIZE as C, DIRECT_GAUSSIAN_MAX_SIGMA as D, ZlibError as Z, type DecodedPng as a, adler32 as b, base64ToBytes as c, bytesToBase64 as d, curveLut as e, decodePng as f, deflate as g, deflateRaw as h, encodePng as i, gaussianBlur as j, inflate as k, inflateRaw as l, isPng as m, pngDataUrl as n, parseDataUrl as p };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixerate/editor",
-  "version": "0.113.0",
+  "version": "0.115.0",
   "description": "UI-agnostic rich text and media editing core library",
   "author": "Pixerate",
   "license": "MIT",
@@ -79,6 +79,11 @@
       "import": "./dist/raster/index.js",
       "require": "./dist/raster/index.cjs"
     },
+    "./cms": {
+      "types": "./dist/cms/index.d.ts",
+      "import": "./dist/cms/index.js",
+      "require": "./dist/cms/index.cjs"
+    },
     "./paint": {
       "types": "./dist/paint/index.d.ts",
       "import": "./dist/paint/index.js",
@@ -192,6 +197,7 @@
     "@types/dagre": "^0.7.54",
     "@types/markdown-it": "^14.2.0",
     "@types/node": "^26.6.5",
+    "assemblyscript": "0.28.20",
     "fast-check": "^3.23.2",
     "mermaid": "12.0.0",
     "tiptap-markdown": "^0.8.10",
@@ -213,6 +219,7 @@
     "build": "tsup",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
-    "test:corpus": "node scripts/fetch-psd-corpus.mjs && PSD_CORPUS=1 vitest run tests/psd-corpus.test.ts"
+    "test:corpus": "node scripts/fetch-psd-corpus.mjs && PSD_CORPUS=1 vitest run tests/psd-corpus.test.ts",
+    "build:wasm": "node scripts/build-wet-wasm.mjs"
   }
 }

package/skills/pixerate-image-editor/SKILL.md

@@ -183,6 +183,10 @@ drawing or editing either.
    false` and `cleanEachStroke: false`, start with `load_mixer_brush`, read the brush with
    `get_mixer_brush` when unsure, and reset it with `clean_mixer_brush`.
 
+### Colour management
+
+The working space, Assign / Convert to Profile with intents, soft proofing with a gamut warning
+and colour conversions for print briefs: read [references/color-management.md](references/color-management.md).
 ### Retouching
 
 Clone Stamp, Healing Brush, Spot Healing, Smudge, Dodge, Burn and Sponge: retouch on an empty
@@ -192,42 +196,9 @@ flaws and `clone_stamp` to copy exactly, and keep strokes short and soft. Read
 
 ### Photoshop files
 
-1. **Inspect before opening.** `inspect_psd` lists every layer with the type it would become and
-   a status: `mapped` (held exactly), `approximated` (type, fill and shape layers come in as their
-   stored pixels; linked smart objects as their stored pixels; Photoshop smart filters other than
-   Box Blur are kept but not drawn; Dissolve becomes Normal; effects with gradient midpoints or
-   smoothness, noise gradients, glow jitter, legacy bevels or patterns missing from the file are
-   drawn approximately) or
-   `dropped` (Brightness/Contrast, Exposure, Channel Mixer, Gradient Map, Selective Color and
-   Color Lookup adjustments). Tell the user what would be lost before `import_psd` when anything
-   is not `mapped`.
-2. **Layer effects come in live**: every Photoshop layer style maps to an effect you can read
-   with `list_layer_effects` and change as usual, with the file's patterns (listed in
-   `list_layer_effects.patterns`) and its global light. An effects block the editor cannot read
-   is kept and written back by `export_psd`, but not drawn; the warnings say so.
-3. **`import_psd` replaces the document** (one undo step). 16- and 32-bit files keep their
-   depth (`get_image_info.bitDepth`); CMYK, Lab, grayscale and indexed files are converted to RGB,
-   and ICC profiles are ignored; the warnings say so. `export_psd` writes at the document's depth.
-   Change it with `set_bit_depth`: 16-bit for smooth gradients and strong grades, 32-bit for
-   linear-light HDR (layers blend in linear light there). Adjustment layers, blend modes, merges
-   and the exported merged image keep the depth; layer effects, layer filters, painting and
-   transforms still work in 8 bits on what they change, so grade a deep file with adjustment
-   layers rather than repainting it when the depth matters. Afterwards work with `list_layers` as usual: there is no Background source image, every
-   pixel comes from the layers.
-4. **Smart objects come in live**: embedded contents (a PSB opens as a nested document you can
-   edit with `edit_smart_object_contents`, a PNG as raster contents), the placement and warp, the
-   smart filters and the filter mask; the layer shows Photoshop's own pixels until you change it.
-   JPEG, TIFF and SVG contents are decoded only in a browser, so elsewhere such a smart object
-   cannot be transformed (the error says so). Photoshop filters we do not model stay in the list
-   (kind `psd`): hide, reorder, re-blend or remove them, and `export_psd` writes them back.
-5. **`export_psd` writes the stack as it is**, in the source frame: crop and rotation are not
-   applied, layer filters and depth masks are baked, annotation layers are rasterized (only in
-   a browser). Effects are written as Photoshop layer styles: an effects block opened from a PSD
-   goes back byte for byte while its effects are unchanged, and the patterns effects use (the
-   built-in ones too) are embedded. Only the first outer glow, inner glow, bevel, satin and
-   pattern overlay of a layer fit in a PSD. Smart objects are written as smart objects (an
-   unchanged one byte for byte); a Develop smart filter has no Photoshop filter and is left out of
-   the list (the pixels still show it). Read its `warnings` and pass them on. The file comes back as base64 (`data`).
+`inspect_psd` before `import_psd`, then work with `list_layers`; `export_psd` writes the stack
+in the source frame at the document's bit depth, colour mode and profile. Read
+[references/photoshop-files.md](references/photoshop-files.md) before opening or saving a PSD.
 
 ## Best practices
 
@@ -403,6 +374,12 @@ flaws and `clone_stamp` to copy exactly, and keep strokes short and soft. Read
 | `get_mixer_brush` | Read-only. The Mixer Brush settings and what it carries (`reservoir` #rrggbb or null, `amount` left 0..1, `pickup` #rrggbb or null). Call it before a mixer stroke with `loadEachStroke: false`. |
 | `load_mixer_brush` | Fill the Mixer Brush reservoir with `color` (default the foreground), amount 1; keeps the pickup. View state, not an undo step. Use before strokes with `loadEachStroke: false`. Returns the load. |
 | `clean_mixer_brush` | Empty the Mixer Brush pickup well (`emptyReservoir: true` also drops the loaded paint, so it only smears). View state, not an undo step. Returns the load. |
+| `get_color_profile` | Read-only. The document's profile (`name`, `builtin` id or null, `colorSpace`, `srgb`), the Proof Setup or null, and the built-in profiles. |
+| `assign_profile` | Make the document's numbers mean colours in `profile` (built-in id or `icc:<base64>`; RGB only). The look changes, pixels do not. One undo step. Returns the profile. |
+| `convert_to_profile` | Convert pixel layers into `profile` keeping their look (`intent`, `bpc`), then assign it. One undo step. Returns the profile, `convertedLayerIds` and `unconvertedLayerIds` (shape, type, effects, smart objects). |
+| `set_proof_setup` | Soft-proof the viewport through `profile` (`intent`, `bpc`, `simulatePaper`, `gamutWarning`), or `off: true`. View state. Returns the setup. |
+| `set_color_mode` | Image › Mode: `rgb`, `cmyk` (with the press `profile`, default coated-cmyk, and the separation `intent`) or `lab`. Pixels stay RGB; CMYK documents proof through their profile and `export_psd` writes CMYK / Lab channels. One undo step. Returns the profile summary with `mode`. |
+| `convert_colors` | Read-only. `colors` #rrggbb from the document's profile (or `from`) to `to`: channel `values` 0..1 (CMYK, RGB, grey), `hex` for RGB, and `lab`. |
 | `clone_stamp` | Copy pixels from the clone source along `points`: each point paints what is at point + offset (source − first point, whole px). `source` `{x, y}` sets the source for this stroke (else the current one, see `set_clone_source`); `aligned` keeps the offset for later strokes; `sample` current \| current-below \| all; `brush` `{size, hardness, spacing, opacity, flow, smoothing, pressureSize, pressureOpacity}`; `layerId`, `channel` (a mask clones from itself). One undo step. Returns the layer, channel, `bounds`, dabs and `clone` `{offset, source, aligned}`. Call `set_clone_source` or pass `source` first. |
 | `heal_brush` | As `clone_stamp`, then blends the cloned texture into the colour and light around the stroke (Poisson seamless cloning, when the stroke ends). Use for blemishes, wrinkles, dust and seams where the surroundings have the right tone. Returns as `clone_stamp`. |
 | `spot_heal` | Remove what `points` cover with no source: `type` proximity-match (default: copies the best matching nearby patch, then heals it in) or smooth (fills from the edges). `sample`, `brush`, `layerId`, `channel`. One undo step. Returns the layer, channel, `bounds`, dabs and `spotHeal` `{offset}` (null for a smooth fill). |