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

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
@@ -283,19 +323,20 @@ declare class TiledPatternObject extends FabricObject {
      * tiling. The copy shares the source (it only ever reads from it).
      */
     clone(): Promise<this>;
+    /** The source's on-canvas width, before the tile scale. */
+    private baseW;
+    /** 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;
     /**
-     * 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>;
-    /** 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;
-    /**
-     * 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. */
@@ -624,6 +665,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 +907,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 +1175,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 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 };