@pixerate/editor 0.109.0 → 0.111.0

package/dist/{export-BLPLaE6Z.d.ts → export-DBNVwb6h.d.ts}

@@ -1,9 +1,9 @@
-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-OLIMk_v0.js';
-import { P as PixelSurface, B as BlendMode, a as TiledSurface } from './surface-CkKOHGPm.js';
+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 { A as AffineMatrix, Q as Quad, a as WarpMesh, V as Vec2$1, H as Homography } from './types-CwMPoRMU.js';
-import { v as VectorSubpath, n as Vec2 } from './types-DtL_qLFz.js';
-import { B as BrushSettings, M as MixerSettings, a as MixerLoad, c as StrokeCoverage, d as MixerTarget, e as MixerStroke, f as StrokeApply, S as StrokePoint } from './mixer-DNqiYXYQ.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 StrokeCoverage, g as MixerTarget, h as MixerStroke, i as StrokeApply, c as StrokePoint } from './blending-DXl06NSx.js';
 import { W as WarpPreset } from './warp-CWHZzE3x.js';
 
 /**
@@ -321,6 +321,118 @@ 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 text and styles are unchanged. */
+    tySh?: Uint8Array;
+    /** Additional-info blocks we do not model, by key. */
+    blocks?: Array<{
+        key: string;
+        data: Uint8Array;
+    }>;
+}
+/**
+ * A type layer: styled text laid out as point text (one line per paragraph, growing from its
+ * origin) or paragraph text (wrapped in a box), placed in the document by `transform`. `surface` is
+ * the rendered text in document space (offset 0), drawn by the editor's text shaper on every change;
+ * the compositor draws it like a pixel layer's pixels. Never paint into it: rasterize the layer.
+ */
+interface TypeLayer extends LayerBase {
+    type: 'type';
+    text: string;
+    /** Character runs covering the text in order (lengths add up to `text.length`). */
+    runs: TextRun[];
+    /** Paragraph runs covering the text in order. */
+    paragraphs: ParagraphRun[];
+    /**
+     * `point`: text space (0, 0) is the first line's baseline at its alignment edge (`origin: 'top'`:
+     * the top of the first line instead, as text annotations were drawn). `box`: text wraps inside
+     * `width × height` with its top-left at (0, 0).
+     */
+    frame: {
+        kind: 'point';
+        origin?: 'baseline' | 'top';
+    } | {
+        kind: 'box';
+        width: number;
+        height: number;
+    };
+    /** Text space → document (missing = identity). */
+    transform?: AffineMatrix;
+    /** Default true. */
+    antiAlias?: boolean;
+    /** The rendered pixels, document space. */
+    surface: PixelSurface;
+    /** Always (0, 0): a type layer moves through its transform. */
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** 0..1, PSD "Fill" (missing = 1). */
+    fillOpacity?: number;
+    /**
+     * How `surface` was made: missing when the shaper laid it out; `'stored'` for pixels kept from a
+     * PSD or a save made where no shaper could draw it (the first edit draws it again).
+     */
+    rendering?: 'stored';
+    /** Families the last render had to replace with a fallback. */
+    missingFonts?: string[];
+    /** The text annotation this layer was migrated from, while it still is that annotation. */
+    annotation?: Annotation;
+    psd?: TypePsdData;
+}
 /** A nested layer document: the contents of a smart object made from layers (or an embedded PSD). */
 interface SmartDocument {
     /** Bottom to top, on a canvas of the contents' `width × height`. */
@@ -436,7 +548,7 @@ interface SmartObjectLayer extends LayerBase {
     fillOpacity?: number;
     psd?: SmartPsdData;
 }
-type ImageLayer = PixelLayer | AdjustmentLayerNode | GroupLayer | AnnotationLayer | SmartObjectLayer | ShapeLayer;
+type ImageLayer = PixelLayer | AdjustmentLayerNode | GroupLayer | AnnotationLayer | SmartObjectLayer | ShapeLayer | TypeLayer;
 type ImageLayerType = ImageLayer['type'];
 /** Which part of the active layer painting targets (`filter-mask`: a smart object's filter mask). */
 type LayerTarget = 'pixels' | 'mask' | 'filter-mask';
@@ -457,15 +569,242 @@ declare function isSpatialFilter(f: LayerFilter): boolean;
 declare function pixelLayerBounds(layer: PixelLayer, surface?: PixelSurface): CropBox | null;
 /** Human label of a layer kind. */
 declare function layerTypeLabel(type: ImageLayerType): string;
-/** Layers whose pixels are a surface the compositor draws (pixel layers, smart objects, shapes). */
-declare function hasSurface(layer: ImageLayer): layer is PixelLayer | SmartObjectLayer | ShapeLayer;
-/** Layers whose `surface` is a render cache of their own data (smart objects, shapes): never paint into it. */
-declare function isRenderedLayer(layer: ImageLayer): layer is SmartObjectLayer | ShapeLayer;
+/** Layers whose pixels are a surface the compositor draws (pixel layers, smart objects, shapes, type). */
+declare function hasSurface(layer: ImageLayer): layer is PixelLayer | SmartObjectLayer | ShapeLayer | TypeLayer;
+/** Layers whose `surface` is a render cache of their own data (smart objects, shapes, type): never paint into it. */
+declare function isRenderedLayer(layer: ImageLayer): layer is SmartObjectLayer | ShapeLayer | TypeLayer;
 /** Every shape layer in the stack. */
 declare function shapeLayers(layers: readonly ImageLayer[]): ShapeLayer[];
 /** Every smart object in the stack (nested contents not included). */
 declare function smartObjectLayers(layers: readonly ImageLayer[]): SmartObjectLayer[];
 
+/**
+ * Type layers: styled runs of text laid out as point or paragraph text and drawn into the layer's
+ * `surface` by a text shaper.
+ *
+ * Layout (paragraphs, line breaking, alignment, tracking, leading, indents, spacing) is ours and
+ * runs anywhere. What needs fonts goes through a `TextShaper`: font availability and fallback,
+ * metrics, advance widths and drawing, either as glyph outlines (pure; rendered by the shape
+ * rasterizer, and what Convert to Shape needs) or onto a 2D canvas (the browser's own text). The
+ * editor uses a Canvas 2D shaper in browsers; hosts can plug in another (an OpenType outline
+ * shaper, or one for a server). Without a shaper, type layers keep the pixels they were saved with
+ * 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;
+    height: number;
+    /** `null`: no shaper here; type layers keep their stored pixels. */
+    shaper: TextShaper | null;
+    /** 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. */
+declare function textMatrix(layer: Pick<TypeLayer, 'transform'>): AffineMatrix;
+/** Glyph outlines of a laid-out layer in document space, one path per fragment (needs an outline shaper). */
+declare function textOutlines(layer: TypeLayer, shaper: TextShaper): Array<{
+    fragment: LaidFragment;
+    path: BezierPath;
+}>;
+/**
+ * Renders a type layer into a document-space surface with the env's shaper, or returns `null`
+ * when nothing here can draw it (no shaper, or a drawing shaper without a canvas).
+ */
+declare function renderText(layer: TypeLayer, env: TextEnv): {
+    surface: PixelSurface;
+    missingFonts: string[];
+} | null;
+/** The layer drawn again (`rendering` and `missingFonts` updated); refuses when nothing can draw it. */
+declare function rerenderText(layer: TypeLayer, env: TextEnv): TypeLayer;
+/** Fields of `TextStyle` an edit can set (`null` clears an optional one). */
+declare const TEXT_STYLE_FIELDS: readonly ["fontFamily", "fontWeight", "italic", "fontSize", "color", "opacity", "tracking", "leading", "baselineShift", "underline", "strikethrough"];
+/** `base` with the given style fields changed, validated (`null` clears leading, tracking, …). */
+declare function patchTextStyle(base: TextStyle, patch: Record<string, unknown>, path?: string): TextStyle;
+declare const PARAGRAPH_STYLE_FIELDS: readonly ["align", "autoLeading", "firstLineIndent", "startIndent", "endIndent", "spaceBefore", "spaceAfter"];
+/** `base` with the given paragraph fields changed, validated. */
+declare function patchParagraphStyle(base: ParagraphStyle, patch: Record<string, unknown>, path?: string): ParagraphStyle;
+/** A range of the text from loose input: [start, end) in UTF-16 code units, defaults the whole text. */
+declare function textRange(text: string, start: unknown, end: unknown): [number, number];
+/** The type layer with `id`, or an error saying what it is instead. */
+declare function requireTypeLayer(layers: readonly ImageLayer[], id: string): TypeLayer;
+/** Normalises text: line breaks as `\n`. */
+declare function normalizeText(text: unknown, path?: string): string;
+/** The name Photoshop gives a type layer: its text, cut short. */
+declare function typeLayerName(text: string): string;
+interface TypeLayerData {
+    text: string;
+    runs: TextRun[];
+    paragraphs?: ParagraphRun[];
+    frame: TypeLayer['frame'];
+    transform?: AffineMatrix;
+    name?: string;
+}
+/**
+ * A new type layer, laid out and drawn. Without anything to draw it, refused, or with `lenient`
+ * kept undrawn (`rendering: 'stored'`, no pixels) until a shaper draws it.
+ */
+declare function createTypeLayer(init: TypeLayerData, env: TextEnv, id?: string, lenient?: boolean): TypeLayer;
+/** Changes a type layer (dropping its migrated annotation and stored pixels) and draws it again. */
+declare function updateTypeLayer(layers: readonly ImageLayer[], id: string, change: (layer: TypeLayer) => Partial<TypeLayer>, env: TextEnv, action?: string): {
+    layers: ImageLayer[];
+    layer: TypeLayer;
+};
+/** A type layer's text with [start, end) replaced by `insert`; new text takes the style at `start`. */
+declare function replaceTextRange(layer: TypeLayer, start: number, end: number, insert: string): Pick<TypeLayer, 'text' | 'runs' | 'paragraphs'>;
+/** A type layer moved by an affine `m` (document space). */
+declare function transformTypeLayer(layer: TypeLayer, m: AffineMatrix): TypeLayer;
+/** Text-space frame of a type layer (the box, or the laid-out lines) for Free Transform. */
+declare function typeFrame(layer: TypeLayer, shaper: TextShaper | null): CropBox;
+/** A type layer as a pixel layer with what it shows now (same id, name, mask, effects, blend). */
+declare function typeAsPixelLayer(layer: TypeLayer): PixelLayer;
+/** Document point → text space of a layer. */
+declare function toTextSpace(layer: Pick<TypeLayer, 'transform'>, p: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};
+/** The type layer data a text annotation draws, or `null` when its colour can't be read. */
+declare function typeFromAnnotation(a: Annotation): TypeLayerData | null;
+/** The annotation a migrated type layer still is (its blend read from the layer). */
+declare function annotationOfType(layer: TypeLayer): Annotation | null;
+
 /**
  * Schema version 3 of the image editor document: the layer tree, with pixel layers and painted
  * masks stored as PNG assets (cropped to their content and placed by position), plus the
@@ -615,7 +954,33 @@ interface SerializedShapeLayer extends SerializedLayerBase {
         }>;
     };
 }
-type SerializedLayer = SerializedPixelLayer | SerializedAdjustmentLayer | SerializedGroupLayer | SerializedAnnotationLayer | SerializedSmartObjectLayer | SerializedShapeLayer;
+/** A type layer: its text and styles, plus the pixels it showed (PNG) for loads without its fonts. */
+interface SerializedTypeLayer extends SerializedLayerBase {
+    type: 'type';
+    text: string;
+    runs: TextRun[];
+    paragraphs: ParagraphRun[];
+    frame: TypeLayer['frame'];
+    transform?: number[];
+    antiAlias?: false;
+    fillOpacity?: number;
+    /** The rendered pixels (RGBA PNG) at `x`, `y` in document space. */
+    asset?: string;
+    x?: number;
+    y?: number;
+    missingFonts?: string[];
+    /** The text annotation the layer was migrated from, while it still is that annotation. */
+    annotation?: Annotation;
+    /** PSD blocks kept for round trips (base64). */
+    psd?: {
+        tySh?: string;
+        blocks?: Array<{
+            key: string;
+            data: string;
+        }>;
+    };
+}
+type SerializedLayer = SerializedPixelLayer | SerializedAdjustmentLayer | SerializedGroupLayer | SerializedAnnotationLayer | SerializedSmartObjectLayer | SerializedShapeLayer | SerializedTypeLayer;
 /** A version 3 document (layers). */
 interface SerializedLayeredImageEditorState {
     version: 3;
@@ -724,6 +1089,8 @@ interface DeserializeContext {
     problems: string[];
     /** The document's patterns by id, for shapes painted with one. */
     pattern?(id: string): EffectPattern | null;
+    /** What draws type layers stored without pixels (and migrated text annotations). */
+    text?: Pick<TextEnv, 'shaper' | 'createCanvas'>;
 }
 /** Decodes a PNG data URL into pixels of `channels` bytes each. */
 declare function decodePngDataUrl(url: string, channels: 1 | 4): {
@@ -1887,6 +2254,8 @@ interface FreeTransformHost {
     pixelsOf(layer: PixelLayer | SmartObjectLayer): TiledSurface;
     /** What shape layers render with (canvas size, document patterns). */
     shapeEnv(): ShapeEnv;
+    /** What type layers lay out and draw with. */
+    textEnv(): TextEnv;
     /** Opaque pre-transform snapshot. */
     capture(): unknown;
     /** Shows a live state (no history). */
@@ -1925,6 +2294,9 @@ declare class FreeTransformSession {
     /** True when the layer is a shape layer (the transform maps its paths and renders them again). */
     readonly shapeLayer: boolean;
     private readonly shape;
+    /** True when the layer is a type layer (the transform sets its text matrix; affine only). */
+    readonly typeLayer: boolean;
+    private readonly typeTarget;
     private geometryValue;
     private readonly smart;
     private readonly smartReduced;
@@ -1962,6 +2334,11 @@ declare class FreeTransformSession {
      * render only the visible part.
      */
     private resampleShape;
+    /**
+     * A type layer with its text matrix set from the corners (affine only: scale, rotate, skew and
+     * flips), drawn again; a linked mask follows by the change's homography.
+     */
+    private resampleType;
     /** A smart object re-rendered from its contents for the current geometry (previews leave the smart filters out). */
     private resampleSmart;
     /** Whether the geometry (or the interpolation of a smart object) differs from where it started. */
@@ -2155,6 +2532,63 @@ interface ShapeLayerInfo {
     /** The annotation id while the layer is still the annotation it was migrated from. */
     annotationId?: string;
 }
+/** A new type layer: its text, where it goes, and its character and paragraph style. */
+interface TextLayerInit extends LayerPlacement {
+    text: string;
+    /**
+     * Document x, y of the text's origin: point text's first baseline at its alignment edge (left
+     * edge for left-aligned, centre for centred, right edge for right-aligned); a paragraph box's
+     * top-left.
+     */
+    x: number;
+    y: number;
+    /** Paragraph (area) text: wrap inside a `width × height` box (pixels). Missing: point text. */
+    box?: {
+        width: number;
+        height: number;
+    };
+    /** Character style of the whole text (default 24 px sans-serif, the foreground colour). */
+    style?: Partial<TextStyle>;
+    paragraph?: ParagraphStyle;
+    /** Degrees clockwise about the origin. */
+    rotation?: number;
+    name?: string;
+    opacity?: number;
+    blend?: BlendMode;
+}
+/** A type layer as tools and panels read it. Ranges are UTF-16 code units, `end` exclusive. */
+interface TypeLayerInfo {
+    id: string;
+    name: string;
+    text: string;
+    runs: Array<{
+        start: number;
+        end: number;
+        style: TextStyle;
+    }>;
+    paragraphs: Array<{
+        start: number;
+        end: number;
+        style: ParagraphStyle;
+    }>;
+    frame: TypeLayer['frame'];
+    /** Text space → document. */
+    transform: AffineMatrix;
+    /** Laid-out lines: text range, baseline (text space) and width; empty without a shaper. */
+    lines: Array<{
+        start: number;
+        end: number;
+        baseline: number;
+        width: number;
+    }>;
+    /** Rendered bounds in the document. */
+    bounds: CropBox | null;
+    /** Families drawn with a fallback because they are missing here. */
+    missingFonts: string[];
+    /** `live`: drawn here from the text; `stored`: pixels kept from a file until the next edit. */
+    rendering: 'live' | 'stored';
+    annotationId?: string;
+}
 /** Paint tools a stroke can use. */
 type StrokeTool = 'brush' | 'eraser' | 'mixer';
 /** A stroke: tool, target (default the active layer and target) and brush / colour overrides. */
@@ -2928,6 +3362,8 @@ declare class ImageEditorController {
     resetDepthMask(): void;
     /** The layer showing annotation `id`: an annotation layer, or a shape layer migrated from it. */
     private annotationLayer;
+    /** What migrating an annotation needs: the canvas size, patterns and the text shaper. */
+    private annotationEnv;
     /**
      * Adds an annotation as its own layer (top of the stack unless `aboveId` is given). Pen,
      * rectangle, ellipse, line and arrow annotations become shape layers that remember the
@@ -2936,7 +3372,7 @@ declare class ImageEditorController {
      */
     addAnnotation(annotation: CreateAnnotationPayload, placement?: AnnotationPlacement): string;
     updateAnnotation(id: string, partial: Partial<Annotation>, commitToHistory?: boolean): void;
-    /** `layer` (an annotation or migrated shape layer) showing `annotation` instead, keeping its other properties. */
+    /** `layer` (an annotation, or a shape or type layer migrated from one) showing `annotation` instead, keeping its other properties. */
     private layerForAnnotation;
     removeAnnotation(id: string): void;
     /** Deletes every annotation layer and every shape layer that still is the annotation it was migrated from. */
@@ -3018,6 +3454,72 @@ declare class ImageEditorController {
      * new image has different dimensions). Resolves to the masked layer's id in mask mode.
      */
     applyBackgroundRemovedImage(newDataUrl: string, options?: AIResultOptions): Promise<string | void>;
+    private textShaperValue;
+    /** The shaper that lays out and draws type layers (`null` when there is none here). */
+    getTextShaper(): TextShaper | null;
+    /** Sets the text shaper (fonts) type layers lay out and draw with; existing layers redraw on their next edit. */
+    setTextShaper(shaper: TextShaper | null): void;
+    /** What type layers lay out and draw with. */
+    private textEnv;
+    /** Font families the shaper offers (generic families at least). */
+    listFonts(): string[];
+    private typeInfo;
+    /** A type layer's text, runs, paragraphs, frame, lines and bounds. */
+    getTextLayer(id: string): TypeLayerInfo;
+    /**
+     * Adds a type layer (one undo step) and makes it active: point text at `x`, `y`, or paragraph
+     * text wrapped in `box`. Refused without a text shaper. Returns its id.
+     */
+    addTextLayer(init: TextLayerInit): string;
+    /**
+     * Replaces text [start, end) (default all of it) with `text`; inserted text takes the style at
+     * `start`. One undo step unless `commitToHistory` is false (typing). Returns the layer.
+     */
+    setText(id: string, text: string, range?: {
+        start?: number;
+        end?: number;
+    }, commitToHistory?: boolean): TypeLayerInfo;
+    /** Sets character style fields over [start, end) (default all), one undo step. Returns the layer. */
+    setTextStyle(id: string, style: Partial<TextStyle> & Record<string, unknown>, range?: {
+        start?: number;
+        end?: number;
+    }, commitToHistory?: boolean): TypeLayerInfo;
+    /** Sets paragraph style fields on every paragraph that [start, end) touches (default all), one undo step. */
+    setParagraphStyle(id: string, style: ParagraphStyle & Record<string, unknown>, range?: {
+        start?: number;
+        end?: number;
+    }, commitToHistory?: boolean): TypeLayerInfo;
+    /**
+     * Point text ↔ paragraph text: `{ kind: 'box', width, height }` wraps the text in a box (its
+     * top-left where the first line's top-left is now), `{ kind: 'point' }` sets it on one line per
+     * paragraph. Also resizes a box. One undo step.
+     */
+    setTextFrame(id: string, frame: {
+        kind: 'point';
+    } | {
+        kind: 'box';
+        width: number;
+        height: number;
+    }, commitToHistory?: boolean): TypeLayerInfo;
+    /**
+     * Convert to Shape: the text's glyph outlines become a shape layer with the same id, name and
+     * layer properties (needs a shaper that gives outlines). The fill is the first run's colour;
+     * `warnings` says when other colours were dropped. One undo step.
+     */
+    convertTextToShape(id: string): {
+        layerId: string;
+        warnings: string[];
+    };
+    /** The layout of a type layer (lines, characters, bounds in text space), or `null` without a shaper. */
+    getTextLayout(id: string): TextLayout | null;
+    /** The text index nearest a document point (for clicks on a type layer). */
+    textIndexAt(id: string, point: ImagePoint): number;
+    /** The caret at text index `index` as a document-space segment (top to bottom), for drawing it. */
+    textCaret(id: string, index: number): {
+        top: ImagePoint;
+        bottom: ImagePoint;
+        line: number;
+    } | null;
     /** What shape rendering needs: the canvas size and the document's patterns. */
     private shapeEnv;
     /** One component from tool or UI input (validated). */
@@ -3499,6 +4001,13 @@ interface ExportOptions {
     layerIds?: string[];
 }
 interface ImageEditorOptions {
+    /**
+     * What lays out and draws type layers. Default: the browser's fonts through Canvas 2D
+     * (`createCanvasTextShaper`) where there is a 2D canvas; `null` (or no canvas) keeps type layers'
+     * stored pixels and refuses edits that would draw them. `createOutlineTextShaper` draws from
+     * fonts you load, anywhere, and enables Convert to Shape.
+     */
+    textShaper?: TextShaper | null;
     image?: string | HTMLImageElement;
     initialState?: Partial<SerializedImageEditorState>;
     onStateChange?: (state: ImageEditorState) => void;
@@ -3552,4 +4061,4 @@ interface PsdExportResult {
 /** Writes the prepared stack as PSD (or PSB) bytes. */
 declare function exportPsd(input: PsdExportInput): PsdExportResult;
 
-export { type AnnotationType as $, type AdjustmentKind as A, type SmartFilterStack as B, type CurvePoint as C, type DepthMaskOptions as D, type SmartFilter as E, type SmartObjectLayer as F, type SmartContents as G, type HueRange as H, type ImageEditorAssetStore as I, type SmartDocument as J, type SmartPlacement as K, type LevelsChannel as L, type FreeTransformGeometry as M, type LayerPlacement as N, type FreeTransformMode as O, type PsdExportResult as P, type FreeTransformResult as Q, type RefineEdgeParams as R, type SerializedLayer as S, FreeTransformSession as T, type FreeTransformInit as U, type TransformAnchor as V, type AIResultOptions as W, type AdjustmentLayerBase as X, type AdjustmentLayerInit as Y, type AdjustmentLayerUpdate as Z, type AnnotationPlacement as _, type ImageAdjustments as a, type MagicWandOptions as a$, type ArrowAnnotation as a0, type AspectRatio as a1, type BaseAnnotation as a2, type BlackWhiteParams as a3, type BlurFilter as a4, type CircleAnnotation as a5, type ColorBalanceParams as a6, type ColorBalanceTone as a7, type ColorRangeOptions as a8, type ColorRangeSample as a9, type ImageDimensions as aA, type ImageEditorAIHooks as aB, type ImageEditorFit as aC, type ImageEditorOptions as aD, ImageEditorRenderer as aE, type ImageEditorState as aF, type ImageEditorTool as aG, type ImageLayerType as aH, type InpaintHook as aI, type InpaintOptions as aJ, type InvertParams as aK, LAYERED_SCHEMA_VERSION as aL, LIVE_SHAPE_KINDS as aM, type LayerBase as aN, type LayerBlendMode as aO, type LayerFilterKind as aP, type LayerLocation as aQ, type LayerMaskProps as aR, LayerOperationError as aS, type LayerProperties as aT, type LayerSourcesHost as aU, type LayerTarget as aV, type LegacySerializedImageEditorState as aW, type LevelsParams as aX, type LineAnnotation as aY, type LiveShape as aZ, type LiveShapeKind as a_, type CreateAnnotationPayload as aa, type CropHandle as ab, type CurvesParams as ac, DEFAULT_ADJUSTMENTS as ad, DEFAULT_DEPTH_MASK as ae, DEFAULT_MITER_LIMIT as af, DEFAULT_REFINE_EDGE_PARAMS as ag, DEFAULT_TRANSFORM as ah, type DeserializeContext as ai, type DevelopSettings as aj, EMPTY_DISTANCE as ak, type ExportOptions as al, FREE_TRANSFORM_CONTENTS as am, FREE_TRANSFORM_MODES as an, type FillOptions as ao, type FreeTransformContent as ap, type FreeTransformHost as aq, type FreeTransformPreview as ar, GUIDED_FILTER_EPS as as, type GroupLayer as at, HISTOGRAM_BINS as au, type HistogramChannel as av, type HistoryEntryHandle as aw, type HueSaturationParams as ax, IMAGE_EDITOR_SCHEMA_VERSION as ay, type ImageAnnotation as az, type SerializedImageEditorState as b, type ShapeSelectionOptions as b$, type MixerStrokeInit as b0, PSD_BLEND_KEYS as b1, type PaintOptions as b2, type PaintStrokeResult as b3, PaintStrokeSession as b4, type PenAnnotation as b5, type PhotoFilterParams as b6, type PixelBuffer as b7, type PixelLayerInit as b8, type PosterizeParams as b9, type SerializeContext as bA, type SerializedAdjustmentLayer as bB, type SerializedAnnotationLayer as bC, type SerializedGroupLayer as bD, type SerializedLayerEffects as bE, type SerializedLayeredImageEditorState as bF, type SerializedPattern as bG, type SerializedPixelLayer as bH, type SerializedRasterMask as bI, type SerializedSelection as bJ, type SerializedShapeLayer as bK, type SerializedSmartContents as bL, type SerializedSmartFilter as bM, type SerializedSmartObjectLayer as bN, type ShapeArrowhead as bO, type ShapeComponent as bP, type ShapeEnv as bQ, type ShapeFillRule as bR, type ShapeGeometryInput as bS, type ShapeLayerData as bT, type ShapeLayerInfo as bU, type ShapeLayerInit as bV, type ShapeLineCap as bW, type ShapeLineJoin as bX, type ShapeOperation as bY, type ShapePaint as bZ, type ShapePsdData as b_, type PsdChannel as ba, type PsdExportInput as bb, type PsdFile as bc, type PsdHeader as bd, type PsdImportOptions as be, type PsdImportResult as bf, type PsdLayerMask as bg, type PsdLayerRecord as bh, type PsdLayerSummary as bi, type PsdRect as bj, type PsdResource as bk, type PsdSmartFilter as bl, type PsdTaggedBlock as bm, type PsdTreeNode as bn, type RectAnnotation as bo, type RemoveBackgroundHook as bp, type RemoveBackgroundOptions as bq, type RenderOptions as br, SELECTION_MODES as bs, SELECTION_MODIFY_OPS as bt, SHAPE_OPERATIONS as bu, SHAPE_RENDER_MARGIN as bv, type SampleOptions as bw, type SelectionChannel as bx, type SelectionCommandOptions as by, type SelectionModifyOp as bz, type AdjustmentLayer as c, expandCoverage as c$, type ShapeStroke as c0, type ShapeStrokeAlign as c1, type SmartFilterKind as c2, type SmartObjectInfo as c3, type SmartPsdData as c4, type StrokeInit as c5, type StrokeTool as c6, TONE_RANGE_PRESETS as c7, TRANSFORM_ANCHORS as c8, type TextAnnotation as c9, computeSelectionBounds as cA, contractCoverage as cB, cornersFromMatrix as cC, coverageToByte as cD, createSelectionMask as cE, createShapeLayer as cF, decodeLayerChannel as cG, decodeLayerMask as cH, decodeMergedImage as cI, decodePngDataUrl as cJ, decodeSelectionRle as cK, defaultShapeName as cL, depthMaskAlpha as cM, describeTransform as cN, deserializeEffects as cO, deserializeLayer as cP, deserializeLayers as cQ, deserializePatterns as cR, deserializeSelection as cS, developFilter as cT, distanceTransform as cU, duplicateLayer as cV, edgeWidth as cW, ellipsePoints as cX, ellipseSelection as cY, encodeSelectionRle as cZ, encodeSurface as c_, type ThresholdParams as ca, type ToneRangePreset as cb, type TransformParams as cc, type TransformReadout as cd, type VibranceParams as ce, type ViewportMetrics as cf, addLayerEffect as cg, addLayerFilter as ch, adjustmentNodeAsLayer as ci, anchorPoint as cj, annotationBlend as ck, annotationOfShape 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, clampCropToImage as cv, colorRange as cw, combineSelections as cx, componentPath as cy, computeHistogram as cz, type AdjustmentParamsMap as d, normalizeShapeStroke as d$, exportPsd as d0, featherCoverage as d1, flipCorners as d2, fullSelection as d3, geometryHomography as d4, getAnnotationBounds as d5, getCropCursor as d6, getRotatedSize as d7, getViewportMetrics as d8, getViewportProjection as d9, layerEffectsOf as dA, layerMaskCoverage as dB, layerMaskFromSelection as dC, layerMaskKey as dD, layerName as dE, layerTree as dF, layerTypeLabel as dG, liveComponent as dH, liveShapeSubpaths as dI, magicWand as dJ, mapCropHandle as dK, mapSubpaths as dL, matrixFromCorners as dM, matrixFromParams as dN, mergeShapeComponents as dO, migrateSerializedImageEditorState as dP, migrateToLayeredState as dQ, modifySelection as dR, moveLayer as dS, newLayerId as dT, normalizeAngle as dU, normalizeFilter as dV, normalizeLayerMask as dW, normalizeLiveShape as dX, normalizeRect as dY, normalizeRefineEdgeParams as dZ, normalizeShapePaint as d_, globalImageCache as da, greyMorphology as db, groupLayers as dc, guidePlanes as dd, guidedFilterColor as de, hasSurface as df, hasWarp as dg, hashMaskContent as dh, histogramPath as di, hitTestAnnotation as dj, hitTestCrop as dk, hueRange as dl, identityTransform as dm, imageToCanvasPoint as dn, importPsd as dp, invertSelection as dq, isActiveFilter as dr, isIdentityTransform as ds, isQuarterTurnSwapped as dt, isRenderedLayer as du, isSelectionEmpty as dv, isSelectionMode as dw, isSpatialFilter as dx, isTransformAnchor as dy, isValidWarp as dz, type AdjustmentLayerMask as e, smoothCoverage as e$, normalizeStoredAdjustments as e0, normalizeSubpaths as e1, offsetLayer as e2, offsetShape as e3, parseBlend as e4, parseColor as e5, parseSelectionMode as e6, pixelLayerBounds as e7, pixelLayers as e8, placeLayer as e9, resolveExternalAssets as eA, runLayerFilters as eB, selectionArea as eC, selectionFromCoverage as eD, selectionFromPixels as eE, selectionToCoverage as eF, selectionToPixels as eG, selectionValueAt as eH, serializeContents as eI, serializeEffects as eJ, serializeLayer as eK, serializeLayers as eL, serializeLayersExternal as eM, serializePatterns as eN, serializeSelection as eO, setLayerEffects as eP, setLayerEffectsEnabled as eQ, setLayerMask as eR, setLayerProperties as eS, shapeAsPixelLayer as eT, shapeFromAnnotation as eU, shapeGeometryBounds as eV, shapeLayers as eW, shapeOutline as eX, shapeRenderClip as eY, shiftCoverage as eZ, smartObjectLayers as e_, polygonCoverage as ea, polygonSelection as eb, presetWarp as ec, previewStep as ed, projectImagePoint as ee, projectImageRect as ef, projectMaskCoverage as eg, psdToLayers as eh, readPsd as ei, rectSelection as ej, referencePoint as ek, refineCoverage as el, refineEdgeHalo as em, refineSelection as en, removeLayer as eo, removeLayerEffect as ep, removeLayerFilter as eq, renderShape as er, renderShapeRect as es, requireLayer as et, requireOperation as eu, requireShapeLayer as ev, requireUnlocked as ew, rerenderShape as ex, resizePixels as ey, resizeSelection as ez, type AdjustmentLayerOf as f, srgb8ToLab as f0, toHex as f1, toneRange as f2, transformHomography as f3, transformMap as f4, transformShapeComponents as f5, transformedBox as f6, transformedPoint as f7, ungroupLayer as f8, unionRect as f9, unprojectCanvasPoint as fa, updateLayerEffect as fb, updateLayerFilter as fc, updateLayerMaskProps as fd, updateShapeLayer as fe, withNewIds as ff, writePsd as fg, ImageEditorController as g, 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 LayerFilter as s, type PixelLayer as t, type DevelopFilter as u, type ImageTransform as v, type ImageHistogram as w, type ImageProjection as x, type CompositorSources as y, LayerCompositor 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 TextShaper as O, type PsdExportResult as P, type TextFont 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, LayerOperationError 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, HISTOGRAM_BINS as aA, type HistogramChannel as aB, type HistoryEntryHandle as aC, type HueSaturationParams as aD, IMAGE_EDITOR_SCHEMA_VERSION as aE, type ImageAnnotation as aF, type ImageDimensions as aG, type ImageEditorAIHooks as aH, type ImageEditorFit as aI, type ImageEditorOptions as aJ, ImageEditorRenderer as aK, type ImageEditorState as aL, type ImageEditorTool as aM, type ImageLayerType as aN, type InpaintHook as aO, type InpaintOptions as aP, type InvertParams as aQ, LAYERED_SCHEMA_VERSION as aR, LIVE_SHAPE_KINDS as aS, type LaidChar as aT, type LaidFragment as aU, type LaidLine as aV, type LayerBase as aW, type LayerBlendMode as aX, type LayerFilterKind as aY, type LayerLocation as aZ, type LayerMaskProps as a_, type ColorBalanceParams as aa, type ColorBalanceTone as ab, type ColorRangeOptions as ac, type ColorRangeSample as ad, type CreateAnnotationPayload as ae, type CropHandle as af, type CurvesParams as ag, DEFAULT_ADJUSTMENTS as ah, DEFAULT_AUTO_LEADING as ai, DEFAULT_DEPTH_MASK as aj, DEFAULT_MITER_LIMIT as ak, DEFAULT_REFINE_EDGE_PARAMS as al, DEFAULT_TEXT_STYLE as am, DEFAULT_TRANSFORM as an, type DeserializeContext as ao, type DevelopSettings as ap, EMPTY_DISTANCE as aq, type ExportOptions as ar, FREE_TRANSFORM_CONTENTS as as, FREE_TRANSFORM_MODES as at, type FillOptions as au, type FreeTransformContent as av, type FreeTransformHost as aw, type FreeTransformPreview as ax, GUIDED_FILTER_EPS as ay, type GroupLayer as az, type SerializedImageEditorState as b, type ShapeArrowhead as b$, type LayerProperties as b0, type LayerSourcesHost as b1, type LayerTarget as b2, type LegacySerializedImageEditorState as b3, type LevelsParams as b4, type LineAnnotation as b5, type LiveShape as b6, type LiveShapeKind as b7, type MagicWandOptions as b8, type MixerStrokeInit as b9, type RectAnnotation as bA, type RemoveBackgroundHook as bB, type RemoveBackgroundOptions as bC, type RenderOptions 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 SerializedGroupLayer as bP, type SerializedLayerEffects as bQ, type SerializedLayeredImageEditorState as bR, type SerializedPattern as bS, type SerializedPixelLayer as bT, type SerializedRasterMask as bU, type SerializedSelection as bV, type SerializedShapeLayer as bW, type SerializedSmartContents as bX, type SerializedSmartFilter as bY, type SerializedSmartObjectLayer as bZ, type SerializedTypeLayer as b_, PARAGRAPH_STYLE_FIELDS as ba, PSD_BLEND_KEYS as bb, type PaintOptions as bc, type PaintStrokeResult as bd, PaintStrokeSession as be, type ParagraphRun as bf, type ParagraphStyle as bg, type PenAnnotation as bh, type PhotoFilterParams as bi, type PixelBuffer as bj, type PixelLayerInit as bk, type PosterizeParams as bl, type PsdChannel as bm, type PsdExportInput as bn, type PsdFile as bo, type PsdHeader as bp, type PsdImportOptions as bq, type PsdImportResult as br, type PsdLayerMask as bs, type PsdLayerRecord as bt, type PsdLayerSummary as bu, type PsdRect as bv, type PsdResource as bw, type PsdSmartFilter as bx, type PsdTaggedBlock as by, type PsdTreeNode as bz, type AdjustmentLayer as c, contractCoverage as c$, type ShapeComponent as c0, type ShapeEnv as c1, type ShapeFillRule as c2, type ShapeGeometryInput as c3, type ShapeLayerData as c4, type ShapeLayerInfo as c5, type ShapeLayerInit as c6, type ShapeLineCap as c7, type ShapeLineJoin as c8, type ShapeOperation as c9, type TypeLayerInfo as cA, type TypePsdData as cB, type VibranceParams as cC, type ViewportMetrics as cD, addLayerEffect as cE, addLayerFilter as cF, adjustmentNodeAsLayer as cG, anchorPoint as cH, annotationBlend as cI, annotationOfShape as cJ, annotationOfType as cK, applyImageProjectionToContext as cL, applyParams as cM, blurFilter as cN, borderCoverage as cO, boxMean as cP, boxPointOf as cQ, buildLayerMaskPlanes as cR, calculateCropDrag as cS, canvasToImagePoint as cT, caretAt as cU, clampCropToImage as cV, colorRange as cW, combineSelections as cX, componentPath as cY, computeHistogram as cZ, computeSelectionBounds as c_, type ShapePaint as ca, type ShapePsdData as cb, type ShapeSelectionOptions as cc, type ShapeStroke as cd, type ShapeStrokeAlign as ce, type SmartFilterKind as cf, type SmartObjectInfo as cg, type SmartPsdData as ch, type StrokeInit as ci, type StrokeTool as cj, TEXT_ALIGNS as ck, TEXT_RENDER_MARGIN as cl, TEXT_STYLE_FIELDS as cm, TONE_RANGE_PRESETS as cn, TRANSFORM_ANCHORS as co, type TextAlign as cp, type TextAnnotation as cq, type TextLayerInit as cr, type TextLayout as cs, type TextRun as ct, type TextStyle as cu, type ThresholdParams as cv, type ToneRangePreset as cw, type TransformParams as cx, type TransformReadout as cy, type TypeLayerData as cz, type AdjustmentParamsMap as d, isSpatialFilter as d$, cornersFromMatrix as d0, coverageToByte as d1, createSelectionMask as d2, createShapeLayer as d3, createTypeLayer as d4, decodeLayerChannel as d5, decodeLayerMask as d6, decodeMergedImage as d7, decodePngDataUrl as d8, decodeSelectionRle as d9, getAnnotationBounds as dA, getCropCursor as dB, getRotatedSize as dC, getViewportMetrics as dD, getViewportProjection as dE, globalImageCache as dF, greyMorphology as dG, groupLayers as dH, guidePlanes as dI, guidedFilterColor as dJ, hasSurface as dK, hasWarp as dL, hashMaskContent as dM, histogramPath as dN, hitTestAnnotation as dO, hitTestCrop as dP, hueRange as dQ, identityTransform as dR, imageToCanvasPoint as dS, importPsd as dT, invertSelection as dU, isActiveFilter as dV, isIdentityTransform as dW, isQuarterTurnSwapped as dX, isRenderedLayer as dY, isSelectionEmpty as dZ, isSelectionMode as d_, defaultShapeName as da, depthMaskAlpha as db, describeTransform as dc, deserializeEffects as dd, deserializeLayer as de, deserializeLayers as df, deserializePatterns as dg, deserializeSelection as dh, developFilter as di, distanceTransform as dj, duplicateLayer as dk, edgeWidth as dl, ellipsePoints as dm, ellipseSelection as dn, encodeSelectionRle as dp, encodeSurface as dq, expandCoverage as dr, exportPsd as ds, featherCoverage as dt, fitParagraphRuns as du, fitRuns as dv, flipCorners as dw, fontOf as dx, fullSelection as dy, geometryHomography as dz, type AdjustmentLayerMask as e, renderShapeRect as e$, isTransformAnchor as e0, isValidWarp as e1, layerEffectsOf as e2, layerMaskCoverage as e3, layerMaskFromSelection as e4, layerMaskKey as e5, layerName as e6, layerTree as e7, layerTypeLabel as e8, layoutText as e9, paragraphRanges as eA, parseBlend as eB, parseColor as eC, parseSelectionMode as eD, patchParagraphStyle as eE, patchTextStyle as eF, pixelLayerBounds as eG, pixelLayers as eH, placeLayer as eI, polygonCoverage as eJ, polygonSelection as eK, presetWarp as eL, previewStep as eM, projectImagePoint as eN, projectImageRect as eO, projectMaskCoverage as eP, psdToLayers as eQ, readPsd as eR, rectSelection as eS, referencePoint as eT, refineCoverage as eU, refineEdgeHalo as eV, refineSelection as eW, removeLayer as eX, removeLayerEffect as eY, removeLayerFilter as eZ, renderShape as e_, liveComponent as ea, liveShapeSubpaths as eb, magicWand as ec, mapCropHandle as ed, mapSubpaths as ee, matrixFromCorners as ef, matrixFromParams as eg, mergeShapeComponents as eh, migrateSerializedImageEditorState as ei, migrateToLayeredState as ej, modifySelection as ek, moveLayer as el, newLayerId as em, normalizeAngle as en, normalizeFilter as eo, normalizeLayerMask as ep, normalizeLiveShape as eq, normalizeRect as er, normalizeRefineEdgeParams as es, normalizeShapePaint as et, normalizeShapeStroke as eu, normalizeStoredAdjustments as ev, normalizeSubpaths as ew, normalizeText as ex, offsetLayer as ey, offsetShape as ez, type AdjustmentLayerOf as f, updateLayerEffect as f$, renderText as f0, replaceTextRange as f1, requireLayer as f2, requireOperation as f3, requireShapeLayer as f4, requireTypeLayer as f5, requireUnlocked as f6, rerenderShape as f7, rerenderText as f8, resizePixels as f9, shapeRenderClip as fA, shiftCoverage as fB, smartObjectLayers as fC, smoothCoverage as fD, spliceRuns as fE, srgb8ToLab as fF, styleAt as fG, textIndexAt 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_, resizeSelection as fa, resolveExternalAssets as fb, restyleRange as fc, runLayerFilters as fd, selectionArea as fe, selectionFromCoverage as ff, selectionFromPixels as fg, selectionToCoverage as fh, selectionToPixels as fi, selectionValueAt as fj, serializeContents as fk, serializeEffects as fl, serializeLayer as fm, serializeLayers as fn, serializeLayersExternal as fo, serializePatterns as fp, serializeSelection as fq, setLayerEffects as fr, setLayerEffectsEnabled as fs, setLayerMask as ft, setLayerProperties as fu, shapeAsPixelLayer as fv, shapeFromAnnotation as fw, shapeGeometryBounds as fx, shapeLayers as fy, shapeOutline 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 };