@pixerate/editor 0.112.0 → 0.114.0

package/dist/{export-DBba-buV.d.cts → export-b6NjCZ5-.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 StrokeCoverage, g as MixerTarget, h as MixerStroke, i as StrokeApply, c as StrokePoint } from './blending-aOE6Y3UE.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,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>`). */
@@ -2501,6 +2429,21 @@ interface PaintOptions {
     mixer: MixerSettings;
     /** What the Mixer Brush carries now: its reservoir, how much is left and the picked-up colour. */
     mixerLoad: MixerLoad;
+    /** The retouching tools' options (aligned, sample, spot healing type, tone range, exposure, sponge mode, smudge strength). */
+    retouch: RetouchSettings;
+    /** The Clone Stamp and Healing Brush source point (Alt-click), or `null` when none is set. */
+    cloneSource: CloneSource | null;
+}
+/** Where the Clone Stamp and Healing Brush sample from. */
+interface CloneSource {
+    /** The source point, document pixels. */
+    x: number;
+    y: number;
+    /** With Aligned on: the offset (source − stroke start) the first stroke fixed, kept for the next strokes; `null` until a stroke has used the point. */
+    offset: {
+        x: number;
+        y: number;
+    } | null;
 }
 /**
  * The geometry of one shape component: a live shape (`{ kind: 'rect' | 'ellipse' | 'polygon' |
@@ -2610,8 +2553,12 @@ interface TypeLayerInfo {
     rendering: 'live' | 'stored';
     annotationId?: string;
 }
+/** The retouching tools (see `@pixerate/editor/paint`'s retouch module). */
+type RetouchTool = 'clone' | 'heal' | 'spot-heal' | 'smudge' | 'dodge' | 'burn' | 'sponge';
+declare const RETOUCH_TOOLS: readonly RetouchTool[];
+declare const isRetouchTool: (tool: unknown) => tool is RetouchTool;
 /** Paint tools a stroke can use. */
