@overtone-art/canvas-editor-core 0.4.0 → 0.5.1

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { Canvas, FabricObject, ImageFormat } from 'fabric';
-import { b as EditorEvents, m as LayerType, k as LayerMeta, L as LayerData, V as SerializedLayer, P as PatternConfig, H as PatternLocks, $ as TextCurveConfig, r as MaskPresetId, W as ShapeMaskPresetId, a0 as TextureMaskPresetId, a2 as Unit, G as MockupPrintArea, x as MockupConfig, e as FontDefinition, n as LicenseConfig, p as LicenseStatus, R as ProjectState, M as MaskBrushOptions, q as MaskPoint, t as MaskRefinementProvider, s as MaskRefinementPrompt, v as MaskRefinementResult, E as EditorConfig, X as ShapePlugin, Z as TemplateDefinition, I as ImageAdjustments, c as EditorState, T as SemanticExportOptions, Y as SvgExportOptions, O as PrintifyPositioning, N as NormalizedLayerPosition, K as PositioningAdapter, h as ImageProviderResult, i as ImageSearchOptions, j as ImageSearchResult, F as FileAdapter, g as ImageProvider, U as SerializedBackgroundImageOptions, B as BackgroundImageOptions, S as ResizeOptions, a as DpiIssue, l as LayerShadowConfig, C as CanvasSizePreset, y as MockupDisplacement } from './types-BNzE_X5M.mjs';
-export { D as DEFAULT_PATTERN_CONFIG, d as ExportFormat, f as ImageAttribution, o as LicensePayload, u as MaskRefinementRequest, w as MockupBlendMode, z as MockupDisplacementChannel, A as MockupOverlay, J as PatternState, Q as ProjectPage, _ as TemplateParameter, a1 as TileMode } from './types-BNzE_X5M.mjs';
+import { Canvas, FabricObject, Point, ImageFormat, Group } from 'fabric';
+import { b as EditorEvents, o as LayerType, m as LayerMeta, L as LayerData, X as SerializedLayer, P as PatternConfig, K as PatternLocks, a1 as TextCurveConfig, t as MaskPresetId, Y as ShapeMaskPresetId, a2 as TextureMaskPresetId, a4 as Unit, J as MockupPrintArea, z as MockupConfig, e as FontDefinition, p as LicenseConfig, r as LicenseStatus, T as ProjectState, M as MaskBrushOptions, s as MaskPoint, v as MaskRefinementProvider, u as MaskRefinementPrompt, x as MaskRefinementResult, k as LayerMaskEntry, l as LayerMaskMode, E as EditorConfig, Z as ShapePlugin, $ as TemplateDefinition, I as ImageAdjustments, c as EditorState, V as SemanticExportOptions, _ as SvgExportOptions, R as PrintifyPositioning, N as NormalizedLayerPosition, Q as PositioningAdapter, h as ImageProviderResult, i as ImageSearchOptions, j as ImageSearchResult, F as FileAdapter, g as ImageProvider, W as SerializedBackgroundImageOptions, B as BackgroundImageOptions, U as ResizeOptions, a as DpiIssue, n as LayerShadowConfig, C as CanvasSizePreset, A as MockupDisplacement } from './types-JP8MZsIs.mjs';
+export { D as DEFAULT_PATTERN_CONFIG, d as ExportFormat, f as ImageAttribution, q as LicensePayload, w as MaskRefinementRequest, y as MockupBlendMode, G as MockupDisplacementChannel, H as MockupOverlay, O as PatternState, S as ProjectPage, a0 as TemplateParameter, a3 as TileMode } from './types-JP8MZsIs.mjs';
 
 type EventHandler<T> = (data: T) => void;
 declare class EventEmitter<TEvents extends {} = Record<string, unknown>> {
@@ -210,6 +210,7 @@ declare class PatternManager {
     private history;
     private events;
     private proxies;
+    private readonly onObjectModified;
     private readonly onSourceModified;
     private readonly onLayerRemoved;
     constructor(canvas: Canvas, layers: LayerManager, history: HistoryManager, events: EventEmitter<EditorEvents>);
@@ -234,6 +235,14 @@ declare class PatternManager {
     /** Release every proxy and the offscreen snapshot it holds. */
     private clearProxies;
     private attach;
+    /**
+     * Fold a finished drag / scale / rotate on the proxy back into the pattern:
+     * position becomes the grid origin (carried by the source), scale becomes the
+     * tile scale, rotation becomes the pattern angle. Read the live transform
+     * first — writing the config re-fits the box and destroys it.
+     */
+    private commitGesture;
+    private area;
     private detach;
     private invalidateFor;
 }
@@ -244,38 +253,69 @@ declare class PatternManager {
  */
 declare function restoreLocks(obj: FabricObject, locks: PatternLocks | undefined): void;
 
+interface PatternArea {
+    width: number;
+    height: number;
+}
 /**
  * Renders a layer's source object repeated across the print area.
  *
  * This is a *render proxy*, not a layer: it is attached to the layer that owns
  * the source (see `LayerManager.setRenderProxy`) and never serialized. The
  * document keeps the real object — a `Textbox` stays a `Textbox` — so tiling is
- * non-destructive and every source edit simply shows up on the next render.
+ * non-destructive and every source edit shows up on the next render.
  *
- * The source is snapshotted to an offscreen canvas and blitted once per tile.
- * The snapshot is rebuilt whenever the source changes or the drawing context
- * gets sharper (a print export), so tiles are rasterised at export resolution
- * instead of being upscaled from a screen-sized bitmap.
+ * **Its box is one tile, its drawing is the whole area.** The object's own
+ * width/height/angle/position track the tile drawn at the grid origin (the
+ * "anchor" tile), so the selection frame the user grabs sits exactly on a tile
+ * they can see, while `_render` paints the full print area outside those bounds.
+ * That also makes the transform handles meaningful: dragging moves the grid,
+ * scaling is the tile scale, rotating is the pattern angle. The live transform
+ * is the truth during a gesture; `PatternManager` folds it back into the config
+ * when the gesture ends.
  */
 declare class TiledPatternObject extends FabricObject {
     static type: string;
     /** The layer's real object. Never rendered directly (it is kept at opacity 0). */
     source: FabricObject;
     config: PatternConfig;
+    /** The print area this pattern fills, in canvas units. */
+    area: PatternArea;
     private snapshotEl;
     private snapshotScale;
-    constructor(source: FabricObject, config: PatternConfig, width: number, height: number);
-    /** Swap in a new config; the next render picks it up. */
+    constructor(source: FabricObject, config: PatternConfig, area: PatternArea);
+    /** Swap in a new config and re-fit the box to the tile it now describes. */
     setConfig(config: PatternConfig): void;
-    /** Resize to a new print area. */
-    setArea(width: number, height: number): void;
-    /** Drop the cached source snapshot (e.g. the source was edited). */
+    /** Re-fit to a new print area (canvas resize). */
+    setArea(area: PatternArea): void;
+    /** Drop the cached source snapshot (the source was edited). */
     invalidate(): void;
     /** Free the offscreen snapshot. */
     dispose(): void;
+    /**
+     * Put the box back on the anchor tile: the tile's size, the pattern angle, and
+     * the grid origin displaced by the configured phase shift. Resets any live
+     * gesture scale, so it must run only once that gesture has been folded in.
+     */
+    syncBox(): void;
+    /** Grid rotation in play right now — the live handle during a rotate gesture. */
+    liveAngle(): number;
+    /** Tile scale in play right now, as a config percentage. */
+    liveScale(): number;
+    /**
+     * Where the source's centre would have to sit for the box to stay put — i.e.
+     * the grid origin implied by a drag. `PatternManager` moves the source there.
+     */
+    liveOrigin(): Point;
     _render(ctx: CanvasRenderingContext2D): void;
     /** Raster fallback for SVG export — one `<image>` covering the print area. */
     _toSVG(): string[];
+    /**
+     * The proxy holds a live reference to its source, which would make a
+     * serialized canvas circular. Nothing persists this object (only layers are
+     * serialized) — this keeps an accidental `canvas.toObject()` from throwing.
+     */
+    toObject(): Record<string, unknown>;
     /**
      * Fabric's generic clone round-trips through `toObject()` + the class
      * registry, which cannot carry a live source reference. Export paths clone
@@ -284,18 +324,43 @@ declare class TiledPatternObject extends FabricObject {
      */
     clone(): Promise<this>;
     /**
-     * The proxy holds a live reference to its source, which would make a
-     * serialized canvas circular. Nothing persists this object (only layers are
-     * serialized) — this keeps an accidental `canvas.toObject()` from throwing.
+     * The source's tile footprint: its bounding box, minus a stroke it reserves
+     * room for but never paints.
+     *
+     * fabric keeps `strokeWidth` inside an object's box whether or not a `stroke`
+     * colour paints it, and the built-in shapes arrive with `strokeWidth: 1` and no
+     * stroke. Stepping the grid by that box puts a transparent seam between every
+     * pair of neighbours at zero spacing: the artwork is a pixel narrower than the
+     * box it is stepped by.
      */
-    toObject(): Record<string, unknown>;
-    /** Tile size in canvas units, floored so a tiny tile can't spawn a huge loop. */
-    private tileSize;
-    /** Grid anchor: the source's centre, in this object's coordinates. */
-    private gridOrigin;
+    private sourceBox;
+    /** The source's on-canvas width, before the tile scale. */
+    private baseW;
+    /** The source's on-canvas height, before the tile scale. */
+    private baseH;
+    /**
+     * Size to paint the snapshot at, for a tile of `tileW × tileH`.
+     *
+     * The snapshot is NOT exactly the source's box: `toCanvasElement` rounds the
+     * raster up to whole pixels and pads it further for a shadow. Painting it into
+     * the tile step would squeeze the artwork inside that padding — every tile
+     * shrinks by up to a pixel and the grid shows transparent seams at zero
+     * spacing. So the bitmap is painted at its own footprint, scaled by the same
+     * factor the tile is, and the step stays the source's box.
+     */
+    private drawSize;
+    /** Tile size from the config alone, ignoring any in-flight gesture. */
+    private baseTile;
+    /** Tile size as drawn right now, including a live scale gesture. */
+    private liveTile;
+    /** Smallest tile the draw loop may use, so a tiny tile can't flood the area. */
+    private tileFloor;
+    /** Phase shift (`offsetX`/`offsetY`) as a canvas-space vector. */
+    private shiftVector;
+    private anchorFromOrigin;
     /**
-     * Snapshot the source at (at least) `scale`, reusing the cached one when it is
-     * still sharp enough and the source has not changed.
+     * Snapshot the source at (at least) `scale`, reusing the cached one while it
+     * is still sharp enough and the source has not changed.
      */
     private ensureSnapshot;
     /** Bound the snapshot by both a linear scale and a total pixel budget. */
@@ -315,6 +380,18 @@ interface PatternOrigin {
     x: number;
     y: number;
 }
+/**
+ * Size the tile bitmap is painted at, when that differs from the grid step.
+ *
+ * A snapshot of the source is not always exactly the source's box: the raster is
+ * allocated in whole pixels, and a shadow pads it further. Painting such a bitmap
+ * into the step would shrink the artwork inside its own transparent margin and
+ * open a hairline gap between neighbours at zero spacing.
+ */
+interface TileDrawSize {
+    width: number;
+    height: number;
+}
 /**
  * Pure tile geometry: where each tile centre lands and how much it is rotated,
  * for a config + target/base size. Covers every corner of the target from the
@@ -328,8 +405,12 @@ declare function computeTilePositions(config: PatternConfig, targetW: number, ta
  * Draw the tiled pattern onto a 2D context, in target coordinates (0,0 = the
  * target's top-left corner). The geometry lives in {@link computeTilePositions};
  * this just plays it out as canvas calls.
+ *
+ * `baseW`/`baseH` are the grid STEP. `draw` is the size the bitmap is painted at
+ * and defaults to the step — pass it when the bitmap carries padding the step
+ * does not (see {@link TileDrawSize}), so the artwork still lands step-sized.
  */
-declare function drawTiles(ctx: CanvasRenderingProtocol, img: CanvasImageSource, config: PatternConfig, targetW: number, targetH: number, baseW: number, baseH: number, origin?: PatternOrigin): void;
+declare function drawTiles(ctx: CanvasRenderingProtocol, img: CanvasImageSource, config: PatternConfig, targetW: number, targetH: number, baseW: number, baseH: number, origin?: PatternOrigin, draw?: TileDrawSize): void;
 /** Minimal 2D-context surface used by {@link drawTiles}; lets tests inject a spy. */
 interface CanvasRenderingProtocol {
     save(): void;
@@ -624,6 +705,237 @@ declare class MaskController {
     private assertActive;
 }
 
+interface MaskEditTarget {
+    target: string;
+    maskId: string;
+}
+
+interface MaskBox {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+
+/** Target id for the mask stack that clips the whole design rather than a layer. */
+declare const CANVAS_MASK_TARGET = "canvas";
+/**
+ * Storage half of the mask stacks: where a stack lives, how it is read back out
+ * of the composed clip, and how a new one is installed. `LayerMaskManager` adds
+ * the editing operations on top.
+ *
+ * Two things are persisted, and each has a job:
+ *
+ *  - the composed `clipPath` on the host's fabric object, which is what actually
+ *    renders — in the browser, in an export, and in a server-side replay that
+ *    knows nothing about this class;
+ *  - `layer.meta.maskStack`, the per-entry list (name, mode, link, visibility)
+ *    that the UI edits.
+ *
+ * Geometry is NOT duplicated into the meta: the group's children are the single
+ * source of truth for it, unwrapped and recomposed on every mutation, so the two
+ * can never drift into disagreeing about where a mask sits. The order of
+ * `entries` matches the order of the group's children, minus the implicit base
+ * rect a stack that opens with subtract/intersect needs.
+ */
+declare abstract class MaskStackStore {
+    protected canvas: Canvas;
+    protected layers: LayerManager;
+    protected history: HistoryManager;
+    protected events: EventEmitter<EditorEvents>;
+    protected selected: {
+        target: string;
+        maskId: string;
+    } | null;
+    private pinning;
+    constructor(canvas: Canvas, layers: LayerManager, history: HistoryManager, events: EventEmitter<EditorEvents>);
+    list(target: string): LayerMaskEntry[];
+    get(target: string, maskId: string): LayerMaskEntry | undefined;
+    /** Every target that currently carries at least one mask. */
+    targets(): string[];
+    /** The box a mask is fitted to, in the space the stack is composed in. */
+    hostBox(target: string, absolute?: boolean): MaskBox;
+    /** The host layer of a target, optionally creating the design overlay. */
+    protected hostLayer(target: string, create?: boolean): Layer | undefined;
+    protected host(target: string, create?: boolean): FabricObject | null;
+    /** Re-pin the design overlay, guarding the reorder that re-triggers this. */
+    protected pin(): void;
+    /**
+     * Take the current geometry back out of the composed clip, entry-aligned.
+     *
+     * The entry list is the authority on how to read the clip: with no entries the
+     * clip predates the stack (a mask preset, or a single `clipPath` an older host
+     * installed) and is one mask whole — including when it happens to be a group,
+     * which is why this cannot just unwrap anything group-shaped.
+     */
+    protected unwrap(target: string, host: FabricObject): FabricObject[];
+    /**
+     * Entries for a stack, adopting a pre-stack clip as the first one. Without
+     * this, the first `add()` on an already-masked layer would compose a clip it
+     * has no entry for and silently throw that mask away.
+     */
+    protected entriesFor(target: string, sources: FabricObject[]): LayerMaskEntry[];
+    /**
+     * Install a stack: convert geometry into the space the stack needs, compose the
+     * clip, store the entries, and commit one history checkpoint for the lot.
+     */
+    protected commit(target: string, host: FabricObject, entries: LayerMaskEntry[], sources: FabricObject[], save?: boolean, 
+    /** Compose in canvas space regardless of the entries — see `beginEdit`. */
+    forceAbsolute?: boolean): void;
+}
+
+interface AddMaskOptions {
+    name?: string;
+    mode?: LayerMaskMode;
+    linked?: boolean;
+    /** Host data describing where the geometry came from (preset id, generator…). */
+    meta?: Record<string, unknown>;
+    /** Scale the geometry to the host's box (a number zooms it); default 1. */
+    fit?: number | false;
+    /**
+     * Fit to this box instead of the host's own, in the stack's coordinate space.
+     * The whole-design overlay spans the canvas, but a mask on it usually wants to
+     * frame the artwork, which occupies part of it.
+     */
+    box?: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Stacked, boolean-composed masks — one ordered list per host, where a host is
+ * either a layer or the design as a whole (`CANVAS_MASK_TARGET`). Storage and
+ * clip composition live in `MaskStackStore`; this class is what a UI drives.
+ */
+declare class LayerMaskManager extends MaskStackStore {
+    private readonly edits;
+    private readonly onLayersChanged;
+    private readonly onLayerSelected;
+    private readonly onObjectModified;
+    constructor(canvas: Canvas, layers: LayerManager, history: HistoryManager, events: EventEmitter<EditorEvents>);
+    dispose(): void;
+    /** The mask currently being dragged on the canvas, if any. */
+    editing(): MaskEditTarget | null;
+    /**
+     * Put drag handles on one mask. The stack is composed in canvas space for the
+     * duration — a linked mask would otherwise sit in the host's space, where the
+     * handle's own canvas coordinates mean something else entirely. `endEdit`
+     * returns it to whichever space its entries call for.
+     */
+    beginEdit(target: string, maskId: string): Promise<boolean>;
+    /** Take the handles down and settle the stack back into its own space. */
+    endEdit(save?: boolean): void;
+    getSelected(): {
+        target: string;
+        maskId: string;
+    } | null;
+    select(target: string | null, maskId: string | null): void;
+    add(target: string, object: FabricObject, options?: AddMaskOptions): LayerMaskEntry | null;
+    /** Swap one mask's geometry, keeping its identity, mode and position in the stack. */
+    replaceGeometry(target: string, maskId: string, object: FabricObject, options?: AddMaskOptions): boolean;
+    /**
+     * Re-fit one mask to its host's box (or `box`) at `fit` scale, keeping the
+     * geometry it already has. This is what a zoom control drives: re-picking the
+     * mask would cost another render of a generated alpha map just to resize it.
+     */
+    refit(target: string, maskId: string, options?: {
+        fit?: number;
+        box?: MaskBox;
+        save?: boolean;
+    }): boolean;
+    remove(target: string, maskId: string): boolean;
+    clear(target: string): boolean;
+    reorder(target: string, maskId: string, index: number): boolean;
+    /** Replace a mask's host metadata (which preset or generator produced it). */
+    setMeta(target: string, maskId: string, meta: Record<string, unknown>): boolean;
+    setMode(target: string, maskId: string, mode: LayerMaskMode): boolean;
+    setVisible(target: string, maskId: string, visible: boolean): boolean;
+    setOpacity(target: string, maskId: string, opacity: number): boolean;
+    setName(target: string, maskId: string, name: string): boolean;
+    /**
+     * Link or unlink one mask. Unlinking pins it where it currently appears;
+     * re-linking records its position relative to the host so later host moves
+     * carry it along.
+     */
+    setLinked(target: string, maskId: string, linked: boolean): boolean;
+    /**
+     * Consume a layer, turning its artwork into a mask. Without an explicit target
+     * it masks the layer directly beneath it, and the bottom layer masks the whole
+     * design — there is nothing under it to clip.
+     */
+    convertLayer(layerId: string, target?: string): {
+        target: string;
+        entry: LayerMaskEntry;
+    } | null;
+    /** Recompose one stack's clip from the geometry it already holds. */
+    rebuild(target: string, save?: boolean): void;
+    /** Re-derive linked masks after the host moved (canvas-space stacks only). */
+    private reflow;
+    /**
+     * Adopt a clip this manager did not install — a host's own single `clipPath` —
+     * as a one-entry stack, so it shows up in the UI as a mask row before anything
+     * is added to it. A mask preset is left alone unless asked for by name: it is
+     * still owned by `MaskPresetManager` until a stack operation takes it over.
+     */
+    adopt(target: string, name?: string): LayerMaskEntry | null;
+    /** After a state restore: re-pin the design overlay and recompose every stack. */
+    refreshAll(): void;
+    private patch;
+}
+
+interface ComposeOptions {
+    /** Host box in the coordinate space the children use, for the implicit base. */
+    box: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    /**
+     * Canvas-space children (an unlinked mask is pinned to the canvas, so the
+     * whole group has to leave the host's local space with it).
+     */
+    absolute: boolean;
+}
+/**
+ * Build the `clipPath` for one mask stack: one child per entry, in order, each
+ * carrying its mode's compositing operation.
+ *
+ * `children` are consumed — a Group takes ownership of what it is given and
+ * rewrites the coordinates, so callers pass clones of their sources rather than
+ * the sources themselves.
+ */
+declare function composeMaskGroup(children: FabricObject[], entries: LayerMaskEntry[], options: ComposeOptions): Group | undefined;
+/** True when the stack has to be composed in canvas space rather than host space. */
+declare function needsAbsoluteSpace(entries: LayerMaskEntry[]): boolean;
+
+/** Host-space geometry → canvas-space, for the same on-screen result. */
+declare function toCanvasSpace(object: FabricObject, host: FabricObject): void;
+/** Canvas-space geometry → host-space, for the same on-screen result. */
+declare function toHostSpace(object: FabricObject, host: FabricObject): void;
+/** Scale an object so its unrotated box covers `box`, centred on it. */
+declare function fitToBox(object: FabricObject, box: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, zoom?: number): void;
+/**
+ * Pull a composed clip group back apart into standalone objects in the space the
+ * group itself was in.
+ *
+ * `removeAll` already restores each child's own transform on the way out — the
+ * group rebases children when it takes them in, and reverses that when it lets
+ * them go. Folding the group's matrix back in on top (as one would with a v5-era
+ * group) double-counts it, which stays invisible while a mask sits at the origin
+ * and moves it twice as far as it should the moment one does not.
+ *
+ * The group passed in is emptied.
+ */
+declare function unwrapGroup(group: Group): FabricObject[];
+
 declare class CanvasEditor {
     readonly canvas: Canvas;
     readonly layers: LayerManager;
@@ -635,6 +947,8 @@ declare class CanvasEditor {
     readonly patterns: PatternManager;
     readonly curves: TextCurveManager;
     readonly maskPresets: MaskPresetManager;
+    /** Stacked boolean masks, per layer and for the design as a whole. */
+    readonly layerMasks: LayerMaskManager;
     readonly fonts: FontRegistry;
     readonly licensing: LicenseManager;
     readonly pages: ProjectManager;
@@ -901,4 +1215,4 @@ declare class AnnotationOverlay {
  */
 declare function displaceRgba(source: Uint8ClampedArray, map: Uint8ClampedArray, width: number, height: number, options: Omit<MockupDisplacement, 'image'>): Uint8ClampedArray;
 
-export { AnnotationOverlay, type AnnotationPrimitive, BackgroundImageOptions, CANVAS_SIZE_PRESETS, CanvasEditor, type CanvasRenderingProtocol, CanvasSizePreset, type CoverPlacement, CropController, DEFAULT_LAYER_SHADOW, DEFAULT_SELECTION_STYLE, DEFAULT_TEXT_CURVE, DpiIssue, EditorConfig, EditorEvents, EditorState, EventEmitter, FileAdapter, FontDefinition, FontRegistry, HistoryManager, ImageAdjustments, ImageProvider, ImageProviderResult, ImageSearchOptions, ImageSearchResult, Layer, LayerData, LayerManager, LayerMeta, LayerShadowConfig, LayerType, LicenseConfig, LicenseManager, LicenseStatus, MaskBrushOptions, MaskController, type MaskPerformanceSample, MaskPoint, MaskPresetId, MaskPresetManager, MaskRefinementError, type MaskRefinementErrorCode, MaskRefinementPrompt, MaskRefinementProvider, MaskRefinementResult, MockupConfig, MockupDisplacement, MockupPrintArea, NormalizedLayerPosition, PatternConfig, PatternLocks, PatternManager, type PatternOrigin, type PngExportOptions, PositioningAdapter, PrintifyPositioning, ProjectManager, ProjectState, ResizeOptions, SHAPE_MASK_BOX, SHAPE_MASK_IDS, type SelectionStyle, SemanticExportOptions, SerializedBackgroundImageOptions, SerializedLayer, ShapeMaskPresetId, ShapePlugin, SnapManager, SvgExportOptions, TEXTURE_MASK_IDS, TEXTURE_MASK_SIZE, TemplateDefinition, TextCurveConfig, TextCurveManager, TextureMaskPresetId, type TilePlacement, TiledPatternObject, Unit, UnitConverter, type ViewportTransform, applyAspectLock, applyLayerShadow, applyObjectSelectionStyle, applySelectionStyle, buildCurvePathData, clamp, clearTextureMaskCache, computeCoverPlacement, computePrintAreaClip, computeTilePositions, deserializeEditor, displaceRgba, drawTiles, escapeXml, exportDataURL, exportMockup, exportPNG, exportPrintArea, exportSVG, generateId, isCssColor, isMaskPresetId, isShapeMaskId, isTextureMaskId, readLayerShadow, renderTextureMask, resetTransform, restoreLocks, round2, sanitizeSvg, serializeEditor, shapeMaskPathData };
+export { type AddMaskOptions, AnnotationOverlay, type AnnotationPrimitive, BackgroundImageOptions, CANVAS_MASK_TARGET, CANVAS_SIZE_PRESETS, CanvasEditor, type CanvasRenderingProtocol, CanvasSizePreset, type CoverPlacement, CropController, DEFAULT_LAYER_SHADOW, DEFAULT_SELECTION_STYLE, DEFAULT_TEXT_CURVE, DpiIssue, EditorConfig, EditorEvents, EditorState, EventEmitter, FileAdapter, FontDefinition, FontRegistry, HistoryManager, ImageAdjustments, ImageProvider, ImageProviderResult, ImageSearchOptions, ImageSearchResult, Layer, LayerData, LayerManager, LayerMaskEntry, LayerMaskManager, LayerMaskMode, LayerMeta, LayerShadowConfig, LayerType, LicenseConfig, LicenseManager, LicenseStatus, MaskBrushOptions, MaskController, type MaskPerformanceSample, MaskPoint, MaskPresetId, MaskPresetManager, MaskRefinementError, type MaskRefinementErrorCode, MaskRefinementPrompt, MaskRefinementProvider, MaskRefinementResult, MockupConfig, MockupDisplacement, MockupPrintArea, NormalizedLayerPosition, PatternConfig, PatternLocks, PatternManager, type PatternOrigin, type PngExportOptions, PositioningAdapter, PrintifyPositioning, ProjectManager, ProjectState, ResizeOptions, SHAPE_MASK_BOX, SHAPE_MASK_IDS, type SelectionStyle, SemanticExportOptions, SerializedBackgroundImageOptions, SerializedLayer, ShapeMaskPresetId, ShapePlugin, SnapManager, SvgExportOptions, TEXTURE_MASK_IDS, TEXTURE_MASK_SIZE, TemplateDefinition, TextCurveConfig, TextCurveManager, TextureMaskPresetId, type TileDrawSize, type TilePlacement, TiledPatternObject, Unit, UnitConverter, type ViewportTransform, applyAspectLock, applyLayerShadow, applyObjectSelectionStyle, applySelectionStyle, buildCurvePathData, clamp, clearTextureMaskCache, composeMaskGroup, computeCoverPlacement, computePrintAreaClip, computeTilePositions, deserializeEditor, displaceRgba, drawTiles, escapeXml, exportDataURL, exportMockup, exportPNG, exportPrintArea, exportSVG, fitToBox, generateId, isCssColor, isMaskPresetId, isShapeMaskId, isTextureMaskId, needsAbsoluteSpace, readLayerShadow, renderTextureMask, resetTransform, restoreLocks, round2, sanitizeSvg, serializeEditor, shapeMaskPathData, toCanvasSpace, toHostSpace, unwrapGroup };