@pixerate/editor 0.189.0 → 0.191.0

package/dist/image-editor/layer-tools.d.cts

@@ -6,7 +6,7 @@ import type { CropBox } from './types.cjs';
 export declare function maskSummary(mask: RasterMask | undefined): Record<string, unknown> | null;
 /**
  * A plain description of a layer (and its children) for agents: ids, types, names, document
- * bounds, visibility, opacity, fill, blend, clipping, locks, mask and effects summaries and
+ * bounds, visibility, opacity, fill, blend, clipping, locks, mask, vector mask and effects summaries and
  * whether it is active. `boundsOf` gives a pixel layer's document bounds.
  */
 export declare function describeLayer(layer: ImageLayer, activeId: string | null, boundsOf: (layer: ImageLayer) => CropBox | null): Record<string, unknown>;

package/dist/image-editor/layer-tools.d.ts

@@ -6,7 +6,7 @@ import type { CropBox } from './types.js';
 export declare function maskSummary(mask: RasterMask | undefined): Record<string, unknown> | null;
 /**
  * A plain description of a layer (and its children) for agents: ids, types, names, document
- * bounds, visibility, opacity, fill, blend, clipping, locks, mask and effects summaries and
+ * bounds, visibility, opacity, fill, blend, clipping, locks, mask, vector mask and effects summaries and
  * whether it is active. `boundsOf` gives a pixel layer's document bounds.
  */
 export declare function describeLayer(layer: ImageLayer, activeId: string | null, boundsOf: (layer: ImageLayer) => CropBox | null): Record<string, unknown>;

package/dist/image-editor/layers/compositor.d.cts

