@pixerate/editor 0.110.0 → 0.112.0

package/dist/{export-DRiLzP_j.d.cts → export-DBba-buV.d.cts}

@@ -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-BEriFuqK.cjs';
 import { b as PixelSurface, B as BlendMode, a as TiledSurface } from './surface-C8RRg_Bh.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 { B as BezierPath } from './bezier-BfwIbVTl.cjs';
 import { W as WarpPreset } from './warp-D5jz_tN7.cjs';
 
 /**
@@ -281,11 +281,13 @@ interface ShapeComponent {
 }
 /** PSD data of a shape layer kept for round trips (see the PSD module). */
 interface ShapePsdData {
-    /** Additional-info blocks we do not model, by key, as read. */
+    /** The vector blocks as read (`vsms` / `vmsk`, `vscg`, `vstk`, `vogk`, fill blocks), by key. */
     blocks?: Array<{
         key: string;
         data: Uint8Array;
     }>;
+    /** The shape as it was read (`shapeSignature`): while unchanged, export writes `blocks` back as they were. */
+    signature?: string;
 }
 /**
  * A shape layer: vector components with a fill and a stroke. `surface` is the rendered result in
@@ -300,6 +302,8 @@ interface ShapeLayer extends LayerBase {
     components: ShapeComponent[];
     /** Default `nonzero`. */
     fillRule?: ShapeFillRule;
+    /** The fill covers everything except the combined area (Photoshop shapes whose first component subtracts). */
+    inverted?: boolean;
     /** `null`: no fill. */
     fill: ShapePaint | null;
     /** `null`: no stroke. */
@@ -321,6 +325,120 @@ 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. */
+    tySh?: Uint8Array;
+    /** The layer's text, styles, frame and transform as read (`typeSignature`). */
+    signature?: string;
+    /** 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 +554,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 +575,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
@@ -602,6 +947,7 @@ interface SerializedShapeLayer extends SerializedLayerBase {
     type: 'shape';
     components: ShapeComponent[];
     fillRule?: 'evenodd';
+    inverted?: true;
     fill: ShapePaint | null;
     stroke: ShapeStroke | null;
     fillOpacity?: number;
@@ -613,9 +959,37 @@ interface SerializedShapeLayer extends SerializedLayerBase {
             key: string;
             data: string;
         }>;
+        signature?: string;
     };
 }
-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;
+        }>;
+        signature?: string;
+    };
+}
+type SerializedLayer = SerializedPixelLayer | SerializedAdjustmentLayer | SerializedGroupLayer | SerializedAnnotationLayer | SerializedSmartObjectLayer | SerializedShapeLayer | SerializedTypeLayer;
 /** A version 3 document (layers). */
 interface SerializedLayeredImageEditorState {
     version: 3;
@@ -724,6 +1098,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): {
@@ -840,6 +1216,15 @@ interface RenderOptions {
         y: number;
         diameter: number;
     } | null;
+    /**
+     * On-canvas text editing (`TextEditSession.overlay()`): the caret as a segment, the selected
+     * ranges as quads and the text's frame, in natural pixels.
+     */
+    textEdit?: {
+        caret: [ImagePoint, ImagePoint] | null;
+        selection: ImagePoint[][];
+        frame: ImagePoint[] | null;
+    } | null;
     /** Free Transform's frame, handles and reference point in natural pixels (`FreeTransformTool.overlay()`). */
     freeTransform?: {
         outline: ImagePoint[];
@@ -1543,7 +1928,7 @@ declare const PSD_BLEND_KEYS: Record<string, LayerBlendMode>;
 interface PsdLayerSummary {
     name: string;
     /** Our layer type, or `null` when the layer was dropped. */
-    type: 'pixel' | 'adjustment' | 'group' | 'smart' | null;
+    type: 'pixel' | 'adjustment' | 'group' | 'smart' | 'shape' | 'type' | null;
     /** `mapped`: held exactly; `approximated`: imported with losses; `dropped`: left out. */
     status: 'mapped' | 'approximated' | 'dropped';
     /** What Photoshop calls it (`pixel`, `type`, `smart-object`, `fill`, `shape`, `Levels` …). */
@@ -1670,6 +2055,7 @@ interface ShapeLayerData {
     fill?: ShapePaint | null;
     stroke?: ShapeStroke | null;
     fillRule?: ShapeFillRule;
+    inverted?: boolean;
     visible?: boolean;
     opacity?: number;
     blend?: BlendMode;
@@ -1887,6 +2273,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 +2313,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 +2353,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. */
@@ -2117,6 +2513,11 @@ interface ShapeGeometryInput {
     /** Default `combine`. */
     op?: ShapeOperation;
 }
+/** A stroke as tools and UIs give it: any `ShapeStroke` fields, the paint as a colour string or a paint (or `color`). */
+type ShapeStrokeInput = Omit<Partial<ShapeStroke>, 'paint'> & {
+    paint?: ShapePaint | string;
+    color?: string;
+};
 /** A new shape layer: its geometry (one component, or `components`), fill and stroke. */
 interface ShapeLayerInit extends ShapeGeometryInput, LayerPlacement {
     /** Several components instead of `shape` / `subpaths`, bottom first. */
@@ -2125,10 +2526,7 @@ interface ShapeLayerInit extends ShapeGeometryInput, LayerPlacement {
     /** A colour string or a paint; `null` for none. Default the foreground colour (none for a stroke-only open path). */
     fill?: ShapePaint | string | null;
     /** `{ width, paint, align?, cap?, join?, miterLimit?, dashes?, dashOffset? }`, or `null` / missing for none. */
-    stroke?: (Partial<ShapeStroke> & {
-        paint?: ShapePaint | string;
-        color?: string;
-    }) | null;
+    stroke?: ShapeStrokeInput | null;
     fillRule?: ShapeFillRule;
     opacity?: number;
     blend?: BlendMode;
@@ -2155,6 +2553,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 +3383,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 +3393,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 +3475,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). */
@@ -3038,10 +3561,7 @@ declare class ImageEditorController {
      */
     setShapeStyle(id: string, changes: {
         fill?: ShapePaint | string | null;
-        stroke?: (Partial<ShapeStroke> & {
-            paint?: ShapePaint | string;
-            color?: string;
-        }) | null;
+        stroke?: ShapeStrokeInput | null;
         fillRule?: ShapeFillRule;
     }, commitToHistory?: boolean): ShapeLayerInfo;
     private componentIndex;
@@ -3081,6 +3601,11 @@ declare class ImageEditorController {
         height: number;
         summary: PsdImportResult['summary'];
     };
+    /**
+     * Type layers whose fonts the shaper lacks: they keep Photoshop's pixels, are marked with their
+     * `missingFonts`, and a warning names them (an edit draws them with a fallback).
+     */
+    private checkPsdFonts;
     /**
      * The document as an 8-bit RGB PSD (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
@@ -3395,7 +3920,11 @@ 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';
+type ImageEditorTool = 'select' | 'crop' | 'pen' | 'rect' | 'circle' | 'arrow' | 'line' | 'text' | 'watermark' | 'move' | 'brush' | 'eraser' | 'mixer'
+/** 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;
@@ -3499,6 +4028,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 +4088,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 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 };