@pixerate/editor 0.108.0 → 0.109.0

package/dist/{chunk-JK6M6V7G.js → chunk-Z3YWVUWT.js}

@@ -1,10 +1,10 @@
-import {
-  mixColorsOklab
-} from "./chunk-ZRJMJIQU.js";
 import {
   evaluateEasing,
   isAnimationEasing
 } from "./chunk-AGR4P4UZ.js";
+import {
+  mixColorsOklab
+} from "./chunk-ZRJMJIQU.js";
 
 // src/animation/keyframes.ts
 var ANIMATION_TIME_EPSILON = 1e-6;
@@ -384,4 +384,4 @@ export {
   AnimationPlayer,
   createAnimationPlayer
 };
-//# sourceMappingURL=chunk-JK6M6V7G.js.map
+//# sourceMappingURL=chunk-Z3YWVUWT.js.map

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

@@ -1,7 +1,9 @@
-import { e as RasterLayerBase, f as RasterMask$1, b as RasterPixelLayer, G as GroupBlendMode, g as GlobalLight, E as EffectPattern, I as Interpolation, h as LayerLocation$1, L as LayerLocks, i as LayerEffect, j as LayerEffects, d as RasterSources, c as RasterCompositor, k as CompositorOptions, l as LayerEffectKind } from './compositor-Kt_M4ruo.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-OLIMk_v0.js';
 import { P as PixelSurface, B as BlendMode, a as TiledSurface } from './surface-CkKOHGPm.js';
-import { Q as Quad, a as WarpMesh, V as Vec2, A as AffineMatrix, H as Homography } from './types-CwMPoRMU.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 { W as WarpPreset } from './warp-CWHZzE3x.js';
 
 /**
@@ -93,7 +95,8 @@ declare function deserializeSelection(value: unknown): SelectionMask;
 declare function hashMaskContent(content: string | Uint8Array): string;
 
 /**
- * The image editor's layer stack: pixel, adjustment, group and annotation layers in one ordered
+ * The image editor's layer stack: pixel, adjustment, group, shape, smart object and annotation
+ * layers in one ordered
  * tree (bottom to top), all in document space (natural pixels of the document).
  *
  * Layer objects are immutable. Every change builds new objects along the path from the root to
@@ -167,6 +170,157 @@ interface AnnotationLayer extends LayerBase {
     type: 'annotation';
     annotation: Annotation;
 }
+/**
+ * How a shape component combines with the result of the components below it (Photoshop's path
+ * operations): `combine` (union), `subtract` (front minus), `intersect` and `exclude` (xor). The
+ * first component always combines, whatever it says.
+ */
+type ShapeOperation = 'combine' | 'subtract' | 'intersect' | 'exclude';
+declare const SHAPE_OPERATIONS: readonly ShapeOperation[];
+/** Winding rule a component's subpaths are filled with. */
+type ShapeFillRule = 'nonzero' | 'evenodd';
+/**
+ * What a shape's fill or stroke paints with: a solid colour, a gradient or a pattern (the fills of
+ * layer effects; gradients aligned with the layer use the shape's bounds), at `opacity` (0..1,
+ * missing = 1).
+ */
+type ShapePaint = EffectFill & {
+    opacity?: number;
+};
+type ShapeStrokeAlign = 'inside' | 'center' | 'outside';
+type ShapeLineCap = 'butt' | 'round' | 'square';
+type ShapeLineJoin = 'miter' | 'round' | 'bevel';
+/** A shape's stroke (Photoshop's shape Stroke options, not the layer-style stroke). */
+interface ShapeStroke {
+    /** Width in document pixels. */
+    width: number;
+    paint: ShapePaint;
+    /** Where the stroke sits on the outline (default `center`; open paths always stroke centred). */
+    align?: ShapeStrokeAlign;
+    /** Default `butt`. */
+    cap?: ShapeLineCap;
+    /** Default `miter`. */
+    join?: ShapeLineJoin;
+    /** Miter length over width above which a miter is bevelled (default 100, as Photoshop). */
+    miterLimit?: number;
+    /** Dash and gap lengths in multiples of the width (Photoshop's convention); missing or empty = solid. */
+    dashes?: number[];
+    /** Distance into the dash pattern at the start, in multiples of the width. */
+    dashOffset?: number;
+}
+/** An arrowhead of a live line: a triangle (notched by `concavity`) whose tip is the line's end. */
+interface ShapeArrowhead {
+    /** Width across the base, document pixels. */
+    width: number;
+    /** Length from the base to the tip, document pixels. */
+    length: number;
+    /** Notch of the base towards the tip as a fraction of `length` (-0.5..0.5, default 0). */
+    concavity?: number;
+}
+interface LiveShapeBase {
+    /**
+     * Where the shape's own frame lands in the document (an affine map, missing = identity): live
+     * shapes keep their parameters through moves, rotations and scales.
+     */
+    transform?: AffineMatrix;
+}
+/**
+ * A parametric ("live") shape a component was drawn as, kept so it stays editable as that shape
+ * (Photoshop's live shape properties). The component's subpaths are always the shape it
+ * describes; editing the subpaths directly drops it.
+ */
+type LiveShape = (LiveShapeBase & {
+    kind: 'rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Corner radii in pixels: top-left, top-right, bottom-right, bottom-left (missing = square). */
+    radii?: [number, number, number, number];
+}) | (LiveShapeBase & {
+    kind: 'ellipse';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}) | (LiveShapeBase & {
+    kind: 'polygon';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    sides: number;
+}) | (LiveShapeBase & {
+    kind: 'star';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    points: number;
+    /** Inner radius over outer radius, 0..1. */
+    innerRatio: number;
+}) | (LiveShapeBase & {
+    kind: 'line';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    /** Thickness of the bar in pixels (a line shape is a filled bar, as in Photoshop). */
+    weight: number;
+    startArrow?: ShapeArrowhead | null;
+    endArrow?: ShapeArrowhead | null;
+});
+type LiveShapeKind = LiveShape['kind'];
+declare const LIVE_SHAPE_KINDS: readonly LiveShapeKind[];
+/** One shape component: subpaths filled together (with the layer's fill rule), combined by `op`. */
+interface ShapeComponent {
+    op: ShapeOperation;
+    /** Document pixels; handles are absolute positions (the vector editor's anchors). */
+    subpaths: VectorSubpath[];
+    live?: LiveShape;
+}
+/** 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. */
+    blocks?: Array<{
+        key: string;
+        data: Uint8Array;
+    }>;
+}
+/**
+ * A shape layer: vector components with a fill and a stroke. `surface` is the rendered result in
+ * document space (offset 0), rebuilt from the components by every change, so it never degrades
+ * however often the shape is moved or transformed; the compositor draws it like a pixel layer's
+ * pixels, and masks, effects, clipping and blend apply on top. Never paint into it: rasterize the
+ * layer first.
+ */
+interface ShapeLayer extends LayerBase {
+    type: 'shape';
+    /** Bottom (first) to top. */
+    components: ShapeComponent[];
+    /** Default `nonzero`. */
+    fillRule?: ShapeFillRule;
+    /** `null`: no fill. */
+    fill: ShapePaint | null;
+    /** `null`: no stroke. */
+    stroke: ShapeStroke | null;
+    /** The rendered pixels (a cache of the components, fill and stroke), document space. */
+    surface: PixelSurface;
+    /** Always (0, 0): a shape moves through its geometry. */
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** 0..1, PSD "Fill" (missing = 1). */
+    fillOpacity?: number;
+    /**
+     * The annotation this layer was migrated from (pen, rectangle, ellipse, line, arrow), while the
+     * shape is still exactly that annotation: the `annotations` compatibility view and
+     * `updateAnnotation` read and edit it. Shape edits drop it.
+     */
+    annotation?: Annotation;
+    psd?: ShapePsdData;
+}
 /** 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`. */
