@pixerate/editor 0.113.0 → 0.114.0

package/dist/{export-DIkoK8-r.d.ts → export-_1dUKwpF.d.ts}

@@ -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-tjzKaik-.js';
-import { b as PixelSurface, B as BlendMode, a as TiledSurface } from './surface-C8RRg_Bh.js';
+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-CrmHOgpo.js';
+import { c as PixelSurface, a as BlendMode, j as TiledSurface, R as RasterRect } from './surface-Cn30xIV6.js';
+import { b as BuiltinProfileId, j as Intent, P as Profile, T as Transform, d as ColorSpace } from './builtin-CY97ppKM.js';
 import { A as AffineMatrix, Q as Quad, a as WarpMesh, V as Vec2$1, H as Homography } from './types-CwMPoRMU.js';
 import { B as BezierPath } from './bezier-DYBvLgUH.js';
-import { v as VectorSubpath, n as Vec2 } from './types-DtL_qLFz.js';
-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-BXmeSCaB.js';
-import { W as WarpPreset } from './warp-CWHZzE3x.js';
+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-DMN30aY6.js';
+import { w as VectorSubpath, o as Vec2 } from './types-1SUQKDAw.js';
+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-Do6tBs2H.js';
 
 /**
  * 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,79 @@ 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'>;
+/** 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 +620,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 +629,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 +760,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 +919,10 @@ 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;
+    /** Bits per channel (missing = 8). */
+    bitDepth?: 16 | 32;
 }
 interface SerializedPattern {
     id: string;
@@ -1030,6 +939,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 +1099,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 +1205,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 +1884,10 @@ interface PsdImportResult {
         colorMode: string;
         channels: number;
     };
+    /** The embedded ICC profile (image resource 1039), raw bytes, when the file has one. */
+    iccProfile?: Uint8Array;
+    /** 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 +2794,9 @@ declare class ImageEditorController {
      */
     private pendingDirty;
     private notify;
+    private displayFor;
+    /** Keeps the renderer's display transform in step with the document profile and Proof Setup. */
+    private syncDisplay;
     /** Recomputes the compatibility views (`adjustments`, `depthMask`, `annotations`) when the stack changed. */
     private syncViews;
     private stack;
@@ -3240,6 +3171,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 +3471,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 +3633,71 @@ 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) and colour space. */
+    getColorProfile(): {
+        name: string;
+        builtin: BuiltinProfileId | null;
+        colorSpace: ColorSpace;
+        srgb: boolean;
+    };
+    /** 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[];
+    };
     /** Pixels per inch of the last opened PSD (written back by `toPsd`). */
     private psdResolution;
     /**
@@ -3710,7 +3719,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 +4040,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 +4108,16 @@ 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;
+    /**
+     * 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 +4201,12 @@ interface PsdExportInput {
     patterns?: readonly EffectPattern[];
     /** Written as image resources 1037 and 1049. */
     globalLight?: GlobalLight;