@@ -42,6 +42,9 @@ export declare function runLayerFiltersFloat(data: Float32Array, width: number,
 /** The per-tile compositor for image editor layer stacks (see the raster module for the caches). */
 export declare class LayerCompositor extends RasterCompositor<ImageLayer, CompositorSources> {
     constructor(options?: CompositorOptions);
+    composite(layers: readonly ImageLayer[], rect: RasterRect, sources: CompositorSources, options?: CompositeCallOptions): Uint8ClampedArray;
+    compositeTiles(layers: readonly ImageLayer[], rect: RasterRect, sources: CompositorSources, onTile: (tx: number, ty: number, data: Uint8ClampedArray, changed: boolean) => void, options?: CompositeCallOptions): void;
+    tile(layers: readonly ImageLayer[], tx: number, ty: number, sources: CompositorSources): Uint8ClampedArray;
 }
 /**
  * The composite of an image editor stack at 16 or 32 bits (see `raster/deep-compositor`): float

package/dist/image-editor/layers/compositor.d.ts

@@ -42,6 +42,9 @@ export declare function runLayerFiltersFloat(data: Float32Array, width: number,
 /** The per-tile compositor for image editor layer stacks (see the raster module for the caches). */
 export declare class LayerCompositor extends RasterCompositor<ImageLayer, CompositorSources> {
     constructor(options?: CompositorOptions);
+    composite(layers: readonly ImageLayer[], rect: RasterRect, sources: CompositorSources, options?: CompositeCallOptions): Uint8ClampedArray;
+    compositeTiles(layers: readonly ImageLayer[], rect: RasterRect, sources: CompositorSources, onTile: (tx: number, ty: number, data: Uint8ClampedArray, changed: boolean) => void, options?: CompositeCallOptions): void;
+    tile(layers: readonly ImageLayer[], tx: number, ty: number, sources: CompositorSources): Uint8ClampedArray;
 }
 /**
  * The composite of an image editor stack at 16 or 32 bits (see `raster/deep-compositor`): float

package/dist/image-editor/layers/model.d.cts

@@ -28,6 +28,29 @@ export type { LayerLocks };
 export type RasterMask = BaseRasterMask<DepthMaskOptions>;
 export interface LayerBase extends RasterLayerBase {
     mask?: RasterMask;
+    /** A vector mask (Photoshop's): a path that reveals the layer, on top of `mask`. Not on shape layers. */
+    vectorMask?: VectorMask;
+}
+/**
+ * A vector mask: shape components in document pixels (the same paths shape layers use) that
+ * reveal the layer inside them (outside with `inverted`). It stays sharp at any size; the
+ * compositor multiplies it with the layer's raster mask. No components hides everything
+ * (reveals everything when inverted).
+ */
+export interface VectorMask {
+    components: ShapeComponent[];
+    /** How overlapping subpaths fill (default nonzero). */
+    fillRule?: ShapeFillRule;
+    /** Reveal outside the path instead (default false). */
+    inverted?: boolean;
+    /** Disabled masks are kept but ignored (default true). */
+    enabled?: boolean;
+    /** `false`: the path stays put when the layer moves or transforms (default true). */
+    linked?: boolean;
+    /** 0..1 (default 1): at 0.5 the hidden area still shows half. */
+    density?: number;
+    /** Gaussian feather σ in px (default 0). */
+    feather?: number;
 }
 /** The base sliders of the old document-level adjustments, as a filter on one layer. */
 export interface DevelopSettings {

package/dist/image-editor/layers/model.d.ts

@@ -28,6 +28,29 @@ export type { LayerLocks };
 export type RasterMask = BaseRasterMask<DepthMaskOptions>;
 export interface LayerBase extends RasterLayerBase {
     mask?: RasterMask;
+    /** A vector mask (Photoshop's): a path that reveals the layer, on top of `mask`. Not on shape layers. */
+    vectorMask?: VectorMask;
+}
+/**
+ * A vector mask: shape components in document pixels (the same paths shape layers use) that
+ * reveal the layer inside them (outside with `inverted`). It stays sharp at any size; the
+ * compositor multiplies it with the layer's raster mask. No components hides everything
+ * (reveals everything when inverted).
+ */
+export interface VectorMask {
+    components: ShapeComponent[];
+    /** How overlapping subpaths fill (default nonzero). */
+    fillRule?: ShapeFillRule;
+    /** Reveal outside the path instead (default false). */
+    inverted?: boolean;
+    /** Disabled masks are kept but ignored (default true). */
+    enabled?: boolean;
+    /** `false`: the path stays put when the layer moves or transforms (default true). */
+    linked?: boolean;
+    /** 0..1 (default 1): at 0.5 the hidden area still shows half. */
+    density?: number;
+    /** Gaussian feather σ in px (default 0). */
+    feather?: number;
 }
 /** The base sliders of the old document-level adjustments, as a filter on one layer. */
 export interface DevelopSettings {

package/dist/image-editor/layers/panel.d.cts

@@ -18,6 +18,16 @@ export declare function maskThumbnailClick(controller: ImageEditorController, la
     shiftKey?: boolean;
     altKey?: boolean;
 }): void;
+/**
+ * A click on a layer's vector mask thumbnail: Ctrl/⌘-click loads the path as the selection (Shift
+ * adds, Alt subtracts, both intersect) and Shift-click turns the vector mask on or off.
+ */
+export declare function vectorMaskThumbnailClick(controller: ImageEditorController, layer: ImageLayer, e: {
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+}): void;
 /**
  * A click on a layer's pixel thumbnail: Ctrl/⌘-click loads the layer's transparency as the
  * selection (Shift adds, Alt subtracts, both intersect) and returns true; other clicks are left
@@ -57,7 +67,7 @@ export type DropZone = 'above' | 'below' | 'inside';
 export declare function dropZone(fraction: number, isGroup: boolean): DropZone;
 /** The placement for `move_layer` when `dragId` is dropped on row `targetId` in `zone`, or `null` for a no-op. */
 export declare function dropPlacement(layers: readonly ImageLayer[], dragId: string, targetId: string, zone: DropZone): LayerPlacement | null;
-export type LayerMenuAction = 'new-layer' | 'new-group' | 'duplicate' | 'delete' | 'group-selected' | 'ungroup' | 'merge-down' | 'merge-visible' | 'flatten' | 'via-copy' | 'via-cut' | 'add-mask' | 'add-mask-selection' | 'add-mask-hide-selection' | 'add-mask-transparency' | 'select-transparency' | 'apply-mask' | 'delete-mask' | 'toggle-mask' | 'toggle-mask-link' | 'toggle-clip' | 'rasterize' | 'convert-smart' | 'edit-contents' | 'smart-via-copy' | 'add-filter-mask';
+export type LayerMenuAction = 'new-layer' | 'new-group' | 'duplicate' | 'delete' | 'group-selected' | 'ungroup' | 'merge-down' | 'merge-visible' | 'flatten' | 'via-copy' | 'via-cut' | 'add-mask' | 'add-vector-mask' | 'add-vector-mask-hide' | 'add-vector-mask-selection' | 'delete-vector-mask' | 'toggle-vector-mask' | 'rasterize-vector-mask' | 'add-mask-selection' | 'add-mask-hide-selection' | 'add-mask-transparency' | 'select-transparency' | 'apply-mask' | 'delete-mask' | 'toggle-mask' | 'toggle-mask-link' | 'toggle-clip' | 'rasterize' | 'convert-smart' | 'edit-contents' | 'smart-via-copy' | 'add-filter-mask';
 export interface LayerMenuItem {
     action: LayerMenuAction;
     label: string;

package/dist/image-editor/layers/panel.d.ts

@@ -18,6 +18,16 @@ export declare function maskThumbnailClick(controller: ImageEditorController, la
     shiftKey?: boolean;
     altKey?: boolean;
 }): void;
+/**
+ * A click on a layer's vector mask thumbnail: Ctrl/⌘-click loads the path as the selection (Shift
+ * adds, Alt subtracts, both intersect) and Shift-click turns the vector mask on or off.
+ */
+export declare function vectorMaskThumbnailClick(controller: ImageEditorController, layer: ImageLayer, e: {
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+}): void;
 /**
  * A click on a layer's pixel thumbnail: Ctrl/⌘-click loads the layer's transparency as the
  * selection (Shift adds, Alt subtracts, both intersect) and returns true; other clicks are left
@@ -57,7 +67,7 @@ export type DropZone = 'above' | 'below' | 'inside';
 export declare function dropZone(fraction: number, isGroup: boolean): DropZone;
 /** The placement for `move_layer` when `dragId` is dropped on row `targetId` in `zone`, or `null` for a no-op. */
 export declare function dropPlacement(layers: readonly ImageLayer[], dragId: string, targetId: string, zone: DropZone): LayerPlacement | null;
-export type LayerMenuAction = 'new-layer' | 'new-group' | 'duplicate' | 'delete' | 'group-selected' | 'ungroup' | 'merge-down' | 'merge-visible' | 'flatten' | 'via-copy' | 'via-cut' | 'add-mask' | 'add-mask-selection' | 'add-mask-hide-selection' | 'add-mask-transparency' | 'select-transparency' | 'apply-mask' | 'delete-mask' | 'toggle-mask' | 'toggle-mask-link' | 'toggle-clip' | 'rasterize' | 'convert-smart' | 'edit-contents' | 'smart-via-copy' | 'add-filter-mask';
+export type LayerMenuAction = 'new-layer' | 'new-group' | 'duplicate' | 'delete' | 'group-selected' | 'ungroup' | 'merge-down' | 'merge-visible' | 'flatten' | 'via-copy' | 'via-cut' | 'add-mask' | 'add-vector-mask' | 'add-vector-mask-hide' | 'add-vector-mask-selection' | 'delete-vector-mask' | 'toggle-vector-mask' | 'rasterize-vector-mask' | 'add-mask-selection' | 'add-mask-hide-selection' | 'add-mask-transparency' | 'select-transparency' | 'apply-mask' | 'delete-mask' | 'toggle-mask' | 'toggle-mask-link' | 'toggle-clip' | 'rasterize' | 'convert-smart' | 'edit-contents' | 'smart-via-copy' | 'add-filter-mask';
 export interface LayerMenuItem {
     action: LayerMenuAction;
     label: string;

package/dist/image-editor/layers/serialize.d.cts

@@ -40,9 +40,20 @@ interface SerializedLayerBase {
     blend: string;
     clipped?: boolean;
     mask?: SerializedRasterMask;
+    vectorMask?: SerializedVectorMask;
     locks?: LayerLocks;
     effects?: SerializedLayerEffects;
 }
+/** A stored vector mask: its components as JSON (document pixels) and its properties. */
+export interface SerializedVectorMask {
+    components: unknown[];
+    fillRule?: 'evenodd';
+    inverted?: true;
+    enabled?: false;
+    linked?: false;
+    density?: number;
+    feather?: number;
+}
 /** A layer's effects: the effect list as JSON plus the PSD block they came from (base64). */
 export interface SerializedLayerEffects {
     enabled: boolean;

package/dist/image-editor/layers/serialize.d.ts

@@ -40,9 +40,20 @@ interface SerializedLayerBase {
     blend: string;
     clipped?: boolean;
     mask?: SerializedRasterMask;
+    vectorMask?: SerializedVectorMask;
     locks?: LayerLocks;
     effects?: SerializedLayerEffects;
 }
+/** A stored vector mask: its components as JSON (document pixels) and its properties. */
+export interface SerializedVectorMask {
+    components: unknown[];
+    fillRule?: 'evenodd';
+    inverted?: true;
+    enabled?: false;
+    linked?: false;
+    density?: number;
+    feather?: number;
+}
 /** A layer's effects: the effect list as JSON plus the PSD block they came from (base64). */
 export interface SerializedLayerEffects {
     enabled: boolean;

package/dist/image-editor/layers/shape.d.cts

@@ -50,6 +50,11 @@ export declare function shapeGeometryBounds(layer: Pick<ShapeLayer, 'components'
     width: number;
     height: number;
 } | null;
+/**
+ * Coverage (0..1) of `components` over `rect`, filled with `rule` and combined by their ops;
+ * `inverted` covers the outside instead. Used for vector masks.
+ */
+export declare function componentsCoverage(components: readonly ShapeComponent[], rect: CropBox, rule?: ShapeFillRule, inverted?: boolean): Float32Array;
 /** Where a shape renders: the canvas grown by the margin. */
 export declare function shapeRenderClip(env: Pick<ShapeEnv, 'width' | 'height'>): CropBox;
 /**

package/dist/image-editor/layers/shape.d.ts

@@ -50,6 +50,11 @@ export declare function shapeGeometryBounds(layer: Pick<ShapeLayer, 'components'
     width: number;
     height: number;
 } | null;
+/**
+ * Coverage (0..1) of `components` over `rect`, filled with `rule` and combined by their ops;
+ * `inverted` covers the outside instead. Used for vector masks.
+ */
+export declare function componentsCoverage(components: readonly ShapeComponent[], rect: CropBox, rule?: ShapeFillRule, inverted?: boolean): Float32Array;
 /** Where a shape renders: the canvas grown by the margin. */
 export declare function shapeRenderClip(env: Pick<ShapeEnv, 'width' | 'height'>): CropBox;
 /**

package/dist/image-editor/layers/vector-mask.d.cts

@@ -0,0 +1,51 @@
+/**
+ * Vector masks: a path on a layer that reveals it (Photoshop's Layer › Vector Mask). The paths are
+ * shape components in document pixels; the compositor sees them through `resolveVectorMasks`, which
+ * gives each layer with a vector mask a raster mask that is its raster mask times the path's
+ * coverage, so the tile engine and its caches need nothing new.
+ */
+import type { CropBox } from '../types.cjs';
+import type { AffineMatrix } from '../../geom/types.cjs';
+import type { ImageLayer, RasterMask, VectorMask } from './model.cjs';
+/** Whether a vector mask takes part in compositing. */
+export declare function isActiveVectorMask(vm: VectorMask | undefined): vm is VectorMask;
+/**
+ * The vector mask's coverage (0..1) over the `width × height` canvas, with its feather and
+ * density applied.
+ */
+export declare function vectorMaskCoverage(vm: VectorMask, width: number, height: number): Float32Array;
+/**
+ * The raster mask a layer composites with: its raster mask times its vector mask (layer space,
+ * feather and density baked in), or the raster mask alone when there is no active vector mask.
+ * A depth (parametric) mask cannot be combined, so it wins.
+ */
+export declare function effectiveLayerMask(layer: ImageLayer, width: number, height: number): RasterMask | undefined;
+/**
+ * The stack as the compositor should see it: each layer with an active vector mask replaced by a
+ * copy whose `mask` is `effectiveLayerMask` (cached per layer object and canvas size, so the
+ * engine's tile caches keep working). Returns `layers` itself when there are none.
+ */
+export declare function resolveVectorMasks(layers: readonly ImageLayer[], width: number, height: number): readonly ImageLayer[];
+/** A vector mask moved by (dx, dy) document pixels. */
+export declare function offsetVectorMask(vm: VectorMask, dx: number, dy: number): VectorMask;
+/** A vector mask with its paths mapped by `f` (document space); `affine` keeps live shapes live. */
+export declare function transformVectorMask(vm: VectorMask, f: (p: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+}, affine?: AffineMatrix): VectorMask;
+/** A linked vector mask moved with its layer by (dx, dy); unlinked ones stay. */
+export declare function followLayerMove<T extends ImageLayer>(layer: T, dx: number, dy: number): T;
+/** Bounds of the area a vector mask's paths enclose (document pixels, the curves themselves, not their handles), or `null` when it has none. */
+export declare function vectorMaskBounds(vm: Pick<VectorMask, 'components'>): CropBox | null;
+/**
+ * A vector mask's thumbnail over the `width × height` canvas, at most `maxSide` px: grey RGBA,
+ * white where the path reveals (cached per mask object).
+ */
+export declare function vectorMaskThumbnail(vm: VectorMask, width: number, height: number, maxSide?: number): {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+};

package/dist/image-editor/layers/vector-mask.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Vector masks: a path on a layer that reveals it (Photoshop's Layer › Vector Mask). The paths are
+ * shape components in document pixels; the compositor sees them through `resolveVectorMasks`, which
+ * gives each layer with a vector mask a raster mask that is its raster mask times the path's
+ * coverage, so the tile engine and its caches need nothing new.
+ */
+import type { CropBox } from '../types.js';
+import type { AffineMatrix } from '../../geom/types.js';
+import type { ImageLayer, RasterMask, VectorMask } from './model.js';
+/** Whether a vector mask takes part in compositing. */
+export declare function isActiveVectorMask(vm: VectorMask | undefined): vm is VectorMask;
+/**
+ * The vector mask's coverage (0..1) over the `width × height` canvas, with its feather and
+ * density applied.
+ */
+export declare function vectorMaskCoverage(vm: VectorMask, width: number, height: number): Float32Array;
+/**
+ * The raster mask a layer composites with: its raster mask times its vector mask (layer space,
+ * feather and density baked in), or the raster mask alone when there is no active vector mask.
+ * A depth (parametric) mask cannot be combined, so it wins.
+ */
+export declare function effectiveLayerMask(layer: ImageLayer, width: number, height: number): RasterMask | undefined;
+/**
+ * The stack as the compositor should see it: each layer with an active vector mask replaced by a
+ * copy whose `mask` is `effectiveLayerMask` (cached per layer object and canvas size, so the
+ * engine's tile caches keep working). Returns `layers` itself when there are none.
+ */
+export declare function resolveVectorMasks(layers: readonly ImageLayer[], width: number, height: number): readonly ImageLayer[];
+/** A vector mask moved by (dx, dy) document pixels. */
+export declare function offsetVectorMask(vm: VectorMask, dx: number, dy: number): VectorMask;
+/** A vector mask with its paths mapped by `f` (document space); `affine` keeps live shapes live. */
+export declare function transformVectorMask(vm: VectorMask, f: (p: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+}, affine?: AffineMatrix): VectorMask;
+/** A linked vector mask moved with its layer by (dx, dy); unlinked ones stay. */
+export declare function followLayerMove<T extends ImageLayer>(layer: T, dx: number, dy: number): T;
+/** Bounds of the area a vector mask's paths enclose (document pixels, the curves themselves, not their handles), or `null` when it has none. */
+export declare function vectorMaskBounds(vm: Pick<VectorMask, 'components'>): CropBox | null;
+/**
+ * A vector mask's thumbnail over the `width × height` canvas, at most `maxSide` px: grey RGBA,
+ * white where the path reveals (cached per mask object).
+ */
+export declare function vectorMaskThumbnail(vm: VectorMask, width: number, height: number, maxSide?: number): {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+};

package/dist/image-editor/psd/import.d.cts

@@ -1,10 +1,3 @@
-/**
- * PSD / PSB → our layer tree. Everything the model holds maps directly (smart objects with their
- * embedded contents, placement, warp, smart filters and filter mask; shape layers with their
- * paths, fill, stroke and live shapes; type layers with their text, styles and Photoshop's pixels
- * until edited); everything else comes in as close as it can (fill layers as their stored pixels)
- * with a warning naming the layers.
- */
 import { type PsdAlphaChannel } from './channels.cjs';
 import type { ImageLayer, LayerBlendMode } from '../layers/model.cjs';
 import { type PsdFile } from './file.cjs';

package/dist/image-editor/psd/import.d.ts

@@ -1,10 +1,3 @@
-/**
- * PSD / PSB → our layer tree. Everything the model holds maps directly (smart objects with their
- * embedded contents, placement, warp, smart filters and filter mask; shape layers with their
- * paths, fill, stroke and live shapes; type layers with their text, styles and Photoshop's pixels
- * until edited); everything else comes in as close as it can (fill layers as their stored pixels)
- * with a warning naming the layers.
- */
 import { type PsdAlphaChannel } from './channels.js';
 import type { ImageLayer, LayerBlendMode } from '../layers/model.js';
 import { type PsdFile } from './file.js';

package/dist/image-editor/selection/index.d.cts

@@ -11,3 +11,4 @@ export * from './segmentation.cjs';
 export * from './stroke.cjs';
 export * from './channels.cjs';
 export * from './mask-files.cjs';
+export * from './path.cjs';

package/dist/image-editor/selection/index.d.ts

@@ -11,3 +11,4 @@ export * from './segmentation.js';
 export * from './stroke.js';
 export * from './channels.js';
 export * from './mask-files.js';
+export * from './path.js';

package/dist/image-editor/selection/path.d.cts

@@ -0,0 +1,37 @@
+/**
+ * Selections ⇄ paths (Photoshop's Make Work Path and Make Selection): a selection's outline traced
+ * into Bézier subpaths, and a path filled into a selection.
+ */
+import type { VectorSubpath } from '../../vector/types.cjs';
+import type { ShapeComponent, ShapeFillRule } from '../layers/model.cjs';
+import { type SelectionMask } from './mask.cjs';
+export interface SelectionToPathOptions {
+    /** How far (px) the path may stray from the outline (default 0.5; Photoshop's Make Work Path tolerance). */
+    tolerance?: number;
+    /** 0: straight sides and sharp corners; 1: as smooth as the outline allows (default 0.5). */
+    cornerRoundness?: number;
+    /** Islands and holes smaller than this many square pixels are left out (default 4). */
+    minArea?: number;
+    /** Coverage (0..255) where the outline runs (default 128, half selected). */
+    threshold?: number;
+}
+/**
+ * The outline of a selection as closed subpaths in document pixels (holes included, so fill them
+ * even-odd). Traced in the selection's bounds only; an empty selection gives none.
+ */
+export declare function selectionToSubpaths(mask: SelectionMask, options?: SelectionToPathOptions): VectorSubpath[];
+/** Subpaths as compact SVG path data (absolute, `precision` decimals). */
+export declare function subpathsToSvgPath(subpaths: readonly VectorSubpath[], precision?: number): string;
+export interface PathToSelectionOptions {
+    /** Feather radius in px applied after filling (default 0). */
+    feather?: number;
+    /** Soft edges (default true); false makes every pixel fully in or out. */
+    antiAlias?: boolean;
+    /** How overlapping subpaths fill (default nonzero). */
+    fillRule?: ShapeFillRule;
+}
+/**
+ * Make Selection: the area of `components` (document pixels, combined by their ops) over a
+ * `width × height` image, computed in the path's bounds only.
+ */
+export declare function pathToSelection(components: readonly ShapeComponent[], width: number, height: number, options?: PathToSelectionOptions): SelectionMask;

package/dist/image-editor/selection/path.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Selections ⇄ paths (Photoshop's Make Work Path and Make Selection): a selection's outline traced
+ * into Bézier subpaths, and a path filled into a selection.
+ */
+import type { VectorSubpath } from '../../vector/types.js';
+import type { ShapeComponent, ShapeFillRule } from '../layers/model.js';
+import { type SelectionMask } from './mask.js';
+export interface SelectionToPathOptions {
+    /** How far (px) the path may stray from the outline (default 0.5; Photoshop's Make Work Path tolerance). */
+    tolerance?: number;
+    /** 0: straight sides and sharp corners; 1: as smooth as the outline allows (default 0.5). */
+    cornerRoundness?: number;
+    /** Islands and holes smaller than this many square pixels are left out (default 4). */
+    minArea?: number;
+    /** Coverage (0..255) where the outline runs (default 128, half selected). */
+    threshold?: number;
+}
+/**
+ * The outline of a selection as closed subpaths in document pixels (holes included, so fill them
+ * even-odd). Traced in the selection's bounds only; an empty selection gives none.
+ */
+export declare function selectionToSubpaths(mask: SelectionMask, options?: SelectionToPathOptions): VectorSubpath[];
+/** Subpaths as compact SVG path data (absolute, `precision` decimals). */
+export declare function subpathsToSvgPath(subpaths: readonly VectorSubpath[], precision?: number): string;
+export interface PathToSelectionOptions {
+    /** Feather radius in px applied after filling (default 0). */
+    feather?: number;
+    /** Soft edges (default true); false makes every pixel fully in or out. */
+    antiAlias?: boolean;
+    /** How overlapping subpaths fill (default nonzero). */
+    fillRule?: ShapeFillRule;
+}
+/**
+ * Make Selection: the area of `components` (document pixels, combined by their ops) over a
+ * `width × height` image, computed in the path's bounds only.
+ */
+export declare function pathToSelection(components: readonly ShapeComponent[], width: number, height: number, options?: PathToSelectionOptions): SelectionMask;

package/dist/paint-editor/index.cjs

@@ -7,7 +7,7 @@ var _chunkZ64NRDEHcjs = require('../chunk-Z64NRDEH.cjs');
 
 
 
-var _chunkED4L4UD6cjs = require('../chunk-ED4L4UD6.cjs');
+var _chunk2UR4OX3Bcjs = require('../chunk-2UR4OX3B.cjs');
 require('../chunk-A2IS7EHE.cjs');
 
 
@@ -1653,11 +1653,11 @@ function header(state, options) {
   return out;
 }
 function serializePaintDocument(state, options = {}) {
-  const { layers, assets } = _chunkED4L4UD6cjs.serializeLayers.call(void 0, state.layers);
+  const { layers, assets } = _chunk2UR4OX3Bcjs.serializeLayers.call(void 0, state.layers);
   return { ...header(state, options), layers, assets };
 }
 async function serializePaintDocumentExternal(state, store, options = {}) {
-  const { layers, assets } = await _chunkED4L4UD6cjs.serializeLayersExternal.call(void 0, state.layers, store);
+  const { layers, assets } = await _chunk2UR4OX3Bcjs.serializeLayersExternal.call(void 0, state.layers, store);
   return { ...header(state, options), layers, assets };
 }
 function paintLayersOnly(layers, problems) {
@@ -1694,7 +1694,7 @@ function deserializePaintDocument(raw) {
   const canvas = normalizeCanvas({ width: r.width, height: r.height, dpi: _nullishCoalesce(r.dpi, () => ( void 0)) });
   const paper = _chunkYQ5C5BVKcjs.normalizePaper.call(void 0, _nullishCoalesce(r.paper, () => ( {})));
   const assets = r.assets && typeof r.assets === "object" ? r.assets : {};
-  const layers = paintLayersOnly(_chunkED4L4UD6cjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
+  const layers = paintLayersOnly(_chunk2UR4OX3Bcjs.deserializeLayers.call(void 0, r.layers, { assets, problems }), problems);
   const wanted = typeof r.activeLayerId === "string" ? r.activeLayerId : null;
   const activeLayerId = wanted && _chunkHGTDMKNEcjs.findLayer.call(void 0, layers, wanted) ? wanted : _nullishCoalesce(_optionalChain([_chunkHGTDMKNEcjs.flattenLayers.call(void 0, layers), 'access', _70 => _70.filter, 'call', _71 => _71((l) => l.type === "pixel"), 'access', _72 => _72.pop, 'call', _73 => _73(), 'optionalAccess', _74 => _74.id]), () => ( null));
   const wetEvents = Array.isArray(r.wetEvents) ? r.wetEvents.filter((e) => e && typeof e === "object" && Number.isInteger(e.clock) && typeof e.kind === "string") : [];
@@ -1710,7 +1710,7 @@ async function deserializePaintDocumentAsync(raw, store) {
   if (!raw || typeof raw !== "object") throw new Error("Not a paint document: expected a JSON object.");
   const r = raw;
   const problems = [];
-  const assets = await _chunkED4L4UD6cjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
+  const assets = await _chunk2UR4OX3Bcjs.resolveExternalAssets.call(void 0, _nullishCoalesce(r.assets, () => ( {})), store, problems);
   const loaded = deserializePaintDocument({ ...r, assets });
   return { ...loaded, problems: [...problems, ...loaded.problems] };
 }
@@ -5409,7 +5409,7 @@ var PaintEditorController = (_class10 = class _PaintEditorController {
       return next.type === "group" ? { ...next, children: toStandard(next.children) } : next;
     });
     const layers = toStandard(dried);
-    const result = _chunkED4L4UD6cjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
+    const result = _chunk2UR4OX3Bcjs.exportPsd.call(void 0, { width, height, layers: [paperLayer, ...layers], merged, resolution: dpi });
     for (const [mode, names] of changed) {
       const label = _nullishCoalesce(_optionalChain([_chunkCWM3CUUXcjs.BLEND_MODES, 'access', _271 => _271.find, 'call', _272 => _272((m) => m.id === mode), 'optionalAccess', _273 => _273.label]), () => ( mode));
       const std = _nullishCoalesce(_optionalChain([_chunkCWM3CUUXcjs.BLEND_MODES, 'access', _274 => _274.find, 'call', _275 => _275((m) => m.id === _chunkCWM3CUUXcjs.standardBlendMode.call(void 0, mode)), 'optionalAccess', _276 => _276.label]), () => ( _chunkCWM3CUUXcjs.standardBlendMode.call(void 0, mode)));

package/dist/paint-editor/index.js

@@ -7,7 +7,7 @@ import {
   resolveExternalAssets,
   serializeLayers,
   serializeLayersExternal
-} from "../chunk-ZEHTUR7Z.js";
+} from "../chunk-TXYXF32N.js";
 import "../chunk-3CI7FRMK.js";
 import {
   EffectRendererPool