@@ -282,7 +436,7 @@ interface SmartObjectLayer extends LayerBase {
     fillOpacity?: number;
     psd?: SmartPsdData;
 }
-type ImageLayer = PixelLayer | AdjustmentLayerNode | GroupLayer | AnnotationLayer | SmartObjectLayer;
+type ImageLayer = PixelLayer | AdjustmentLayerNode | GroupLayer | AnnotationLayer | SmartObjectLayer | ShapeLayer;
 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';
@@ -303,8 +457,12 @@ 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 and smart objects). */
-declare function hasSurface(layer: ImageLayer): layer is PixelLayer | SmartObjectLayer;
+/** 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;
+/** 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[];
 
@@ -439,7 +597,25 @@ interface SerializedSmartContents {
         path: string;
     };
 }
-type SerializedLayer = SerializedPixelLayer | SerializedAdjustmentLayer | SerializedGroupLayer | SerializedAnnotationLayer | SerializedSmartObjectLayer;
+/** A shape layer: its vector data (the pixels are rendered again on load). */
+interface SerializedShapeLayer extends SerializedLayerBase {
+    type: 'shape';
+    components: ShapeComponent[];
+    fillRule?: 'evenodd';
+    fill: ShapePaint | null;
+    stroke: ShapeStroke | null;
+    fillOpacity?: number;
+    /** The annotation the layer was migrated from, while it still is that annotation. */
+    annotation?: Annotation;
+    /** PSD blocks kept for round trips (base64). */
+    psd?: {
+        blocks: Array<{
+            key: string;
+            data: string;
+        }>;
+    };
+}
+type SerializedLayer = SerializedPixelLayer | SerializedAdjustmentLayer | SerializedGroupLayer | SerializedAnnotationLayer | SerializedSmartObjectLayer | SerializedShapeLayer;
 /** A version 3 document (layers). */
 interface SerializedLayeredImageEditorState {
     version: 3;
@@ -546,6 +722,8 @@ interface DeserializeContext {
     };
     /** Problems found while reading (unknown kinds, broken assets); the rest still loads. */
     problems: string[];
+    /** The document's patterns by id, for shapes painted with one. */
+    pattern?(id: string): EffectPattern | null;
 }
 /** Decodes a PNG data URL into pixels of `channels` bytes each. */
 declare function decodePngDataUrl(url: string, channels: 1 | 4): {
@@ -1411,6 +1589,118 @@ declare function psdToLayers(file: PsdFile, options?: PsdImportOptions): PsdImpo
 /** Parses and maps PSD / PSB bytes. Throws `PsdError` for files that cannot be read at all. */
 declare function importPsd(bytes: Uint8Array, options?: PsdImportOptions): PsdImportResult;
 
+/**
+ * Shape layers: vector components with a fill and a stroke, rendered without a canvas into the
+ * layer's `surface` (document space) by every change, so the compositor, effects, masks, clipping,
+ * thumbnails and export see them like pixel layers while the vectors stay exact.
+ *
+ * Geometry comes from the vector editor (anchors with absolute handles and live corners, shape
+ * factories) and the curve path operations (booleans, stroke outlines). Following Photoshop, each
+ * component's subpaths are filled together with the layer's fill rule, and the components are
+ * folded in order with their operation (the first one always combines). The stroke follows the
+ * outline of the combined area, centred, inside or outside it.
+ */
+
+/** How far beyond the canvas a shape is rendered (effects can reach this far into the canvas). */
+declare const SHAPE_RENDER_MARGIN = 512;
+/** Photoshop's default miter limit (effectively always mitered). */
+declare const DEFAULT_MITER_LIMIT = 100;
+/** What rendering needs besides the layer. */
+interface ShapeEnv {
+    /** Canvas size: the render covers it grown by `SHAPE_RENDER_MARGIN`. */
+    width: number;
+    height: number;
+    /** A document pattern by id (built-in patterns are found without it). */
+    pattern?(id: string): EffectPattern | null;
+}
+/** Subpaths with every anchor and handle mapped by `f` (live corners are cut first, then mapped). */
+declare function mapSubpaths(subpaths: readonly VectorSubpath[], f: (p: Vec2) => Vec2): VectorSubpath[];
+/** The subpaths a live shape describes, in document pixels. */
+declare function liveShapeSubpaths(live: LiveShape): VectorSubpath[];
+/** A component drawn as a live shape. */
+declare function liveComponent(live: LiveShape, op?: ShapeOperation): ShapeComponent;
+/** A component as Bézier commands (live corners cut). */
+declare function componentPath(c: ShapeComponent): BezierPath;
+/**
+ * The outline of the combined area (every component folded in with its operation) as one clean
+ * path. A single component comes back as its own path (open subpaths stay open, for stroking).
+ */
+declare function shapeOutline(components: readonly ShapeComponent[], fillRule?: ShapeFillRule): BezierPath;
+/** Bounds of the shape's geometry (the combined components, not the stroke), or `null`. */
+declare function shapeGeometryBounds(layer: Pick<ShapeLayer, 'components'>): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+/** Where a shape renders: the canvas grown by the margin. */
+declare function shapeRenderClip(env: Pick<ShapeEnv, 'width' | 'height'>): CropBox;
+/**
+ * Straight RGBA bytes of the shape over `rect`: the fill (its coverage × paint), then the stroke
+ * over it (centred, or clipped to the inside or outside of the fill area). `null` when empty.
+ */
+declare function renderShapeRect(layer: ShapeLayer, rect: CropBox, env: ShapeEnv, ctx?: EffectContext): Uint8ClampedArray | null;
+/**
+ * Renders a shape layer into a document-space surface (offset 0), tile by tile, over the canvas
+ * grown by `SHAPE_RENDER_MARGIN` (or only `clip`, for previews).
+ */
+declare function renderShape(layer: ShapeLayer, env: ShapeEnv, options?: {
+    clip?: CropBox;
+}): PixelSurface;
+/** The layer with its `surface` rendered again from its components. */
+declare function rerenderShape(layer: ShapeLayer, env: ShapeEnv): ShapeLayer;
+/**
+ * A paint from loose input: a CSS colour string (`#rrggbb`, `#rrggbbaa`, `rgb()`, a name; its
+ * alpha becomes the opacity), `{ type: 'color', color, opacity? }`, `{ type: 'gradient',
+ * gradient, opacity? }` or `{ type: 'pattern', patternId, scale?, angle?, link?, phase?, opacity? }`.
+ */
+declare function normalizeShapePaint(v: unknown, path?: string): ShapePaint;
+/** A stroke from loose input (`width` and `paint` required; the rest default as Photoshop). */
+declare function normalizeShapeStroke(v: unknown, path?: string, base?: ShapeStroke | null): ShapeStroke;
+/** A live shape from loose input (`kind` plus its fields), validated. */
+declare function normalizeLiveShape(v: unknown, path?: string): LiveShape;
+/** Subpaths from loose input: `[{ anchors: [{ x, y, in?, out? }], closed }]` or SVG path data. */
+declare function normalizeSubpaths(v: unknown, path?: string): VectorSubpath[];
+declare function requireOperation(v: unknown, path?: string): ShapeOperation;
+/** The shape layer with `id`, or an error saying what it is instead. */
+declare function requireShapeLayer(layers: readonly ImageLayer[], id: string): ShapeLayer;
+interface ShapeLayerData {
+    name?: string;
+    components: ShapeComponent[];
+    fill?: ShapePaint | null;
+    stroke?: ShapeStroke | null;
+    fillRule?: ShapeFillRule;
+    visible?: boolean;
+    opacity?: number;
+    blend?: BlendMode;
+}
+/** A new shape layer, rendered. */
+declare function createShapeLayer(init: ShapeLayerData, env: ShapeEnv, id?: string): ShapeLayer;
+/** The default name of a shape layer (Photoshop names them by tool). */
+declare function defaultShapeName(c: ShapeComponent | undefined): string;
+/** Replaces a shape layer's data (dropping the migrated annotation) and renders it again. */
+declare function updateShapeLayer(layers: readonly ImageLayer[], id: string, change: (layer: ShapeLayer) => Partial<ShapeLayer>, env: ShapeEnv, action?: string): {
+    layers: ImageLayer[];
+    layer: ShapeLayer;
+};
+/** Moves every component of a shape by `f` (a document-space point map); `affine` keeps live shapes live. */
+declare function transformShapeComponents(components: readonly ShapeComponent[], f: (p: Vec2) => Vec2, affine?: AffineMatrix): ShapeComponent[];
+/** A shape moved by (dx, dy), rendered again. */
+declare function offsetShape(layer: ShapeLayer, dx: number, dy: number, env: ShapeEnv): ShapeLayer;
+/** Merge Shape Components: the combined area as one `combine` component (live shapes become paths). */
+declare function mergeShapeComponents(components: readonly ShapeComponent[], fillRule?: ShapeFillRule): ShapeComponent[];
+/** A shape layer as a pixel layer with what it shows now (same id, name, mask, effects, blend). */
+declare function shapeAsPixelLayer(layer: ShapeLayer): PixelLayer;
+/**
+ * The shape an annotation draws (pen, rectangle, ellipse, line, arrow), exactly as the canvas drew
+ * it, or `null` for annotations that are not shapes (text, image) or use a colour we can't read.
+ */
+declare function shapeFromAnnotation(a: Annotation): Pick<ShapeLayer, 'components' | 'fill' | 'stroke'> | null;
+/** The blend a migrated layer draws with: the annotation's own unless the layer set one. */
+declare function annotationBlend(a: Annotation, layerBlend: string): BlendMode;
+/** The annotation a migrated shape layer still is (its blend read from the layer). */
+declare function annotationOfShape(layer: ShapeLayer): Annotation | null;
+
 /**
  * Free Transform geometry for the image editor, as pure functions both the UI bindings and the
  * agent tools use: a transform is the frame being transformed (`box`, document pixels), where its
@@ -1457,11 +1747,11 @@ declare function isIdentityTransform(geometry: FreeTransformGeometry): boolean;
  * The forward map of the whole transform (document pixels of the source → document pixels of the
  * result): the warp over the box, then the corner map. `null` where it is undefined.
  */
-declare function transformMap(geometry: FreeTransformGeometry): ((p: Vec2) => Vec2 | null) | null;
+declare function transformMap(geometry: FreeTransformGeometry): ((p: Vec2$1) => Vec2$1 | null) | null;
 /** A point of the transformed box at box fractions (`fx`, `fy`), warp included. */
-declare function transformedPoint(geometry: FreeTransformGeometry, fx: number, fy: number): Vec2 | null;
+declare function transformedPoint(geometry: FreeTransformGeometry, fx: number, fy: number): Vec2$1 | null;
 /** Where an anchor of the box is after the corner map (the warp ignored). */
-declare function anchorPoint(geometry: FreeTransformGeometry, anchor: TransformAnchor): Vec2;
+declare function anchorPoint(geometry: FreeTransformGeometry, anchor: TransformAnchor): Vec2$1;
 /** Bounds of the transformed result's outline (document pixels, not rounded). */
 declare function transformedBox(geometry: FreeTransformGeometry): CropBox | null;
 /** Free Transform as numbers, as Photoshop's options bar shows it. */
@@ -1480,10 +1770,10 @@ interface TransformParams {
     dx?: number;
     dy?: number;
     /** The fixed point of scale, skew and rotation: an anchor of the frame or a document point (default the centre). */
-    reference?: TransformAnchor | Vec2;
+    reference?: TransformAnchor | Vec2$1;
 }
 /** The reference point of params over a box (default its centre). */
-declare function referencePoint(box: CropBox, reference: TransformParams['reference']): Vec2;
+declare function referencePoint(box: CropBox, reference: TransformParams['reference']): Vec2$1;
 /**
  * The affine matrix of `params` over `box`: about the reference point, skew, then scale, then
  * rotate; then the move.
@@ -1521,7 +1811,7 @@ declare function applyParams(geometry: FreeTransformGeometry, params: TransformP
 /** Flip of the corners about the box's centre line (horizontal: left ↔ right). */
 declare function flipCorners(geometry: FreeTransformGeometry, axis: 'horizontal' | 'vertical'): Quad;
 /** Inverse of `matrixFromCorners` (box space → document) for mapping a document point back into the box. */
-declare function boxPointOf(geometry: FreeTransformGeometry, p: Vec2): Vec2 | null;
+declare function boxPointOf(geometry: FreeTransformGeometry, p: Vec2$1): Vec2$1 | null;
 /** A warp mesh from a preset over the box (null when it changes nothing). */
 declare function presetWarp(box: CropBox, preset: WarpPreset): WarpMesh | null;
 /** Validates a warp mesh for a box: well formed, finite, the right number of points. */
@@ -1595,6 +1885,8 @@ interface FreeTransformHost {
     };
     /** The pixels a pixel layer or smart object composites (the decoded source for the Background). */
     pixelsOf(layer: PixelLayer | SmartObjectLayer): TiledSurface;
+    /** What shape layers render with (canvas size, document patterns). */
+    shapeEnv(): ShapeEnv;
     /** Opaque pre-transform snapshot. */
     capture(): unknown;
     /** Shows a live state (no history). */
@@ -1630,6 +1922,9 @@ declare class FreeTransformSession {
     readonly startGeometry: FreeTransformGeometry;
     /** True when the layer is a smart object (the transform sets its placement). */
     readonly smartObject: boolean;
+    /** True when the layer is a shape layer (the transform maps its paths and renders them again). */
+    readonly shapeLayer: boolean;
+    private readonly shape;
     private geometryValue;
     private readonly smart;
     private readonly smartReduced;
@@ -1661,6 +1956,12 @@ declare class FreeTransformSession {
     }, preview?: FreeTransformPreview | false): FreeTransformGeometry;
     /** Resamples every part for the current geometry and shows it (or returns it, for commit). */
     private resample;
+    /**
+     * A shape with its paths mapped through the current geometry and rendered again (live shapes
+     * stay live under an affine map; perspective and warps turn them into plain paths). Previews
+     * render only the visible part.
+     */
+    private resampleShape;
     /** 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. */
@@ -1805,6 +2106,55 @@ interface PaintOptions {
     /** What the Mixer Brush carries now: its reservoir, how much is left and the picked-up colour. */
     mixerLoad: MixerLoad;
 }
+/**
+ * The geometry of one shape component: a live shape (`{ kind: 'rect' | 'ellipse' | 'polygon' |
+ * 'star' | 'line', … }`, see `LiveShape`) or subpaths (`[{ anchors: [{ x, y, in?, out? }],
+ * closed }]` or SVG path data), and how it combines with the components below it.
+ */
+interface ShapeGeometryInput {
+    shape?: LiveShape | Record<string, unknown>;
+    subpaths?: VectorSubpath[] | string;
+    /** Default `combine`. */
+    op?: ShapeOperation;
+}
+/** 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. */
+    components?: ShapeGeometryInput[];
+    name?: string;
+    /** 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;
+    fillRule?: ShapeFillRule;
+    opacity?: number;
+    blend?: BlendMode;
+}
+/** A shape layer as tools and panels read it. */
+interface ShapeLayerInfo {
+    id: string;
+    name: string;
+    /** Bottom to top; `index` is what component edits take. */
+    components: Array<{
+        index: number;
+        op: ShapeOperation;
+        live: LiveShape | null;
+        subpaths: VectorSubpath[];
+        bounds: CropBox | null;
+    }>;
+    fillRule: ShapeFillRule;
+    fill: ShapePaint | null;
+    stroke: ShapeStroke | null;
+    /** Bounds of the paths (document pixels, not rounded), or `null` when empty. */
+    geometryBounds: CropBox | null;
+    /** Bounds of the rendered pixels (stroke and antialiasing included). */
+    bounds: CropBox | null;
+    /** The annotation id while the layer is still the annotation it was migrated from. */
+    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. */
@@ -2040,7 +2390,7 @@ declare class ImageEditorController {
     private nextSourceId;
     /** Changes whenever the Background's source pixels can have changed. */
     private sourceVersion;
-    /** The pixels a pixel layer or smart object composites (the decoded source for the Background). */
+    /** The pixels a pixel layer, smart object or shape composites (the decoded source for the Background). */
     private surfaceOf;
     /**
      * The source image as a surface (cached): host-supplied sample pixels first, then the decoded
@@ -2576,11 +2926,20 @@ declare class ImageEditorController {
     /** Sets the depth mask (a parametric mask on the active pixel layer, or the Background) as one undo step. */
     setDepthMask(partial: Partial<DepthMaskOptions>): void;
     resetDepthMask(): void;
+    /** The layer showing annotation `id`: an annotation layer, or a shape layer migrated from it. */
     private annotationLayer;
-    /** Adds an annotation as its own layer (top of the stack unless `aboveId` is given). */
+    /**
+     * 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
+     * annotation (so `annotations` and `updateAnnotation` keep working); text and images stay
+     * annotation layers.
+     */
     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. */
+    private layerForAnnotation;
     removeAnnotation(id: string): void;
+    /** Deletes every annotation layer and every shape layer that still is the annotation it was migrated from. */
     clearAnnotations(): void;
     selectAnnotation(id: string | null): void;
     setZoom(zoom: number): void;
@@ -2659,6 +3018,48 @@ 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>;
+    /** What shape rendering needs: the canvas size and the document's patterns. */
+    private shapeEnv;
+    /** One component from tool or UI input (validated). */
+    private componentFrom;
+    private shapeInfo;
+    /** A shape layer's components, fill, stroke and bounds. */
+    getShapeLayer(id: string): ShapeLayerInfo;
+    /**
+     * Adds a shape layer (one undo step) and makes it active: a live shape or subpaths (or several
+     * `components`), filled with `fill` (default the foreground colour, except for a stroke-only
+     * open path) and stroked with `stroke`. Goes above the active layer unless placed. Returns its id.
+     */
+    addShapeLayer(init: ShapeLayerInit): string;
+    /**
+     * Sets a shape's fill, stroke or fill rule (one undo step unless `commitToHistory` is false):
+     * `fill` / `stroke` replace them (`null` removes); `stroke` given as a partial object changes
+     * only those settings of the current stroke. Returns the shape.
+     */
+    setShapeStyle(id: string, changes: {
+        fill?: ShapePaint | string | null;
+        stroke?: (Partial<ShapeStroke> & {
+            paint?: ShapePaint | string;
+            color?: string;
+        }) | null;
+        fillRule?: ShapeFillRule;
+    }, commitToHistory?: boolean): ShapeLayerInfo;
+    private componentIndex;
+    /**
+     * Changes one component (one undo step unless `commitToHistory` is false): its live shape
+     * (fields not given keep their values when the kind stays the same), its subpaths (which drops
+     * the live shape) or its operation. Returns the shape.
+     */
+    setShapeComponent(id: string, index: number, change: ShapeGeometryInput, commitToHistory?: boolean): ShapeLayerInfo;
+    /** Adds a component to a shape (path operations), on top unless `index` is given (one undo step). Returns the shape. */
+    addShapeComponent(id: string, spec: ShapeGeometryInput, index?: number): ShapeLayerInfo;
+    /** Removes one component of a shape (one undo step); the last one cannot go (delete the layer instead). Returns the shape. */
+    removeShapeComponent(id: string, index: number): ShapeLayerInfo;
+    /**
+     * Merge Shape Components: the area the components combine to becomes one plain component (live
+     * shapes become paths), as one undo step. Returns the shape.
+     */
+    mergeShapeComponents(id: string): ShapeLayerInfo;
     /**
      * Rasterize Layer: an annotation layer becomes a pixel layer with the same id, name and
      * properties (needs a canvas), and a pixel layer's filters are baked into its pixels. One undo
@@ -3151,4 +3552,4 @@ interface PsdExportResult {
 /** Writes the prepared stack as PSD (or PSB) bytes. */
 declare function exportPsd(input: PsdExportInput): PsdExportResult;
 
-export { type ArrowAnnotation as $, type AdjustmentKind as A, type SmartFilter as B, type CurvePoint as C, type DepthMaskOptions as D, type SmartObjectLayer as E, type SmartContents as F, type SmartDocument as G, type HueRange as H, type ImageEditorAssetStore as I, type SmartPlacement as J, type FreeTransformGeometry as K, type LevelsChannel as L, type LayerPlacement as M, type FreeTransformMode as N, type FreeTransformResult as O, type PsdExportResult as P, FreeTransformSession as Q, type RefineEdgeParams as R, type SerializedLayer as S, type FreeTransformInit as T, type TransformAnchor as U, type AIResultOptions as V, type AdjustmentLayerBase as W, type AdjustmentLayerInit as X, type AdjustmentLayerUpdate as Y, type AnnotationPlacement as Z, type AnnotationType as _, type ImageAdjustments as a, PaintStrokeSession as a$, type AspectRatio as a0, type BaseAnnotation as a1, type BlackWhiteParams as a2, type BlurFilter as a3, type CircleAnnotation as a4, type ColorBalanceParams as a5, type ColorBalanceTone as a6, type ColorRangeOptions as a7, type ColorRangeSample as a8, type CreateAnnotationPayload as a9, type ImageEditorFit as aA, type ImageEditorOptions as aB, ImageEditorRenderer as aC, type ImageEditorState as aD, type ImageEditorTool as aE, type ImageLayerType as aF, type InpaintHook as aG, type InpaintOptions as aH, type InvertParams as aI, LAYERED_SCHEMA_VERSION as aJ, type LayerBase as aK, type LayerBlendMode as aL, type LayerFilterKind as aM, type LayerLocation as aN, type LayerMaskProps as aO, LayerOperationError as aP, type LayerProperties as aQ, type LayerSourcesHost as aR, type LayerTarget as aS, type LegacySerializedImageEditorState as aT, type LevelsParams as aU, type LineAnnotation as aV, type MagicWandOptions as aW, type MixerStrokeInit as aX, PSD_BLEND_KEYS as aY, type PaintOptions as aZ, type PaintStrokeResult as a_, type CropHandle as aa, type CurvesParams as ab, DEFAULT_ADJUSTMENTS as ac, DEFAULT_DEPTH_MASK as ad, DEFAULT_REFINE_EDGE_PARAMS as ae, DEFAULT_TRANSFORM as af, type DeserializeContext as ag, type DevelopSettings as ah, EMPTY_DISTANCE as ai, type ExportOptions as aj, FREE_TRANSFORM_CONTENTS as ak, FREE_TRANSFORM_MODES as al, type FillOptions as am, type FreeTransformContent as an, type FreeTransformHost as ao, type FreeTransformPreview as ap, GUIDED_FILTER_EPS as aq, type GroupLayer as ar, HISTOGRAM_BINS as as, type HistogramChannel as at, type HistoryEntryHandle as au, type HueSaturationParams as av, IMAGE_EDITOR_SCHEMA_VERSION as aw, type ImageAnnotation as ax, type ImageDimensions as ay, type ImageEditorAIHooks as az, type SerializedImageEditorState as b, blurFilter as b$, type PenAnnotation as b0, type PhotoFilterParams as b1, type PixelBuffer as b2, type PixelLayerInit as b3, type PosterizeParams as b4, type PsdChannel as b5, type PsdExportInput as b6, type PsdFile as b7, type PsdHeader as b8, type PsdImportOptions as b9, type SerializedPixelLayer as bA, type SerializedRasterMask as bB, type SerializedSelection as bC, type SerializedSmartContents as bD, type SerializedSmartFilter as bE, type SerializedSmartObjectLayer as bF, type ShapeSelectionOptions as bG, type SmartFilterKind as bH, type SmartObjectInfo as bI, type SmartPsdData as bJ, type StrokeInit as bK, type StrokeTool as bL, TONE_RANGE_PRESETS as bM, TRANSFORM_ANCHORS as bN, type TextAnnotation as bO, type ThresholdParams as bP, type ToneRangePreset as bQ, type TransformParams as bR, type TransformReadout as bS, type VibranceParams as bT, type ViewportMetrics as bU, addLayerEffect as bV, addLayerFilter as bW, adjustmentNodeAsLayer as bX, anchorPoint as bY, applyImageProjectionToContext as bZ, applyParams as b_, type PsdImportResult as ba, type PsdLayerMask as bb, type PsdLayerRecord as bc, type PsdLayerSummary as bd, type PsdRect as be, type PsdResource as bf, type PsdSmartFilter as bg, type PsdTaggedBlock as bh, type PsdTreeNode as bi, type RectAnnotation as bj, type RemoveBackgroundHook as bk, type RemoveBackgroundOptions as bl, type RenderOptions as bm, SELECTION_MODES as bn, SELECTION_MODIFY_OPS as bo, type SampleOptions as bp, type SelectionChannel as bq, type SelectionCommandOptions as br, type SelectionModifyOp as bs, type SerializeContext as bt, type SerializedAdjustmentLayer as bu, type SerializedAnnotationLayer as bv, type SerializedGroupLayer as bw, type SerializedLayerEffects as bx, type SerializedLayeredImageEditorState as by, type SerializedPattern as bz, type AdjustmentLayer as c, isIdentityTransform as c$, borderCoverage as c0, boxMean as c1, boxPointOf as c2, buildLayerMaskPlanes as c3, calculateCropDrag as c4, canvasToImagePoint as c5, clampCropToImage as c6, colorRange as c7, combineSelections as c8, computeHistogram as c9, exportPsd as cA, featherCoverage as cB, flipCorners as cC, fullSelection as cD, geometryHomography as cE, getAnnotationBounds as cF, getCropCursor as cG, getRotatedSize as cH, getViewportMetrics as cI, getViewportProjection as cJ, globalImageCache as cK, greyMorphology as cL, groupLayers as cM, guidePlanes as cN, guidedFilterColor as cO, hasSurface as cP, hasWarp as cQ, hashMaskContent as cR, histogramPath as cS, hitTestAnnotation as cT, hitTestCrop as cU, hueRange as cV, identityTransform as cW, imageToCanvasPoint as cX, importPsd as cY, invertSelection as cZ, isActiveFilter as c_, computeSelectionBounds as ca, contractCoverage as cb, cornersFromMatrix as cc, coverageToByte as cd, createSelectionMask as ce, decodeLayerChannel as cf, decodeLayerMask as cg, decodeMergedImage as ch, decodePngDataUrl as ci, decodeSelectionRle as cj, depthMaskAlpha as ck, describeTransform as cl, deserializeEffects as cm, deserializeLayer as cn, deserializeLayers as co, deserializePatterns as cp, deserializeSelection as cq, developFilter as cr, distanceTransform as cs, duplicateLayer as ct, edgeWidth as cu, ellipsePoints as cv, ellipseSelection as cw, encodeSelectionRle as cx, encodeSurface as cy, expandCoverage as cz, type AdjustmentParamsMap as d, selectionToPixels as d$, isQuarterTurnSwapped as d0, isSelectionEmpty as d1, isSelectionMode as d2, isSpatialFilter as d3, isTransformAnchor as d4, isValidWarp as d5, layerEffectsOf as d6, layerMaskCoverage as d7, layerMaskFromSelection as d8, layerMaskKey as d9, polygonCoverage as dA, polygonSelection as dB, presetWarp as dC, previewStep as dD, projectImagePoint as dE, projectImageRect as dF, projectMaskCoverage as dG, psdToLayers as dH, readPsd as dI, rectSelection as dJ, referencePoint as dK, refineCoverage as dL, refineEdgeHalo as dM, refineSelection as dN, removeLayer as dO, removeLayerEffect as dP, removeLayerFilter as dQ, requireLayer as dR, requireUnlocked as dS, resizePixels as dT, resizeSelection as dU, resolveExternalAssets as dV, runLayerFilters as dW, selectionArea as dX, selectionFromCoverage as dY, selectionFromPixels as dZ, selectionToCoverage as d_, layerName as da, layerTree as db, layerTypeLabel as dc, magicWand as dd, mapCropHandle as de, matrixFromCorners as df, matrixFromParams as dg, migrateSerializedImageEditorState as dh, migrateToLayeredState as di, modifySelection as dj, moveLayer as dk, newLayerId as dl, normalizeAngle as dm, normalizeFilter as dn, normalizeLayerMask as dp, normalizeRect as dq, normalizeRefineEdgeParams as dr, normalizeStoredAdjustments as ds, offsetLayer as dt, parseBlend as du, parseColor as dv, parseSelectionMode as dw, pixelLayerBounds as dx, pixelLayers as dy, placeLayer as dz, type AdjustmentLayerMask as e, selectionValueAt as e0, serializeContents as e1, serializeEffects as e2, serializeLayer as e3, serializeLayers as e4, serializeLayersExternal as e5, serializePatterns as e6, serializeSelection as e7, setLayerEffects as e8, setLayerEffectsEnabled as e9, setLayerMask as ea, setLayerProperties as eb, shiftCoverage as ec, smartObjectLayers as ed, smoothCoverage as ee, srgb8ToLab as ef, toHex as eg, toneRange as eh, transformHomography as ei, transformMap as ej, transformedBox as ek, transformedPoint as el, ungroupLayer as em, unionRect as en, unprojectCanvasPoint as eo, updateLayerEffect as ep, updateLayerFilter as eq, updateLayerMaskProps as er, withNewIds as es, writePsd as et, type AdjustmentLayerOf as f, 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 LayerFilter as r, type PixelLayer as s, type DevelopFilter as t, type ImageTransform as u, type ImageHistogram as v, type ImageProjection as w, type CompositorSources as x, LayerCompositor as y, type SmartFilterStack as z };
+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 };