+    /** 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 +4219,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 LayerSourcesHost 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, type GroupLayer as aA, HISTOGRAM_BINS as aB, type HistogramChannel as aC, type HistoryEntryHandle as aD, type HueSaturationParams as aE, IMAGE_EDITOR_SCHEMA_VERSION as aF, type ImageAnnotation as aG, type ImageDimensions as aH, type ImageEditorAIHooks as aI, type ImageEditorFit as aJ, type ImageEditorOptions as aK, ImageEditorRenderer as aL, type ImageEditorState as aM, type ImageEditorTool as aN, type ImageLayerType as aO, type InpaintHook as aP, type InpaintOptions as aQ, type InvertParams as aR, LAYERED_SCHEMA_VERSION as aS, LIVE_SHAPE_KINDS as aT, type LayerBase as aU, type LayerBlendMode as aV, type LayerFilterKind as aW, type LayerLocation as aX, type LayerMaskProps as aY, LayerOperationError as aZ, type LayerProperties 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 DocumentColorProfile as aq, EMPTY_DISTANCE as ar, type ExportOptions as as, FREE_TRANSFORM_CONTENTS as at, FREE_TRANSFORM_MODES as au, type FillOptions as av, type FreeTransformContent as aw, type FreeTransformHost as ax, type FreeTransformPreview as ay, GUIDED_FILTER_EPS as az, type SerializedImageEditorState as b, type SerializedSmartObjectLayer as b$, type LayerTarget as b0, type LegacySerializedImageEditorState as b1, type LevelsParams as b2, type LineAnnotation as b3, type LiveShape as b4, type MagicWandOptions as b5, type MixerStrokeInit as b6, PARAGRAPH_STYLE_FIELDS as b7, PSD_BLEND_KEYS as b8, type PaintOptions as b9, type RemoveBackgroundOptions as bA, type RenderOptions as bB, type RetouchStrokeInit as bC, type RetouchTool as bD, SELECTION_MODES as bE, SELECTION_MODIFY_OPS as bF, SHAPE_OPERATIONS as bG, SHAPE_RENDER_MARGIN as bH, type SampleOptions as bI, type SelectionChannel as bJ, type SelectionCommandOptions as bK, type SelectionModifyOp as bL, type SerializeContext as bM, type SerializedAdjustmentLayer as bN, type SerializedAnnotationLayer as bO, type SerializedColorProfile as bP, type SerializedDeepPixels as bQ, type SerializedGroupLayer as bR, type SerializedLayerEffects as bS, type SerializedLayeredImageEditorState as bT, type SerializedPattern as bU, type SerializedPixelLayer as bV, type SerializedRasterMask as bW, type SerializedSelection as bX, type SerializedShapeLayer as bY, type SerializedSmartContents as bZ, type SerializedSmartFilter as b_, type PaintStrokeResult as ba, PaintStrokeSession as bb, type PenAnnotation as bc, type PhotoFilterParams as bd, type PixelBuffer as be, type PixelLayerInit as bf, type PixelTransform as bg, type PosterizeParams as bh, type ProofSetup as bi, type PsdChannel as bj, type PsdExportInput as bk, type PsdFile as bl, type PsdHeader as bm, type PsdImportOptions as bn, type PsdImportResult as bo, type PsdLayerMask as bp, type PsdLayerRecord as bq, type PsdLayerSummary as br, type PsdRect as bs, type PsdResource as bt, type PsdSmartFilter as bu, type PsdTaggedBlock as bv, type PsdTreeNode as bw, RETOUCH_TOOLS as bx, type RectAnnotation as by, type RemoveBackgroundHook as bz, type AdjustmentLayer as c, cornersFromMatrix as c$, type SerializedTypeLayer as c0, type ShapeArrowhead as c1, type ShapeComponent as c2, type ShapeEnv as c3, type ShapeFillRule as c4, type ShapeGeometryInput as c5, type ShapeLayerData as c6, type ShapeLayerInfo as c7, type ShapeLayerInit as c8, type ShapeLineCap as c9, type ViewportMetrics as cA, addLayerEffect as cB, addLayerFilter as cC, adjustmentNodeAsLayer as cD, anchorPoint as cE, annotationBlend as cF, annotationOfShape as cG, annotationOfType as cH, applyImageProjectionToContext as cI, applyParams as cJ, blurFilter as cK, borderCoverage as cL, boxMean as cM, boxPointOf as cN, buildLayerMaskPlanes as cO, calculateCropDrag as cP, canvasToImagePoint as cQ, clampCropToImage as cR, colorRange as cS, combineSelections as cT, componentPath as cU, compositeDeep as cV, computeHistogram as cW, computeSelectionBounds as cX, contractCoverage as cY, convertHex as cZ, convertSurfaceColors as c_, type ShapeLineJoin as ca, type ShapeOperation as cb, type ShapePaint as cc, type ShapePsdData as cd, type ShapeSelectionOptions as ce, type ShapeStroke as cf, type ShapeStrokeAlign as cg, type ShapeStrokeInput as ch, type SmartFilterKind as ci, type SmartObjectInfo as cj, type SmartPsdData as ck, type StrokeInit as cl, type StrokeTool as cm, TEXT_RENDER_MARGIN as cn, TEXT_STYLE_FIELDS as co, TONE_RANGE_PRESETS as cp, TRANSFORM_ANCHORS as cq, type TextAnnotation as cr, type TextLayerInit as cs, type ThresholdParams as ct, type ToneRangePreset as cu, type TransformParams as cv, type TransformReadout as cw, type TypeLayerData as cx, type TypePsdData as cy, type VibranceParams as cz, type AdjustmentParamsMap as d, isSelectionEmpty as d$, coverageToByte as d0, createSelectionMask as d1, createShapeLayer as d2, createTypeLayer as d3, decodeDeepSurface as d4, decodeLayerChannel as d5, decodeLayerMask as d6, decodeMergedImage as d7, decodePngDataUrl as d8, decodeSelectionRle as d9, geometryHomography as dA, getAnnotationBounds as dB, getCropCursor as dC, getRotatedSize as dD, getViewportMetrics as dE, getViewportProjection as dF, globalImageCache as dG, greyMorphology as dH, groupLayers as dI, guidePlanes as dJ, guidedFilterColor as dK, hasSurface as dL, hasWarp as dM, hashMaskContent as dN, histogramPath as dO, hitTestAnnotation as dP, hitTestCrop as dQ, hueRange as dR, identityTransform as dS, imageToCanvasPoint as dT, importPsd as dU, invertSelection as dV, isActiveFilter as dW, isIdentityTransform as dX, isQuarterTurnSwapped as dY, isRenderedLayer as dZ, isRetouchTool as d_, defaultShapeName as da, depthMaskAlpha as db, describeTransform as dc, deserializeColorProfile as dd, deserializeEffects as de, deserializeLayer as df, deserializeLayers as dg, deserializePatterns as dh, deserializeSelection as di, developFilter as dj, displayTransform as dk, distanceTransform as dl, documentProfile as dm, duplicateLayer as dn, edgeWidth as dp, ellipsePoints as dq, ellipseSelection as dr, encodeDeepSurface as ds, encodeSelectionRle as dt, encodeSurface as du, expandCoverage as dv, exportPsd as dw, featherCoverage as dx, flipCorners as dy, fullSelection as dz, type AdjustmentLayerMask as e, removeLayerFilter as e$, isSelectionMode as e0, isSpatialFilter as e1, isSrgb as e2, isTransformAnchor as e3, isValidWarp as e4, layerEffectsOf as e5, layerMaskCoverage as e6, layerMaskFromSelection as e7, layerMaskKey as e8, layerName as e9, offsetLayer as eA, offsetShape as eB, parseBlend as eC, parseColor as eD, parseSelectionMode as eE, patchParagraphStyle as eF, patchTextStyle as eG, pixelLayerBounds as eH, pixelLayers as eI, placeLayer as eJ, polygonCoverage as eK, polygonSelection as eL, presetWarp as eM, previewStep as eN, profileBytes as eO, projectImagePoint as eP, projectImageRect as eQ, projectMaskCoverage as eR, psdToLayers as eS, readPsd as eT, rectSelection as eU, referencePoint as eV, refineCoverage as eW, refineEdgeHalo as eX, refineSelection as eY, removeLayer as eZ, removeLayerEffect as e_, layerTree as ea, layerTypeLabel as eb, liveComponent as ec, liveShapeSubpaths as ed, magicWand as ee, mapCropHandle as ef, mapSubpaths as eg, matrixFromCorners as eh, matrixFromParams as ei, mergeShapeComponents as ej, migrateSerializedImageEditorState as ek, migrateToLayeredState as el, modifySelection as em, moveLayer as en, newLayerId as eo, normalizeAngle as ep, normalizeFilter as eq, normalizeLayerMask as er, normalizeLiveShape as es, normalizeRect as et, normalizeRefineEdgeParams as eu, normalizeShapePaint as ev, normalizeShapeStroke as ew, normalizeStoredAdjustments as ex, normalizeSubpaths as ey, normalizeText as ez, type AdjustmentLayerOf as f, updateLayerEffect as f$, renderShape as f0, renderShapeRect as f1, renderText as f2, replaceTextRange as f3, requireLayer as f4, requireOperation as f5, requireShapeLayer as f6, requireTypeLayer as f7, requireUnlocked as f8, rerenderShape as f9, shapeGeometryBounds as fA, shapeLayers as fB, shapeOutline as fC, shapeRenderClip as fD, shiftCoverage as fE, smartObjectLayers as fF, smoothCoverage as fG, srgb8ToLab as fH, textMatrix as fI, textOutlines as fJ, textRange as fK, toHex as fL, toTextSpace as fM, toneRange as fN, transformHomography as fO, transformMap as fP, transformShapeComponents as fQ, transformTypeLayer as fR, transformedBox as fS, transformedPoint as fT, typeAsPixelLayer as fU, typeFrame as fV, typeFromAnnotation as fW, typeLayerName as fX, ungroupLayer as fY, unionRect as fZ, unprojectCanvasPoint as f_, rerenderText as fa, resizePixels as fb, resizeSelection as fc, resolveExternalAssets as fd, resolveProfile as fe, runLayerFilters as ff, selectionArea as fg, selectionFromCoverage as fh, selectionFromPixels as fi, selectionToCoverage as fj, selectionToPixels as fk, selectionValueAt as fl, serializeColorProfile as fm, serializeContents as fn, serializeEffects as fo, serializeLayer as fp, serializeLayers as fq, serializeLayersExternal as fr, serializePatterns as fs, serializeSelection as ft, setLayerEffects as fu, setLayerEffectsEnabled as fv, setLayerMask as fw, setLayerProperties as fx, shapeAsPixelLayer as fy, shapeFromAnnotation as fz, ImageEditorController as g, updateLayerFilter as g0, updateLayerMaskProps as g1, updateShapeLayer as g2, updateTypeLayer as g3, withNewIds as g4, writePsd as g5, 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 };