@pixerate/editor 0.113.0 → 0.115.0

package/dist/{export-CEXEzqBf.d.cts → export-BJE8T0YA.d.cts}

@@ -1,10 +1,11 @@
-import { e as RasterLayerBase, f as RasterMask$1, b as RasterPixelLayer, G as GroupBlendMode, E as EffectFill, g as GlobalLight, h as EffectPattern, I as Interpolation, i as LayerLocation$1, L as LayerLocks, j as LayerEffect, k as LayerEffects, d as RasterSources, c as RasterCompositor, l as CompositorOptions, m as LayerEffectKind, n as EffectContext } from './render-BEriFuqK.cjs';
-import { b as PixelSurface, B as BlendMode, a as TiledSurface } from './surface-C8RRg_Bh.cjs';
+import { a2 as RasterLayerBase, a3 as RasterMask$1, a5 as RasterPixelLayer, H as GroupBlendMode, r as EffectFill, G as GlobalLight, u as EffectPattern, M as Interpolation, T as LayerLocation$1, U as LayerLocks, O as LayerEffect, S as LayerEffects, R as RasterSources, a as RasterCompositor, l as CompositorOptions, Q as LayerEffectKind, p as EffectContext, h as BitDepth } from './render-B1K_OoLy.cjs';
+import { c as PixelSurface, a as BlendMode, j as TiledSurface, R as RasterRect } from './surface-Cn30xIV6.cjs';
+import { b as BuiltinProfileId, j as Intent, P as Profile, T as Transform, d as ColorSpace } from './builtin-CY97ppKM.cjs';
 import { A as AffineMatrix, Q as Quad, a as WarpMesh, V as Vec2$1, H as Homography } from './types-CwMPoRMU.cjs';
 import { B as BezierPath } from './bezier-BfwIbVTl.cjs';
