@pixerate/editor 0.112.0 → 0.114.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.112.0",
+  "version": "0.114.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",