-type StrokeTool = 'brush' | 'eraser' | 'mixer';
+type StrokeTool = 'brush' | 'eraser' | 'mixer' | RetouchTool;
 /** A stroke: tool, target (default the active layer and target) and brush / colour overrides. */
 interface StrokeInit {
     tool?: StrokeTool;
@@ -2628,6 +2575,16 @@ interface StrokeInit {
     mixer?: Partial<MixerSettings>;
     /** Eraser colour on locked transparency / masks (default the background). */
     background?: string | number[];
+    /** Overrides of the paint options' retouch settings (the retouching tools). */
+    retouch?: Partial<RetouchSettings>;
+    /**
+     * Clone Stamp / Healing Brush: the source point for this stroke (document pixels). Given, it
+     * becomes the clone source (as an Alt-click), so the stroke starts its offset afresh.
+     */
+    source?: {
+        x: number;
+        y: number;
+    };
     /** Kept with the stroke for replays (v1 brushes have no jitter). */
     seed?: number;
 }
@@ -2651,6 +2608,28 @@ interface PaintStrokeResult {
     dabs: number;
     /** The Mixer Brush's load after the stroke (tool `mixer` only). */
     mixerLoad?: MixerLoad;
+    /**
+     * Clone Stamp / Healing Brush: the offset used (source − first stroke point, whole pixels) and
+     * where the stroke's first point sampled.
+     */
+    clone?: {
+        offset: {
+            x: number;
+            y: number;
+        };
+        source: {
+            x: number;
+            y: number;
+        };
+        aligned: boolean;
+    };
+    /** Spot Healing: the offset of the patch it copied, or `null` when it filled smoothly. */
+    spotHeal?: {
+        offset: {
+            x: number;
+            y: number;
+        } | null;
+    };
 }
 /** An opaque pre-stroke history snapshot. */
 type HistoryEntryHandle = {
@@ -2663,11 +2642,42 @@ interface MixerStrokeInit {
     /** Stores the brush load when the stroke ends and returns it (after any clean). */
     end(load: MixerLoad): MixerLoad;
 }
+/** A stroke that paints dab by dab into live pixels (Mixer Brush, Smudge, Sponge). */
+interface LiveDabStroke {
+    push(points: readonly StrokePoint[]): CropBox[];
+    finish(last?: StrokePoint): CropBox[];
+    readonly bounds: CropBox | null;
+    readonly dabCount: number;
+}
+/**
+ * How a retouching stroke starts (see `PaintStrokeSession`): either coverage-based (Clone Stamp,
+ * Healing Brush, Spot Healing, Dodge, Burn: `coverage` composited with `paint()` over the
+ * pre-stroke pixels, optionally replaced by `finalPaint` when the stroke ends) or sequential
+ * (`create`: dabs over live pixels, Smudge and Sponge).
+ */
+type RetouchStrokeInit = {
+    kind: 'coverage';
+    coverage: StrokeCoverage;
+    apply: RetouchApply;
+    /** Called with the first point before any dab is shown (the clone offset is fixed here). */
+    start(first: StrokePoint): void;
+    /** What the coverage lays while the stroke is drawn. */
+    paint(): RetouchPaint;
+    /** What it lays once the stroke ends, from the whole coverage (healing); `null` keeps `paint()`. */
+    finalPaint?(coverage: CoverageMap): RetouchPaint | null;
+    /** Extra result fields. */
+    result?(): Partial<PaintStrokeResult>;
+} | {
+    kind: 'dabs';
+    /** Makes the stroke over the session's live pixels (RGBA, or an RGBA view of a mask). */
+    create(pixels: PaintTileTarget): LiveDabStroke;
+    result?(): Partial<PaintStrokeResult>;
+};
 /**
  * A stroke in progress (see `beginStroke`): `push` input points as they arrive, then `end` (one
  * undo step) or `cancel`. Brush and eraser strokes build up a coverage map composited over the
  * pre-stroke pixels; Mixer Brush strokes paint dab by dab into the live pixels, so each dab picks
- * up what the dabs before it laid down.
+ * up what the dabs before it laid down. Retouching strokes take one of the two shapes.
  */
 declare class PaintStrokeSession {
     private readonly controller;
@@ -2684,6 +2694,10 @@ declare class PaintStrokeSession {
     private readonly stroke;
     private readonly mixer;
     private readonly mixerInit;
+    private readonly retouch;
+    /** Writes a mask's RGBA view back (sequential retouching on a mask). */
+    private readonly flushView;
+    private started;
     /** Mixer tiles written since the last update: they get new tile objects so the compositor sees them change. */
     private readonly fresh;
     private last;
@@ -2692,7 +2706,9 @@ declare class PaintStrokeSession {
         id: string;
         channel: LayerTarget;
         surface: TiledSurface;
-    }, stroke: StrokeCoverage | MixerStrokeInit, apply: StrokeApply);
+    }, stroke: StrokeCoverage | MixerStrokeInit | RetouchStrokeInit, apply: StrokeApply);
+    /** The new tile of a coverage stroke over the pre-stroke tile `src`. */
+    private compositeTile;
     /** The live pixels a mixer stroke reads and writes; base tiles are copied on first write. */
     private mixerPixels;
     get layerId(): string;
@@ -2778,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;
@@ -3152,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;
     /**
@@ -3185,9 +3215,10 @@ declare class ImageEditorController {
         mask?: boolean;
     }): string | null;
     /** Brush settings, colours and tool options of the paint tools (view state, no undo). */
-    setPaintOptions(options: Partial<Omit<PaintOptions, 'brush' | 'mixer' | 'mixerLoad'>> & {
+    setPaintOptions(options: Partial<Omit<PaintOptions, 'brush' | 'mixer' | 'mixerLoad' | 'retouch' | 'cloneSource'>> & {
         brush?: Partial<BrushSettings>;
         mixer?: Partial<MixerSettings>;
+        retouch?: Partial<RetouchSettings>;
     }): PaintOptions;
     /**
      * Loads the Mixer Brush's reservoir full with `color` (default the foreground); the picked-up
@@ -3198,6 +3229,14 @@ declare class ImageEditorController {
     cleanMixerBrush(): MixerLoad;
     /** Empties the Mixer Brush entirely (no reservoir, nothing picked up). Returns the brush load. */
     emptyMixerBrush(): MixerLoad;
+    /**
+     * Sets (Alt-click) or clears the Clone Stamp and Healing Brush source point, in document
+     * pixels. The next stroke fixes the offset from its first point. View state, no undo.
+     */
+    setCloneSource(point: {
+        x: number;
+        y: number;
+    } | null): CloneSource | null;
     /** D: black foreground, white background. */
     resetPaintColors(): void;
     /** X: swaps the foreground and background colours. */
@@ -3213,6 +3252,12 @@ declare class ImageEditorController {
      * without recording history.
      */
     beginStroke(init?: StrokeInit): PaintStrokeSession;
+    /** A retouching stroke's start: its settings, what it samples and how it composites. */
+    private retouchStroke;
+    /** A pixel source over a surface (layer pixels or a mask) in layer space at `offset`. */
+    private surfaceSource;
+    /** A pixel source over the composite of the current layers (through `throughId` and below, or all of them), as it is now. */
+    private compositeSource;
     /** A Mixer Brush stroke's start: the settings, and the load (refilled when asked or set to). */
     private mixerStroke;
     /** @internal Shows a stroke's live surface (no history). */
@@ -3426,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;
@@ -3586,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;
     /**
@@ -3607,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.
@@ -3921,11 +4033,14 @@ interface ImageAnnotation extends BaseAnnotation {
 type Annotation = PenAnnotation | RectAnnotation | CircleAnnotation | ArrowAnnotation | LineAnnotation | TextAnnotation | ImageAnnotation;
 type CreateAnnotationPayload = Omit<PenAnnotation, 'id'> | Omit<RectAnnotation, 'id'> | Omit<CircleAnnotation, 'id'> | Omit<ArrowAnnotation, 'id'> | Omit<LineAnnotation, 'id'> | Omit<TextAnnotation, 'id'> | Omit<ImageAnnotation, 'id'>;
 type ImageEditorTool = 'select' | 'crop' | 'pen' | 'rect' | 'circle' | 'arrow' | 'line' | 'text' | 'watermark' | 'move' | 'brush' | 'eraser' | 'mixer'
+/** Retouching (see `RetouchTool`): Clone Stamp, Healing Brush, Spot Healing, Smudge, Dodge, Burn, Sponge. */
+ | 'clone' | 'heal' | 'spot-heal' | 'smudge' | 'dodge' | 'burn' | 'sponge'
 /** Live shape layers (see `ShapeDrawGesture`). */
  | 'shape'
 /** 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. */
@@ -3993,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
@@ -4076,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;
@@ -4088,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 LayerBase 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 FreeTransformContent as aA, type FreeTransformHost as aB, type FreeTransformPreview as aC, GUIDED_FILTER_EPS as aD, type GroupLayer as aE, HISTOGRAM_BINS as aF, type HistogramChannel as aG, type HistoryEntryHandle as aH, type HueSaturationParams as aI, IMAGE_EDITOR_SCHEMA_VERSION as aJ, type ImageAnnotation as aK, type ImageDimensions as aL, type ImageEditorAIHooks as aM, type ImageEditorFit as aN, type ImageEditorOptions as aO, ImageEditorRenderer as aP, type ImageEditorState as aQ, type ImageEditorTool as aR, type ImageLayerType as aS, type InpaintHook as aT, type InpaintOptions as aU, type InvertParams as aV, LAYERED_SCHEMA_VERSION as aW, LIVE_SHAPE_KINDS as aX, type LaidChar as aY, type LaidFragment as aZ, type LaidLine as a_, type AspectRatio as aa, type BaseAnnotation as ab, type BlackWhiteParams as ac, type BlurFilter as ad, type CircleAnnotation as ae, type ColorBalanceParams as af, type ColorBalanceTone as ag, type ColorRangeOptions as ah, type ColorRangeSample as ai, type CreateAnnotationPayload as aj, type CropHandle as ak, type CurvesParams as al, DEFAULT_ADJUSTMENTS as am, DEFAULT_AUTO_LEADING as an, DEFAULT_DEPTH_MASK as ao, DEFAULT_MITER_LIMIT as ap, DEFAULT_REFINE_EDGE_PARAMS as aq, DEFAULT_TEXT_STYLE as ar, DEFAULT_TRANSFORM as as, type DeserializeContext as at, type DevelopSettings as au, EMPTY_DISTANCE as av, type ExportOptions as aw, FREE_TRANSFORM_CONTENTS as ax, FREE_TRANSFORM_MODES as ay, type FillOptions as az, type SerializedImageEditorState as b, type SerializedSmartFilter as b$, type LayerBlendMode as b0, type LayerFilterKind as b1, type LayerLocation as b2, type LayerMaskProps as b3, LayerOperationError as b4, type LayerProperties as b5, type LayerSourcesHost as b6, type LayerTarget as b7, type LegacySerializedImageEditorState as b8, type LevelsParams as b9, type PsdSmartFilter as bA, type PsdTaggedBlock as bB, type PsdTreeNode as bC, type RectAnnotation as bD, type RemoveBackgroundHook as bE, type RemoveBackgroundOptions as bF, type RenderOptions as bG, SELECTION_MODES as bH, SELECTION_MODIFY_OPS as bI, SHAPE_OPERATIONS as bJ, SHAPE_RENDER_MARGIN as bK, type SampleOptions as bL, type SelectionChannel as bM, type SelectionCommandOptions as bN, type SelectionModifyOp as bO, type SerializeContext as bP, type SerializedAdjustmentLayer as bQ, type SerializedAnnotationLayer as bR, type SerializedGroupLayer as bS, type SerializedLayerEffects as bT, type SerializedLayeredImageEditorState as bU, type SerializedPattern as bV, type SerializedPixelLayer as bW, type SerializedRasterMask as bX, type SerializedSelection as bY, type SerializedShapeLayer as bZ, type SerializedSmartContents as b_, type LineAnnotation as ba, type LiveShape as bb, type MagicWandOptions as bc, type MixerStrokeInit as bd, PARAGRAPH_STYLE_FIELDS as be, PSD_BLEND_KEYS as bf, type PaintOptions as bg, type PaintStrokeResult as bh, PaintStrokeSession as bi, type ParagraphRun as bj, type PenAnnotation as bk, type PhotoFilterParams as bl, type PixelBuffer as bm, type PixelLayerInit as bn, type PosterizeParams as bo, type PsdChannel as bp, type PsdExportInput as bq, type PsdFile as br, type PsdHeader as bs, type PsdImportOptions as bt, type PsdImportResult as bu, type PsdLayerMask as bv, type PsdLayerRecord as bw, type PsdLayerSummary as bx, type PsdRect as by, type PsdResource as bz, type AdjustmentLayer as c, computeSelectionBounds as c$, type SerializedSmartObjectLayer as c0, type SerializedTypeLayer as c1, type ShapeArrowhead as c2, type ShapeComponent as c3, type ShapeEnv as c4, type ShapeFillRule as c5, type ShapeGeometryInput as c6, type ShapeLayerData as c7, type ShapeLayerInfo as c8, type ShapeLayerInit as c9, type TransformReadout as cA, type TypeLayerData as cB, type TypePsdData as cC, type VibranceParams as cD, type ViewportMetrics as cE, addLayerEffect as cF, addLayerFilter as cG, adjustmentNodeAsLayer as cH, anchorPoint as cI, annotationBlend as cJ, annotationOfShape as cK, annotationOfType as cL, applyImageProjectionToContext as cM, applyParams as cN, blurFilter as cO, borderCoverage as cP, boxMean as cQ, boxPointOf as cR, buildLayerMaskPlanes as cS, calculateCropDrag as cT, canvasToImagePoint as cU, caretAt as cV, clampCropToImage as cW, colorRange as cX, combineSelections as cY, componentPath as cZ, computeHistogram as c_, type ShapeLineCap as ca, type ShapeLineJoin as cb, type ShapeOperation as cc, type ShapePaint as cd, type ShapePsdData as ce, type ShapeSelectionOptions as cf, type ShapeStroke as cg, type ShapeStrokeAlign as ch, type ShapeStrokeInput as ci, type SmartFilterKind as cj, type SmartObjectInfo as ck, type SmartPsdData as cl, type StrokeInit as cm, type StrokeTool as cn, TEXT_ALIGNS 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 TextLayout as cv, type TextRun as cw, type ThresholdParams as cx, type ToneRangePreset as cy, type TransformParams as cz, type AdjustmentParamsMap as d, isSelectionMode as d$, contractCoverage as d0, cornersFromMatrix as d1, coverageToByte as d2, createSelectionMask as d3, createShapeLayer as d4, createTypeLayer as d5, decodeLayerChannel as d6, decodeLayerMask as d7, decodeMergedImage as d8, decodePngDataUrl 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, isSelectionEmpty as d_, decodeSelectionRle as da, defaultShapeName as db, depthMaskAlpha as dc, describeTransform as dd, deserializeEffects as de, deserializeLayer as df, deserializeLayers as dg, deserializePatterns as dh, deserializeSelection as di, developFilter as dj, distanceTransform as dk, duplicateLayer as dl, edgeWidth as dm, ellipsePoints as dn, ellipseSelection as dp, encodeSelectionRle as dq, encodeSurface as dr, expandCoverage as ds, exportPsd as dt, featherCoverage as du, fitParagraphRuns as dv, fitRuns as dw, flipCorners as dx, fontOf as dy, fullSelection as dz, type AdjustmentLayerMask as e, renderShape as e$, isSpatialFilter as e0, isTransformAnchor as e1, isValidWarp as e2, layerEffectsOf as e3, layerMaskCoverage as e4, layerMaskFromSelection as e5, layerMaskKey as e6, layerName as e7, layerTree as e8, layerTypeLabel as e9, offsetShape as eA, paragraphRanges 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, projectImagePoint as eO, projectImageRect as eP, projectMaskCoverage as eQ, psdToLayers as eR, readPsd as eS, rectSelection as eT, referencePoint as eU, refineCoverage as eV, refineEdgeHalo as eW, refineSelection as eX, removeLayer as eY, removeLayerEffect as eZ, removeLayerFilter as e_, layoutText as ea, liveComponent as eb, liveShapeSubpaths as ec, magicWand as ed, mapCropHandle as ee, mapSubpaths as ef, matrixFromCorners as eg, matrixFromParams as eh, mergeShapeComponents as ei, migrateSerializedImageEditorState as ej, migrateToLayeredState as ek, modifySelection as el, moveLayer as em, newLayerId as en, normalizeAngle as eo, normalizeFilter as ep, normalizeLayerMask as eq, normalizeLiveShape as er, normalizeRect as es, normalizeRefineEdgeParams as et, normalizeShapePaint as eu, normalizeShapeStroke as ev, normalizeStoredAdjustments as ew, normalizeSubpaths as ex, normalizeText as ey, offsetLayer as ez, type AdjustmentLayerOf as f, unprojectCanvasPoint as f$, renderShapeRect as f0, renderText as f1, replaceTextRange as f2, requireLayer as f3, requireOperation as f4, requireShapeLayer as f5, requireTypeLayer as f6, requireUnlocked as f7, rerenderShape as f8, rerenderText as f9, shapeOutline as fA, shapeRenderClip as fB, shiftCoverage as fC, smartObjectLayers as fD, smoothCoverage as fE, spliceRuns as fF, srgb8ToLab as fG, styleAt as fH, textIndexAt as fI, textMatrix as fJ, textOutlines as fK, textRange as fL, toHex as fM, toTextSpace as fN, toneRange as fO, transformHomography as fP, transformMap as fQ, transformShapeComponents as fR, transformTypeLayer as fS, transformedBox as fT, transformedPoint as fU, typeAsPixelLayer as fV, typeFrame as fW, typeFromAnnotation as fX, typeLayerName as fY, ungroupLayer as fZ, unionRect as f_, resizePixels as fa, resizeSelection as fb, resolveExternalAssets as fc, restyleRange as fd, runLayerFilters as fe, selectionArea as ff, selectionFromCoverage as fg, selectionFromPixels as fh, selectionToCoverage as fi, selectionToPixels as fj, selectionValueAt as fk, serializeContents as fl, serializeEffects as fm, serializeLayer as fn, serializeLayers as fo, serializeLayersExternal as fp, serializePatterns as fq, serializeSelection as fr, setLayerEffects as fs, setLayerEffectsEnabled as ft, setLayerMask as fu, setLayerProperties as fv, shapeAsPixelLayer as fw, shapeFromAnnotation as fx, shapeGeometryBounds as fy, shapeLayers as fz, ImageEditorController as g, updateLayerEffect as g0, updateLayerFilter as g1, updateLayerMaskProps as g2, updateShapeLayer as g3, updateTypeLayer as g4, withNewIds as g5, writePsd as g6, 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 };