-import { v as VectorSubpath, n as Vec2 } from './types-DyQq-WPY.cjs';
-import { B as BrushSettings, M as MixerSettings, d as MixerLoad, f as RetouchSettings, g as StrokeCoverage, h as MixerTarget, i as MixerStroke, j as RetouchApply, c as StrokePoint, k as RetouchPaint, C as CoverageMap, P as PaintTileTarget, l as StrokeApply } from './retouch-CEIKR22W.cjs';
-import { W as WarpPreset } from './warp-D5jz_tN7.cjs';
+import { b as TextRun, P as ParagraphRun, T as TextShaper, c as ParagraphStyle, d as TextStyle, L as LaidFragment, W as WarpPreset, e as TextLayout } from './warp-B39VsOtd.cjs';
+import { w as VectorSubpath, o as Vec2 } from './types-yINF17Ta.cjs';
+import { B as BrushSettings, M as MixerSettings, d as MixerLoad, f as RetouchSettings, g as StrokeCoverage, h as MixerTarget, i as MixerStroke, j as RetouchApply, c as StrokePoint, k as RetouchPaint, C as CoverageMap, P as PaintTileTarget, l as StrokeApply } from './retouch-Bxkuc0KH.cjs';
 
 /**
  * A selection: one 8-bit coverage value per image pixel (0 = not selected, 255 = fully
@@ -325,58 +326,7 @@ interface ShapeLayer extends LayerBase {
     annotation?: Annotation;
     psd?: ShapePsdData;
 }
-/**
- * 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;
-}
+
 /** PSD data of a type layer kept for round trips (see the PSD module). */
 interface TypePsdData {
     /** The `TySh` block as read: written back while the layer is unchanged, else patched. */
@@ -584,6 +534,105 @@ declare function shapeLayers(layers: readonly ImageLayer[]): ShapeLayer[];
 /** Every smart object in the stack (nested contents not included). */
 declare function smartObjectLayers(layers: readonly ImageLayer[]): SmartObjectLayer[];
 
+/**
+ * Colour management for the image editor, on `@pixerate/editor/cms`:
+ *
+ * - The document has a colour profile (its working space): the colours its RGB pixels mean.
+ *   Missing means sRGB. Assign Profile changes that meaning and keeps the numbers; Convert to
+ *   Profile changes the numbers so the colours stay (with a rendering intent and black point
+ *   compensation).
+ * - The viewport assumes an sRGB display: a document in another space is converted for display,
+ *   and Proof Setup shows it as it would print or display through another profile (soft
+ *   proofing), optionally with a gamut warning.
+ * - Profiles travel with files: PSD image resource 1039, PNG `iCCP`, JPEG APP2.
+ */
+
+/** A document's colour profile: a built-in one by id, or embedded ICC bytes. */
+interface DocumentColorProfile {
+    /** A built-in profile (see `BUILTIN_PROFILES`). */
+    builtin?: BuiltinProfileId;
+    /** The profile's description. */
+    name: string;
+    /** ICC bytes of a profile that is not built in. */
+    icc?: Uint8Array;
+}
+/** View › Proof Setup (view state). */
+interface ProofSetup {
+    profile: DocumentColorProfile;
+    /** Rendering intent from the document to the proof profile (default relative). */
+    intent: Intent;
+    /** Black point compensation (default true). */
+    bpc: boolean;
+    /** Show the proof's paper white and ink black (absolute colorimetric to the display). */
+    simulatePaper: boolean;
+    /** Grey out colours the proof profile cannot reproduce (Gamut Warning). */
+    gamutWarning: boolean;
+}
+declare const DEFAULT_PROOF: Omit<ProofSetup, 'profile'>;
+/**
+ * Image › Mode beyond RGB. The document is still edited as RGB in its working space; the mode is
+ * what it is for: the viewport soft-proofs through the CMYK profile (unless Proof Setup says
+ * otherwise) and PSD export writes CMYK or Lab channels.
+ */
+type DocumentColorMode = {
+    mode: 'cmyk';
+    profile: DocumentColorProfile;
+    intent: Intent;
+} | {
+    mode: 'lab';
+};
+interface SerializedColorMode {
+    mode: 'cmyk' | 'lab';
+    profile?: SerializedColorProfile;
+    intent?: Intent;
+}
+declare function serializeColorMode(m: DocumentColorMode): SerializedColorMode;
+declare function deserializeColorMode(raw: unknown, problems: string[]): DocumentColorMode | null;
+/** The proof the viewport shows: Proof Setup, else a CMYK document's own profile. */
+declare function effectiveProof(proof: ProofSetup | null | undefined, mode: DocumentColorMode | null | undefined): ProofSetup | null;
+/**
+ * RGBA pixels (in the document profile `doc`) as the channel planes of `mode`, for a PSD:
+ * CMYK as Photoshop stores it (255 = no ink), Lab with L 0..255 for 0..100 and a, b offset by 128.
+ */
+declare function colorModePlanes(doc: DocumentColorProfile | null | undefined, mode: DocumentColorMode): (rgba: Uint8ClampedArray, n: number) => Uint8Array[];
+/** The profile a document profile names (sRGB when missing). Throws `CmsError` for unreadable ICC bytes. */
+declare function resolveProfile(doc: DocumentColorProfile | null | undefined): Profile;
+/** The ICC bytes to embed for a document profile. */
+declare function profileBytes(doc: DocumentColorProfile | null | undefined): Uint8Array;
+/**
+ * A document profile from what a user or agent gives: a built-in id or alias ("srgb",
+ * "display-p3", "Adobe RGB (1998)", "coated-cmyk", …) or ICC bytes. Throws with the choices.
+ */
+declare function documentProfile(input: string | Uint8Array): DocumentColorProfile;
+/** Whether a document profile means sRGB (so the display needs no conversion). */
+declare function isSrgb(doc: DocumentColorProfile | null | undefined): boolean;
+/** JSON form of a document profile. */
+interface SerializedColorProfile {
+    builtin?: BuiltinProfileId;
+    name: string;
+    /** ICC bytes, base64. */
+    icc?: string;
+}
+declare function serializeColorProfile(doc: DocumentColorProfile): SerializedColorProfile;
+/** A document profile from JSON, or `null` (with a problem noted) when it cannot be read. */
+declare function deserializeColorProfile(raw: unknown, problems: string[]): DocumentColorProfile | null;
+/** Applies a colour transform to 8-bit RGBA in place (alpha kept). */
+type PixelTransform = (rgba: Uint8ClampedArray) => void;
+/**
+ * What the viewport applies to the composite before showing it on an sRGB display: nothing for
+ * an sRGB document without proofing; the document → sRGB conversion; or the proof chain
+ * document → proof → sRGB, with out-of-gamut colours greyed when asked.
+ */
+declare function displayTransform(doc: DocumentColorProfile | null | undefined, proof: ProofSetup | null | undefined): PixelTransform | null;
+/** A `#rrggbb` colour converted between two profiles. */
+declare function convertHex(hex: string, from: Profile, to: Profile, intent?: Intent, bpc?: boolean): string;
+/**
+ * A layer surface with every pixel's colour converted through `t` (an RGB → RGB transform):
+ * 8-bit tiles through its tables, 16-bit tiles at 16 bits, 32-bit (linear) tiles through the
+ * float path. Alpha is kept.
+ */
+declare function convertSurfaceColors(surface: TiledSurface, t: Transform): TiledSurface;
+
 /**
  * Type layers: styled runs of text laid out as point or paragraph text and drawn into the layer's
  * `surface` by a text shaper.
@@ -597,43 +646,6 @@ declare function smartObjectLayers(layers: readonly ImageLayer[]): SmartObjectLa
  * and refuse edits that would need drawing them again.
  */
 
-/** 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[];
-}
 /** What rendering a type layer needs besides the layer. */
 interface TextEnv {
     width: number;
@@ -643,101 +655,6 @@ interface TextEnv {
     /** A 2D canvas for shapers that `draw` (the editor's renderer provides one). */
     createCanvas?(width: number, height: number): HTMLCanvasElement | OffscreenCanvas;
 }
-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: CropBox;
-    /** 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: Pick<TypeLayer, 'text' | 'runs' | 'paragraphs' | 'frame'>, 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;
-};
 /** How far beyond the canvas type renders (as shapes). */
 declare const TEXT_RENDER_MARGIN = 512;
 /** Text space → document of a layer. */
@@ -869,6 +786,20 @@ interface SerializedPixelLayer extends SerializedLayerBase {
     filters?: LayerFilter[];
     /** `'document'`: the pixels are the document's source image (no asset is stored). */
     source?: 'document';
+    /** 16- or 32-bit samples of the pixels (the PNG asset is their 8-bit rendering), see `raster/deep`. */
+    deep?: SerializedDeepPixels;
+}
+/**
+ * High bit depth pixels: `width × height` interleaved RGBA samples at (`x`, `y`) in layer space,
+ * little-endian (`Uint16` for 16-bit, `Float32` linear light for 32-bit), deflated and base64.
+ */
+interface SerializedDeepPixels {
+    depth: 16 | 32;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    data: string;
 }
 interface SerializedAdjustmentLayer extends SerializedLayerBase {
     type: 'adjustment';
@@ -1014,6 +945,12 @@ interface SerializedLayeredImageEditorState {
     patterns?: SerializedPattern[];
     /** Contents of the smart objects (nested ones included), each stored once. */
     smartContents?: SerializedSmartContents[];
+    /** The document's colour profile (missing = sRGB). */
+    colorProfile?: SerializedColorProfile;
+    /** Image › Mode CMYK or Lab (missing = RGB). */
+    colorMode?: SerializedColorMode;
+    /** Bits per channel (missing = 8). */
+    bitDepth?: 16 | 32;
 }
 interface SerializedPattern {
     id: string;
@@ -1030,6 +967,10 @@ interface EncodedSurface {
 }
 /** The surface's content (non-default pixels) as a PNG data URL and its position, or `null`. */
 declare function encodeSurface(surface: TiledSurface): EncodedSurface | null;
+/** A surface's deep samples over its content, or `null` when it holds only 8-bit tiles. */
+declare function encodeDeepSurface(surface: TiledSurface): SerializedDeepPixels | null;
+/** Puts serialized deep samples into `surface` (the 8-bit rendering read from the PNG); unreadable data leaves it 8-bit. */
+declare function decodeDeepSurface(surface: TiledSurface, raw: unknown, problems: string[], label: string): TiledSurface;
 interface SerializeContext {
     /** Adds an asset and returns its id. */
     addAsset(url: string, hint: string): string;
@@ -1186,6 +1127,12 @@ declare function runLayerFilters(data: Uint8ClampedArray, width: number, height:
 declare class LayerCompositor extends RasterCompositor<ImageLayer, CompositorSources> {
     constructor(options?: CompositorOptions);
 }
+/**
+ * The composite of an image editor stack at 16 or 32 bits (see `raster/deep-compositor`): float
+ * RGBA over `rect`, sRGB-encoded 0..1 at 16 bits, linear light at 32. Adjustment layers run in
+ * float; layers with effects or filters and annotation layers are drawn at 8 bits.
+ */
+declare function compositeDeep(layers: readonly ImageLayer[], rect: RasterRect, sources: CompositorSources, depth: 16 | 32): Float32Array;
 
 interface RenderOptions {
     viewportWidth?: number;
@@ -1286,6 +1233,11 @@ declare class ImageEditorRenderer {
     /** Which path the last base render took. */
     lastBaseRoute: 'legacy' | 'layers' | null;
     private comp;
+    /** Colour transform from the document to the display (see `color-management`), or none. */
+    private display;
+    private displayKey;
+    /** Sets the viewport's display transform (document profile → sRGB, or a soft proof); `null` for none. */
+    setDisplayTransform(t: PixelTransform | null): void;
     private depthMaps;
     private assetVersion;
     private scratch;
@@ -1960,6 +1912,17 @@ interface PsdImportResult {
         colorMode: string;
         channels: number;
     };
+    /** The embedded ICC profile (image resource 1039), raw bytes, when the file has one. */
+    iccProfile?: Uint8Array;
+    /** CMYK and Lab files: the mode (and CMYK profile) their pixels were converted from, to write them back. */
+    sourceMode?: {
+        mode: 'cmyk';
+        profile: DocumentColorProfile;
+    } | {
+        mode: 'lab';
+    };
+    /** The bits per channel the layers keep: 16 or 32 for such files (not indexed or bitmap), else 8. */
+    bitDepth: 8 | 16 | 32;
 }
 interface PsdImportOptions {
     /** Makes layer ids (defaults to `psd-<n>`). */
@@ -2866,6 +2829,9 @@ declare class ImageEditorController {
      */
     private pendingDirty;
     private notify;
+    private displayFor;
+    /** Keeps the renderer's display transform in step with the document profile, mode and Proof Setup. */
+    private syncDisplay;
     /** Recomputes the compatibility views (`adjustments`, `depthMask`, `annotations`) when the stack changed. */
     private syncViews;
     private stack;
@@ -3240,6 +3206,17 @@ declare class ImageEditorController {
     setGlobalLight(light: Partial<GlobalLight>, commitToHistory?: boolean): GlobalLight;
     /** Composites `layers` (in isolation) over `rect` into a surface, loading depth maps first. */
     private compositeToSurface;
+    /**
+     * The composite of the layer stack at the document's bit depth (as `compositePixels`, no
+     * canvas): 16-bit sRGB samples, or 32-bit linear float, over `rect` (default the canvas). At 8
+     * bits, the 8-bit composite widened to 16 bits.
+     */
+    compositeDeepPixels(rect?: CropBox): {
+        width: number;
+        height: number;
+        depth: 16 | 32;
+        data: Uint16Array | Float32Array;
+    };
     /** Document bounds a layer can paint into (pixel content, annotations, or the canvas for the rest). */
     private paintBounds;
     /**
@@ -3529,6 +3506,8 @@ declare class ImageEditorController {
         includeAnnotations?: boolean;
     }): Promise<HTMLCanvasElement | null>;
     toDataURL(options?: ExportOptions): Promise<string>;
+    /** PNG or JPEG bytes with the document's ICC profile embedded (other formats unchanged). */
+    private withEmbeddedProfile;
     toBlob(options?: ExportOptions): Promise<Blob>;
     renderMask(options?: {
         useAnnotations?: boolean;
@@ -3689,6 +3668,89 @@ declare class ImageEditorController {
      * step. Returns the layer id.
      */
     rasterizeLayer(id: string): Promise<string>;
+    /** The document's colour profile: its name, built-in id (or `null` for an embedded profile), colour space, and Image › Mode. */
+    getColorProfile(): {
+        name: string;
+        builtin: BuiltinProfileId | null;
+        colorSpace: ColorSpace;
+        srgb: boolean;
+        mode: 'rgb' | 'cmyk' | 'lab';
+        cmykProfile?: {
+            name: string;
+            builtin: BuiltinProfileId | null;
+            intent: Intent;
+        };
+    };
+    /**
+     * Image › Mode (one undo step): `rgb`, `cmyk` (with a CMYK `profile`, default the coated
+     * CMYK, and the `intent` RGB is separated with) or `lab`. The pixels stay RGB in the working
+     * space; a CMYK document is soft-proofed through its profile in the viewport, and PSD export
+     * writes CMYK or Lab channels. Returns the profile summary.
+     */
+    setColorMode(mode: 'rgb' | 'cmyk' | 'lab', options?: {
+        profile?: string | Uint8Array;
+        intent?: Intent;
+    }): ReturnType<ImageEditorController['getColorProfile']>;
+    /** Resolves a profile argument (built-in id or alias, or ICC bytes) as an RGB document profile. */
+    private rgbProfileArg;
+    /**
+     * Edit › Assign Profile (one undo step): the document's numbers now mean colours in
+     * `profile` (a built-in id such as `display-p3`, or ICC bytes); no pixel changes, so colours
+     * look different unless the profiles match. Returns the new profile.
+     */
+    assignProfile(profile: string | Uint8Array): ReturnType<ImageEditorController['getColorProfile']>;
+    /**
+     * Edit › Convert to Profile (one undo step): every pixel layer's numbers are converted so its
+     * colours stay the same in `profile` (with `intent` and black point compensation), and
+     * `profile` becomes the document's. Shape and type layers, layer effects and adjustment layers
+     * keep their numbers (they are listed in `unconvertedLayerIds`). Returns the profile and the
+     * layers changed.
+     */
+    convertToProfile(profile: string | Uint8Array, options?: {
+        intent?: Intent;
+        bpc?: boolean;
+    }): {
+        profile: ReturnType<ImageEditorController['getColorProfile']>;
+        convertedLayerIds: string[];
+        unconvertedLayerIds: string[];
+    };
+    /**
+     * View › Proof Setup (view state, not an undo step): shows the document as `profile` would
+     * reproduce it, or turns proofing off with `null`. Returns the setup.
+     */
+    setProofSetup(setup: (Partial<Omit<ProofSetup, 'profile'>> & {
+        profile: string | Uint8Array;
+    }) | null): ProofSetup | null;
+    /**
+     * Converts colours (`#rrggbb`) from one profile to another (default from the document's), with
+     * `intent`. For RGB targets returns hex; for others the channel values 0..1 (CMYK, grey, Lab
+     * encoded as L/100, (a+128)/255, (b+128)/255) and, for Lab, L*a*b*.
+     */
+    convertColors(colors: string[], to: string | Uint8Array, options?: {
+        from?: string | Uint8Array;
+        intent?: Intent;
+        bpc?: boolean;
+    }): Array<{
+        input: string;
+        values: number[];
+        hex?: string;
+        lab: [number, number, number];
+    }>;
+    /** The document's bits per channel (8 unless set to 16 or 32). */
+    get bitDepth(): BitDepth;
+    /**
+     * Image › Mode › 8 / 16 / 32 Bits/Channel (one undo step). Going up costs nothing: layers keep
+     * their pixels and read them at the new depth, and edits that understand depth keep the extra
+     * precision from then on. Going down rounds every pixel layer's deep samples to the new depth
+     * (8 bits: their 8-bit rendering; 32 → 16: colour above 1 is clipped). Returns the depth and
+     * the ids of the layers whose pixels changed.
+     */
+    setBitDepth(depth: BitDepth): {
+        bitDepth: BitDepth;
+        changedLayerIds: string[];
+    };
+    /** How `toPsd` writes colour: RGB with the working space, or CMYK / Lab channels for those modes. */
+    private psdColorOptions;
     /** Pixels per inch of the last opened PSD (written back by `toPsd`). */
     private psdResolution;
     /**
@@ -3710,7 +3772,7 @@ declare class ImageEditorController {
      */
     private checkPsdFonts;
     /**
-     * The document as an 8-bit RGB PSD (PSB above 30 000 px) with real layers, groups, adjustment
+     * The document as an RGB PSD at its bit depth (8, 16 or 32) (PSB above 30 000 px) with real layers, groups, adjustment
      * layers and masks, in the source frame. Layer filters and parametric (depth) masks are baked
      * into pixels and masks, annotation layers are rasterized (in a browser; elsewhere they are left
      * out), and the merged image is our composite. `warnings` lists every such change.
@@ -4031,6 +4093,7 @@ type ImageEditorTool = 'select' | 'crop' | 'pen' | 'rect' | 'circle' | 'arrow' |
 /** Live type layers, edited on the canvas (see `TypeToolGesture`). */
  | 'type';
 type ImageEditorFit = 'contain' | 'margin';
+
 interface ImageEditorState {
     sourceUrl: string | null;
     /** Canvas (document) size in pixels: the source image's natural size. */
@@ -4098,6 +4161,18 @@ interface ImageEditorState {
         layerId: string;
         name: string;
     }>;
+    /** The document's colour profile (working space); missing means sRGB. Recorded in history and saved. */
+    colorProfile?: DocumentColorProfile;
+    /** View › Proof Setup (view state): soft-proof the viewport through another profile, or `null`. */
+    proofSetup?: ProofSetup | null;
+    /** Image › Mode CMYK or Lab (missing: RGB): what the document is for (see `DocumentColorMode`). Recorded in history and saved. */
+    colorMode?: DocumentColorMode;
+    /**
+     * Bits per channel of the document (Image › Mode): 8 (missing), 16 or 32 (linear float).
+     * Pixel layers keep 16- or 32-bit samples where they have them (see `raster/deep`); the
+     * viewport shows their 8-bit rendering. Recorded in undo history and saved in `toJSON()`.
+     */
+    bitDepth?: BitDepth;
 }
 /**
  * A stored editor state in the document-level schema (versions 1 and 2). Documents whose layer
@@ -4181,6 +4256,19 @@ interface PsdExportInput {
     patterns?: readonly EffectPattern[];
     /** Written as image resources 1037 and 1049. */
     globalLight?: GlobalLight;
+    /**
+     * The file's colour mode (default rgb). For cmyk and lab, `colorPlanes` turns RGBA pixels into
+     * the mode's channel planes (CMYK as Photoshop stores it: 255 is no ink; Lab: L 0..255 for
+     * 0..100, a and b offset by 128).
+     */
+    colorMode?: 'rgb' | 'cmyk' | 'lab';
+    colorPlanes?: (rgba: Uint8ClampedArray, n: number) => Uint8Array[];
+    /** The document's ICC profile, written as image resource 1039. */
+    iccProfile?: Uint8Array;
+    /** Bits per channel to write (default 8): 16 and 32 write the layers' deep samples (see `raster/deep`). */
+    depth?: 8 | 16 | 32;
+    /** The composite at `depth` (RGBA samples: 16-bit sRGB or 32-bit linear), written instead of `merged`. */
+    mergedDeep?: Uint16Array | Float32Array;
 }
 interface PsdExportResult {
     bytes: Uint8Array;
@@ -4193,4 +4281,4 @@ interface PsdExportResult {
 /** Writes the prepared stack as PSD (or PSB) bytes. */
 declare function exportPsd(input: PsdExportInput): PsdExportResult;
 
-export { type FreeTransformResult as $, type AdjustmentKind as A, LayerCompositor as B, type CurvePoint as C, type DepthMaskOptions as D, type SmartFilterStack as E, type SmartFilter as F, type SmartObjectLayer as G, type HueRange as H, type ImageEditorAssetStore as I, type SmartContents as J, type SmartDocument as K, type LevelsChannel as L, type SmartPlacement as M, type FreeTransformGeometry as N, type TextShaper as O, type PsdExportResult as P, type TextFont as Q, type RefineEdgeParams as R, type SerializedLayer as S, type TextEnv as T, type LiveShapeKind as U, type TextAlign as V, type TextStyle as W, type ParagraphStyle as X, type TypeLayerInfo as Y, type LayerPlacement as Z, type FreeTransformMode as _, type ImageAdjustments as a, type LaidLine as a$, FreeTransformSession as a0, type FreeTransformInit as a1, type TransformAnchor as a2, type AIResultOptions as a3, type AdjustmentLayerBase as a4, type AdjustmentLayerInit as a5, type AdjustmentLayerUpdate as a6, type AnnotationPlacement as a7, type AnnotationType as a8, type ArrowAnnotation as a9, type FillOptions as aA, type FreeTransformContent as aB, type FreeTransformHost as aC, type FreeTransformPreview as aD, GUIDED_FILTER_EPS as aE, type GroupLayer as aF, HISTOGRAM_BINS as aG, type HistogramChannel as aH, type HistoryEntryHandle as aI, type HueSaturationParams as aJ, IMAGE_EDITOR_SCHEMA_VERSION as aK, type ImageAnnotation as aL, type ImageDimensions as aM, type ImageEditorAIHooks as aN, type ImageEditorFit as aO, type ImageEditorOptions as aP, ImageEditorRenderer as aQ, type ImageEditorState as aR, type ImageEditorTool as aS, type ImageLayerType as aT, type InpaintHook as aU, type InpaintOptions as aV, type InvertParams as aW, LAYERED_SCHEMA_VERSION as aX, LIVE_SHAPE_KINDS as aY, type LaidChar as aZ, type LaidFragment as a_, type AspectRatio as aa, type BaseAnnotation as ab, type BlackWhiteParams as ac, type BlurFilter as ad, type CircleAnnotation as ae, type CloneSource as af, type ColorBalanceParams as ag, type ColorBalanceTone as ah, type ColorRangeOptions as ai, type ColorRangeSample as aj, type CreateAnnotationPayload as ak, type CropHandle as al, type CurvesParams as am, DEFAULT_ADJUSTMENTS as an, DEFAULT_AUTO_LEADING as ao, DEFAULT_DEPTH_MASK as ap, DEFAULT_MITER_LIMIT as aq, DEFAULT_REFINE_EDGE_PARAMS as ar, DEFAULT_TEXT_STYLE as as, DEFAULT_TRANSFORM as at, type DeserializeContext as au, type DevelopSettings as av, EMPTY_DISTANCE as aw, type ExportOptions as ax, FREE_TRANSFORM_CONTENTS as ay, FREE_TRANSFORM_MODES as az, type SerializedImageEditorState as b, type SerializedRasterMask as b$, type LayerBase as b0, type LayerBlendMode as b1, type LayerFilterKind as b2, type LayerLocation as b3, type LayerMaskProps as b4, LayerOperationError as b5, type LayerProperties as b6, type LayerSourcesHost as b7, type LayerTarget as b8, type LegacySerializedImageEditorState as b9, type PsdResource as bA, type PsdSmartFilter as bB, type PsdTaggedBlock as bC, type PsdTreeNode as bD, RETOUCH_TOOLS as bE, type RectAnnotation as bF, type RemoveBackgroundHook as bG, type RemoveBackgroundOptions as bH, type RenderOptions as bI, type RetouchStrokeInit as bJ, type RetouchTool as bK, SELECTION_MODES as bL, SELECTION_MODIFY_OPS as bM, SHAPE_OPERATIONS as bN, SHAPE_RENDER_MARGIN as bO, type SampleOptions as bP, type SelectionChannel as bQ, type SelectionCommandOptions as bR, type SelectionModifyOp as bS, type SerializeContext as bT, type SerializedAdjustmentLayer as bU, type SerializedAnnotationLayer as bV, type SerializedGroupLayer as bW, type SerializedLayerEffects as bX, type SerializedLayeredImageEditorState as bY, type SerializedPattern as bZ, type SerializedPixelLayer as b_, type LevelsParams as ba, type LineAnnotation as bb, type LiveShape as bc, type MagicWandOptions as bd, type MixerStrokeInit as be, PARAGRAPH_STYLE_FIELDS as bf, PSD_BLEND_KEYS as bg, type PaintOptions as bh, type PaintStrokeResult as bi, PaintStrokeSession as bj, type ParagraphRun as bk, type PenAnnotation as bl, type PhotoFilterParams as bm, type PixelBuffer as bn, type PixelLayerInit as bo, type PosterizeParams as bp, type PsdChannel as bq, type PsdExportInput as br, type PsdFile as bs, type PsdHeader as bt, type PsdImportOptions as bu, type PsdImportResult as bv, type PsdLayerMask as bw, type PsdLayerRecord as bx, type PsdLayerSummary as by, type PsdRect as bz, type AdjustmentLayer as c, colorRange as c$, type SerializedSelection as c0, type SerializedShapeLayer as c1, type SerializedSmartContents as c2, type SerializedSmartFilter as c3, type SerializedSmartObjectLayer as c4, type SerializedTypeLayer as c5, type ShapeArrowhead as c6, type ShapeComponent as c7, type ShapeEnv as c8, type ShapeFillRule as c9, type TextRun as cA, type ThresholdParams as cB, type ToneRangePreset as cC, type TransformParams as cD, type TransformReadout as cE, type TypeLayerData as cF, type TypePsdData as cG, type VibranceParams as cH, type ViewportMetrics as cI, addLayerEffect as cJ, addLayerFilter as cK, adjustmentNodeAsLayer as cL, anchorPoint as cM, annotationBlend as cN, annotationOfShape as cO, annotationOfType as cP, applyImageProjectionToContext as cQ, applyParams as cR, blurFilter as cS, borderCoverage as cT, boxMean as cU, boxPointOf as cV, buildLayerMaskPlanes as cW, calculateCropDrag as cX, canvasToImagePoint as cY, caretAt as cZ, clampCropToImage as c_, type ShapeGeometryInput as ca, type ShapeLayerData as cb, type ShapeLayerInfo as cc, type ShapeLayerInit as cd, type ShapeLineCap as ce, type ShapeLineJoin as cf, type ShapeOperation as cg, type ShapePaint as ch, type ShapePsdData as ci, type ShapeSelectionOptions as cj, type ShapeStroke as ck, type ShapeStrokeAlign as cl, type ShapeStrokeInput as cm, type SmartFilterKind as cn, type SmartObjectInfo as co, type SmartPsdData as cp, type StrokeInit as cq, type StrokeTool as cr, TEXT_ALIGNS as cs, TEXT_RENDER_MARGIN as ct, TEXT_STYLE_FIELDS as cu, TONE_RANGE_PRESETS as cv, TRANSFORM_ANCHORS as cw, type TextAnnotation as cx, type TextLayerInit as cy, type TextLayout as cz, type AdjustmentParamsMap as d, isIdentityTransform as d$, combineSelections as d0, componentPath as d1, computeHistogram as d2, computeSelectionBounds as d3, contractCoverage as d4, cornersFromMatrix as d5, coverageToByte as d6, createSelectionMask as d7, createShapeLayer as d8, createTypeLayer as d9, fitRuns as dA, flipCorners as dB, fontOf as dC, fullSelection as dD, geometryHomography as dE, getAnnotationBounds as dF, getCropCursor as dG, getRotatedSize as dH, getViewportMetrics as dI, getViewportProjection as dJ, globalImageCache as dK, greyMorphology as dL, groupLayers as dM, guidePlanes as dN, guidedFilterColor as dO, hasSurface as dP, hasWarp as dQ, hashMaskContent as dR, histogramPath as dS, hitTestAnnotation as dT, hitTestCrop as dU, hueRange as dV, identityTransform as dW, imageToCanvasPoint as dX, importPsd as dY, invertSelection as dZ, isActiveFilter as d_, decodeLayerChannel as da, decodeLayerMask as db, decodeMergedImage as dc, decodePngDataUrl as dd, decodeSelectionRle as de, defaultShapeName as df, depthMaskAlpha as dg, describeTransform as dh, deserializeEffects as di, deserializeLayer as dj, deserializeLayers as dk, deserializePatterns as dl, deserializeSelection as dm, developFilter as dn, distanceTransform as dp, duplicateLayer as dq, edgeWidth as dr, ellipsePoints as ds, ellipseSelection as dt, encodeSelectionRle as du, encodeSurface as dv, expandCoverage as dw, exportPsd as dx, featherCoverage as dy, fitParagraphRuns as dz, type AdjustmentLayerMask as e, refineEdgeHalo as e$, isQuarterTurnSwapped as e0, isRenderedLayer as e1, isRetouchTool as e2, isSelectionEmpty as e3, isSelectionMode as e4, isSpatialFilter as e5, isTransformAnchor as e6, isValidWarp as e7, layerEffectsOf as e8, layerMaskCoverage as e9, normalizeShapeStroke as eA, normalizeStoredAdjustments as eB, normalizeSubpaths as eC, normalizeText as eD, offsetLayer as eE, offsetShape as eF, paragraphRanges as eG, parseBlend as eH, parseColor as eI, parseSelectionMode as eJ, patchParagraphStyle as eK, patchTextStyle as eL, pixelLayerBounds as eM, pixelLayers as eN, placeLayer as eO, polygonCoverage as eP, polygonSelection as eQ, presetWarp as eR, previewStep as eS, projectImagePoint as eT, projectImageRect as eU, projectMaskCoverage as eV, psdToLayers as eW, readPsd as eX, rectSelection as eY, referencePoint as eZ, refineCoverage as e_, layerMaskFromSelection as ea, layerMaskKey as eb, layerName as ec, layerTree as ed, layerTypeLabel as ee, layoutText as ef, liveComponent as eg, liveShapeSubpaths as eh, magicWand as ei, mapCropHandle as ej, mapSubpaths as ek, matrixFromCorners as el, matrixFromParams as em, mergeShapeComponents as en, migrateSerializedImageEditorState as eo, migrateToLayeredState as ep, modifySelection as eq, moveLayer as er, newLayerId as es, normalizeAngle as et, normalizeFilter as eu, normalizeLayerMask as ev, normalizeLiveShape as ew, normalizeRect as ex, normalizeRefineEdgeParams as ey, normalizeShapePaint as ez, type AdjustmentLayerOf as f, typeFrame as f$, refineSelection as f0, removeLayer as f1, removeLayerEffect as f2, removeLayerFilter as f3, renderShape as f4, renderShapeRect as f5, renderText as f6, replaceTextRange as f7, requireLayer as f8, requireOperation as f9, setLayerProperties as fA, shapeAsPixelLayer as fB, shapeFromAnnotation as fC, shapeGeometryBounds as fD, shapeLayers as fE, shapeOutline as fF, shapeRenderClip as fG, shiftCoverage as fH, smartObjectLayers as fI, smoothCoverage as fJ, spliceRuns as fK, srgb8ToLab as fL, styleAt as fM, textIndexAt as fN, textMatrix as fO, textOutlines as fP, textRange as fQ, toHex as fR, toTextSpace as fS, toneRange as fT, transformHomography as fU, transformMap as fV, transformShapeComponents as fW, transformTypeLayer as fX, transformedBox as fY, transformedPoint as fZ, typeAsPixelLayer as f_, requireShapeLayer as fa, requireTypeLayer as fb, requireUnlocked as fc, rerenderShape as fd, rerenderText as fe, resizePixels as ff, resizeSelection as fg, resolveExternalAssets as fh, restyleRange as fi, runLayerFilters as fj, selectionArea as fk, selectionFromCoverage as fl, selectionFromPixels as fm, selectionToCoverage as fn, selectionToPixels as fo, selectionValueAt as fp, serializeContents as fq, serializeEffects as fr, serializeLayer as fs, serializeLayers as ft, serializeLayersExternal as fu, serializePatterns as fv, serializeSelection as fw, setLayerEffects as fx, setLayerEffectsEnabled as fy, setLayerMask as fz, ImageEditorController as g, typeFromAnnotation as g0, typeLayerName as g1, ungroupLayer as g2, unionRect as g3, unprojectCanvasPoint as g4, updateLayerEffect as g5, updateLayerFilter as g6, updateLayerMaskProps as g7, updateShapeLayer as g8, updateTypeLayer as g9, withNewIds as ga, writePsd as gb, type SelectionMask as h, type SelectionMode as i, type ColorDistance as j, type ImagePoint as k, type ImageLayer as l, type CropBox as m, type RasterMask as n, type Annotation as o, type AdjustmentLayerNode as p, type AnnotationLayer as q, type ShapeLayer as r, type TypeLayer as s, type LayerFilter as t, type PixelLayer as u, type DevelopFilter as v, type ImageTransform as w, type ImageHistogram as x, type ImageProjection as y, type CompositorSources as z };
+export { type AdjustmentLayerBase as $, type AdjustmentKind as A, LayerCompositor as B, type CurvePoint as C, type DepthMaskOptions as D, type SmartFilterStack as E, type SmartFilter as F, type SmartObjectLayer as G, type HueRange as H, type ImageEditorAssetStore as I, type SmartContents as J, type SmartDocument as K, type LevelsChannel as L, type SmartPlacement as M, type FreeTransformGeometry as N, type LiveShapeKind as O, type PsdExportResult as P, type TypeLayerInfo as Q, type RefineEdgeParams as R, type SerializedLayer as S, type TextEnv as T, type LayerPlacement as U, type FreeTransformMode as V, type FreeTransformResult as W, FreeTransformSession as X, type FreeTransformInit as Y, type TransformAnchor as Z, type AIResultOptions as _, type ImageAdjustments as a, type LayerProperties as a$, type AdjustmentLayerInit as a0, type AdjustmentLayerUpdate as a1, type AnnotationPlacement as a2, type AnnotationType as a3, type ArrowAnnotation as a4, type AspectRatio as a5, type BaseAnnotation as a6, type BlackWhiteParams as a7, type BlurFilter as a8, type CircleAnnotation as a9, GUIDED_FILTER_EPS as aA, type GroupLayer as aB, HISTOGRAM_BINS as aC, type HistogramChannel as aD, type HistoryEntryHandle as aE, type HueSaturationParams as aF, IMAGE_EDITOR_SCHEMA_VERSION as aG, type ImageAnnotation as aH, type ImageDimensions as aI, type ImageEditorAIHooks as aJ, type ImageEditorFit as aK, type ImageEditorOptions as aL, ImageEditorRenderer as aM, type ImageEditorState as aN, type ImageEditorTool as aO, type ImageLayerType as aP, type InpaintHook as aQ, type InpaintOptions as aR, type InvertParams as aS, LAYERED_SCHEMA_VERSION as aT, LIVE_SHAPE_KINDS as aU, type LayerBase as aV, type LayerBlendMode as aW, type LayerFilterKind as aX, type LayerLocation as aY, type LayerMaskProps as aZ, LayerOperationError as a_, type CloneSource as aa, type ColorBalanceParams as ab, type ColorBalanceTone as ac, type ColorRangeOptions as ad, type ColorRangeSample as ae, type CreateAnnotationPayload as af, type CropHandle as ag, type CurvesParams as ah, DEFAULT_ADJUSTMENTS as ai, DEFAULT_DEPTH_MASK as aj, DEFAULT_MITER_LIMIT as ak, DEFAULT_PROOF as al, DEFAULT_REFINE_EDGE_PARAMS as am, DEFAULT_TRANSFORM as an, type DeserializeContext as ao, type DevelopSettings as ap, type DocumentColorMode as aq, type DocumentColorProfile as ar, EMPTY_DISTANCE as as, type ExportOptions as at, FREE_TRANSFORM_CONTENTS as au, FREE_TRANSFORM_MODES as av, type FillOptions as aw, type FreeTransformContent as ax, type FreeTransformHost as ay, type FreeTransformPreview as az, type SerializedImageEditorState as b, type SerializedSmartContents as b$, type LayerSourcesHost as b0, type LayerTarget as b1, type LegacySerializedImageEditorState as b2, type LevelsParams as b3, type LineAnnotation as b4, type LiveShape as b5, type MagicWandOptions as b6, type MixerStrokeInit as b7, PARAGRAPH_STYLE_FIELDS as b8, PSD_BLEND_KEYS as b9, type RemoveBackgroundHook as bA, type RemoveBackgroundOptions as bB, type RenderOptions as bC, type RetouchStrokeInit as bD, type RetouchTool as bE, SELECTION_MODES as bF, SELECTION_MODIFY_OPS as bG, SHAPE_OPERATIONS as bH, SHAPE_RENDER_MARGIN as bI, type SampleOptions as bJ, type SelectionChannel as bK, type SelectionCommandOptions as bL, type SelectionModifyOp as bM, type SerializeContext as bN, type SerializedAdjustmentLayer as bO, type SerializedAnnotationLayer as bP, type SerializedColorMode as bQ, type SerializedColorProfile as bR, type SerializedDeepPixels as bS, type SerializedGroupLayer as bT, type SerializedLayerEffects as bU, type SerializedLayeredImageEditorState as bV, type SerializedPattern as bW, type SerializedPixelLayer as bX, type SerializedRasterMask as bY, type SerializedSelection as bZ, type SerializedShapeLayer as b_, type PaintOptions as ba, type PaintStrokeResult as bb, PaintStrokeSession as bc, type PenAnnotation as bd, type PhotoFilterParams as be, type PixelBuffer as bf, type PixelLayerInit as bg, type PixelTransform as bh, type PosterizeParams as bi, type ProofSetup as bj, type PsdChannel as bk, type PsdExportInput as bl, type PsdFile as bm, type PsdHeader as bn, type PsdImportOptions as bo, type PsdImportResult as bp, type PsdLayerMask as bq, type PsdLayerRecord as br, type PsdLayerSummary as bs, type PsdRect as bt, type PsdResource as bu, type PsdSmartFilter as bv, type PsdTaggedBlock as bw, type PsdTreeNode as bx, RETOUCH_TOOLS as by, type RectAnnotation as bz, type AdjustmentLayer as c, contractCoverage as c$, type SerializedSmartFilter as c0, type SerializedSmartObjectLayer as c1, type SerializedTypeLayer as c2, type ShapeArrowhead as c3, type ShapeComponent as c4, type ShapeEnv as c5, type ShapeFillRule as c6, type ShapeGeometryInput as c7, type ShapeLayerData as c8, type ShapeLayerInfo as c9, type TypePsdData as cA, type VibranceParams as cB, type ViewportMetrics as cC, addLayerEffect as cD, addLayerFilter as cE, adjustmentNodeAsLayer as cF, anchorPoint as cG, annotationBlend as cH, annotationOfShape as cI, annotationOfType as cJ, applyImageProjectionToContext as cK, applyParams as cL, blurFilter as cM, borderCoverage as cN, boxMean as cO, boxPointOf as cP, buildLayerMaskPlanes as cQ, calculateCropDrag as cR, canvasToImagePoint as cS, clampCropToImage as cT, colorModePlanes as cU, colorRange as cV, combineSelections as cW, componentPath as cX, compositeDeep as cY, computeHistogram as cZ, computeSelectionBounds as c_, type ShapeLayerInit as ca, type ShapeLineCap as cb, type ShapeLineJoin as cc, type ShapeOperation as cd, type ShapePaint as ce, type ShapePsdData as cf, type ShapeSelectionOptions as cg, type ShapeStroke as ch, type ShapeStrokeAlign as ci, type ShapeStrokeInput as cj, type SmartFilterKind as ck, type SmartObjectInfo as cl, type SmartPsdData as cm, type StrokeInit as cn, type StrokeTool as co, TEXT_RENDER_MARGIN as cp, TEXT_STYLE_FIELDS as cq, TONE_RANGE_PRESETS as cr, TRANSFORM_ANCHORS as cs, type TextAnnotation as ct, type TextLayerInit as cu, type ThresholdParams as cv, type ToneRangePreset as cw, type TransformParams as cx, type TransformReadout as cy, type TypeLayerData as cz, type AdjustmentParamsMap as d, isActiveFilter as d$, convertHex as d0, convertSurfaceColors as d1, cornersFromMatrix as d2, coverageToByte as d3, createSelectionMask as d4, createShapeLayer as d5, createTypeLayer as d6, decodeDeepSurface as d7, decodeLayerChannel as d8, decodeLayerMask as d9, expandCoverage as dA, exportPsd as dB, featherCoverage as dC, flipCorners as dD, fullSelection as dE, geometryHomography as dF, getAnnotationBounds as dG, getCropCursor as dH, getRotatedSize as dI, getViewportMetrics as dJ, getViewportProjection as dK, globalImageCache as dL, greyMorphology as dM, groupLayers as dN, guidePlanes as dO, guidedFilterColor as dP, hasSurface as dQ, hasWarp as dR, hashMaskContent as dS, histogramPath as dT, hitTestAnnotation as dU, hitTestCrop as dV, hueRange as dW, identityTransform as dX, imageToCanvasPoint as dY, importPsd as dZ, invertSelection as d_, decodeMergedImage as da, decodePngDataUrl as db, decodeSelectionRle as dc, defaultShapeName as dd, depthMaskAlpha as de, describeTransform as df, deserializeColorMode as dg, deserializeColorProfile as dh, deserializeEffects as di, deserializeLayer as dj, deserializeLayers as dk, deserializePatterns as dl, deserializeSelection as dm, developFilter as dn, displayTransform as dp, distanceTransform as dq, documentProfile as dr, duplicateLayer as ds, edgeWidth as dt, effectiveProof as du, ellipsePoints as dv, ellipseSelection as dw, encodeDeepSurface as dx, encodeSelectionRle as dy, encodeSurface as dz, type AdjustmentLayerMask as e, refineCoverage as e$, isIdentityTransform as e0, isQuarterTurnSwapped as e1, isRenderedLayer as e2, isRetouchTool as e3, isSelectionEmpty as e4, isSelectionMode as e5, isSpatialFilter as e6, isSrgb as e7, isTransformAnchor as e8, isValidWarp as e9, normalizeShapePaint as eA, normalizeShapeStroke as eB, normalizeStoredAdjustments as eC, normalizeSubpaths as eD, normalizeText as eE, offsetLayer as eF, offsetShape as eG, parseBlend as eH, parseColor as eI, parseSelectionMode as eJ, patchParagraphStyle as eK, patchTextStyle as eL, pixelLayerBounds as eM, pixelLayers as eN, placeLayer as eO, polygonCoverage as eP, polygonSelection as eQ, presetWarp as eR, previewStep as eS, profileBytes as eT, projectImagePoint as eU, projectImageRect as eV, projectMaskCoverage as eW, psdToLayers as eX, readPsd as eY, rectSelection as eZ, referencePoint as e_, layerEffectsOf as ea, layerMaskCoverage as eb, layerMaskFromSelection as ec, layerMaskKey as ed, layerName as ee, layerTree as ef, layerTypeLabel as eg, liveComponent as eh, liveShapeSubpaths as ei, magicWand as ej, mapCropHandle as ek, mapSubpaths as el, matrixFromCorners as em, matrixFromParams as en, mergeShapeComponents as eo, migrateSerializedImageEditorState as ep, migrateToLayeredState as eq, modifySelection as er, moveLayer as es, newLayerId as et, normalizeAngle as eu, normalizeFilter as ev, normalizeLayerMask as ew, normalizeLiveShape as ex, normalizeRect as ey, normalizeRefineEdgeParams as ez, type AdjustmentLayerOf as f, typeFrame as f$, refineEdgeHalo as f0, refineSelection as f1, removeLayer as f2, removeLayerEffect as f3, removeLayerFilter as f4, renderShape as f5, renderShapeRect as f6, renderText as f7, replaceTextRange as f8, requireLayer as f9, setLayerEffects as fA, setLayerEffectsEnabled as fB, setLayerMask as fC, setLayerProperties as fD, shapeAsPixelLayer as fE, shapeFromAnnotation as fF, shapeGeometryBounds as fG, shapeLayers as fH, shapeOutline as fI, shapeRenderClip as fJ, shiftCoverage as fK, smartObjectLayers as fL, smoothCoverage as fM, srgb8ToLab as fN, textMatrix as fO, textOutlines as fP, textRange as fQ, toHex as fR, toTextSpace as fS, toneRange as fT, transformHomography as fU, transformMap as fV, transformShapeComponents as fW, transformTypeLayer as fX, transformedBox as fY, transformedPoint as fZ, typeAsPixelLayer as f_, requireOperation as fa, requireShapeLayer as fb, requireTypeLayer as fc, requireUnlocked as fd, rerenderShape as fe, rerenderText as ff, resizePixels as fg, resizeSelection as fh, resolveExternalAssets as fi, resolveProfile as fj, runLayerFilters as fk, selectionArea as fl, selectionFromCoverage as fm, selectionFromPixels as fn, selectionToCoverage as fo, selectionToPixels as fp, selectionValueAt as fq, serializeColorMode as fr, serializeColorProfile as fs, serializeContents as ft, serializeEffects as fu, serializeLayer as fv, serializeLayers as fw, serializeLayersExternal as fx, serializePatterns as fy, serializeSelection as fz, ImageEditorController as g, typeFromAnnotation as g0, typeLayerName as g1, ungroupLayer as g2, unionRect as g3, unprojectCanvasPoint as g4, updateLayerEffect as g5, updateLayerFilter as g6, updateLayerMaskProps as g7, updateShapeLayer as g8, updateTypeLayer as g9, withNewIds as ga, writePsd as gb, type SelectionMask as h, type SelectionMode as i, type ColorDistance as j, type ImagePoint as k, type ImageLayer as l, type CropBox as m, type RasterMask as n, type Annotation as o, type AdjustmentLayerNode as p, type AnnotationLayer as q, type ShapeLayer as r, type TypeLayer as s, type LayerFilter as t, type PixelLayer as u, type DevelopFilter as v, type ImageTransform as w, type ImageHistogram as x, type ImageProjection as y, type CompositorSources as z };