@pixerate/editor 0.88.0 → 0.89.0

package/dist/raster/index.d.ts

@@ -0,0 +1,365 @@
+import { B as BlendMode, M as MaskSurface, P as PixelSurface, R as RasterRect, T as TiledSurface, h as TileKey } from '../surface-fJhkmNQn.js';
+export { a as BLEND_MODES, b as BlendModeInfo, c as Rgb, d as Rgba, S as SurfaceDraft, e as TILE, f as TILE_SHIFT, g as Tile, i as blendChannel, j as blendImageData, k as blendLum, l as blendPixel, m as blendRgb, n as canvasCompositeOperation, o as collectTiles, p as contentBounds, q as emptySurface, r as fillRect, s as finishTile, t as isBlendMode, u as isSeparableBlendMode, v as normalizeBlendMode, w as packRgba, x as readPixel, y as readRegion, z as setLum, A as solidSurface, C as surfaceBytes, D as surfaceFromPixels, E as surfacesEqual, F as tileCoord, G as tileKey, H as tileRect, I as tilesInRect, J as translateSurface, K as uniformTile, L as writeRegion } from '../surface-fJhkmNQn.js';
+
+/**
+ * A layer stack that is not specific to any editor: pixel layers on tiled surfaces, groups (with
+ * pass-through), raster masks with density and feather, clipping, locks, opacity, fill and blend
+ * modes, plus pure tree helpers. Editors extend these types with their own layer kinds (the image
+ * editor adds adjustment and annotation layers, filters and parametric masks).
+ *
+ * Layer objects are immutable: every change builds new objects along the path from the root to
+ * the changed layer and shares everything else.
+ */
+
+/** Blend modes of a layer; groups also accept `pass-through`. */
+type GroupBlendMode = BlendMode | 'pass-through';
+interface LayerLocks {
+    /** Painting and filling are refused. */
+    pixels?: boolean;
+    /** Painting keeps each pixel's alpha. */
+    transparency?: boolean;
+    /** Moving (offset) is refused. */
+    position?: boolean;
+    /** Everything above, plus property changes and deletion. */
+    all?: boolean;
+}
+/**
+ * A layer mask: 8-bit coverage (255 reveals, 0 hides) on a tiled surface, plus non-destructive
+ * density and feather. `source` is an editor-defined parametric mask (generated instead of
+ * painted; the compositor asks its profile for the coverage, and the surface is unused).
+ */
+interface RasterMask<Source = unknown> {
+    surface: MaskSurface;
+    /** Value outside the painted tiles (PSD's default colour); equals `surface.defaultValue`. */
+    defaultValue: 0 | 255;
+    /** 0..1 (missing = 1): at 0.5 hidden areas still show half. */
+    density?: number;
+    /** Gaussian σ in pixels (missing = 0). */
+    feather?: number;
+    /** `false` keeps the mask but ignores it. */
+    enabled?: boolean;
+    source?: Source;
+}
+interface RasterLayerBase {
+    id: string;
+    name: string;
+    visible: boolean;
+    /** 0..1 */
+    opacity: number;
+    blend: BlendMode;
+    /** Clip to the nearest unclipped layer below (Photoshop's clipping mask). */
+    clipped?: boolean;
+    mask?: RasterMask;
+    locks?: LayerLocks;
+}
+interface RasterPixelLayer extends RasterLayerBase {
+    type: 'pixel';
+    /** Pixels in layer space; document position = layer position + `offset`. A mask moves with it. */
+    surface: PixelSurface;
+    /** Integer move without re-tiling. */
+    offset: {
+        x: number;
+        y: number;
+    };
+    /** 0..1, PSD "Fill" (missing = 1). */
+    fillOpacity?: number;
+}
+interface RasterGroupLayer<L = RasterLayer> extends Omit<RasterLayerBase, 'blend'> {
+    type: 'group';
+    blend: GroupBlendMode;
+    /** Bottom to top. */
+    children: L[];
+    /** UI only. */
+    collapsed?: boolean;
+}
+/** The plain stack: pixel layers and groups. */
+type RasterLayer = RasterPixelLayer | RasterGroupLayer<RasterLayer>;
+/** What the tree helpers need of a layer: an id, a type, and `children` on groups. */
+interface RasterNode {
+    id: string;
+    type: string;
+}
+/** The group members of a layer union. */
+type GroupIn<T> = Extract<T, {
+    type: 'group';
+}>;
+interface LayerLocation<T extends RasterNode = RasterLayer> {
+    layer: T;
+    /** The containing group, or `null` at the top level. */
+    parent: GroupIn<T> | null;
+    /** Index within the parent's children (or the top-level list). */
+    index: number;
+    /** Ancestors from the top level down to the parent. */
+    path: GroupIn<T>[];
+}
+/** Every layer, depth first, bottom to top (a group comes before its children). */
+declare function flattenLayers<T extends RasterNode>(layers: readonly T[]): T[];
+declare function findLayer<T extends RasterNode>(layers: readonly T[], id: string): LayerLocation<T> | null;
+/** Replaces the layer with `id` by `fn(layer)` (or removes it when `fn` returns `null`). */
+declare function mapLayer<T extends RasterNode>(layers: readonly T[], id: string, fn: (layer: T) => T | null): T[];
+/** Inserts `layer` into `parentId`'s children (or the top level) at `index` (default: top). */
+declare function insertLayer<T extends RasterNode>(layers: readonly T[], layer: T, parentId: string | null, index?: number): T[];
+declare function isLayerLocked(layer: {
+    locks?: LayerLocks;
+}, what: keyof LayerLocks): boolean;
+
+/**
+ * The per-tile layer compositor engine. Composites a layer stack (pixel layers and groups with
+ * masks, clipping, blend modes, opacity, fill and pass-through) tile by tile in document space,
+ * in pure TypeScript, so results are deterministic and testable in Node and Workers.
+ *
+ * Editors add their own layer kinds through a {@link CompositorProfile}: layers that filter
+ * what is below them (adjustment layers), content layers drawn by the editor (annotations),
+ * per-layer pixel filters, and parametric mask sources.
+ *
+ * Caches:
+ * - Each top-level *step* (a content layer and the layers clipped to it, a run of filter layers,
+ *   a group) has a per-tile *signature*: its properties plus the identity of every surface tile
+ *   it reads. A tile whose signatures are unchanged returns the cached result (same buffer
+ *   object, so callers can skip uploading it).
+ * - A prefix cache keeps the accumulator *before* the step that changed last time (and, when the
+ *   caller names it, before the active layer). Dragging a slider on layer k, or a stroke on layer
+ *   k, recomposites from step k upwards only; `dirty` rectangles limit that to where it changed.
+ * - Spatial filters and feathered or parametric masks are computed once over the canvas and
+ *   cached by the identity of their inputs.
+ */
+
+/** What the compositor needs from its host besides the layers. */
+interface RasterSources {
+    /** Canvas (document) size: spatial filters and mask feathering clamp at this rect. */
+    width: number;
+    height: number;
+    /** The pixels of a pixel layer (lets a host resolve layers whose pixels live elsewhere). */
+    surfaceOf?(layer: CompositorLayer): PixelSurface;
+    /** Changes whenever one of the host's callbacks would return something new for the same layers. */
+    version?: number | string;
+}
+/** The fields the engine reads; editor layer types are wider. */
+interface CompositorLayer extends RasterNode {
+    visible: boolean;
+    opacity: number;
+    blend: string;
+    clipped?: boolean;
+    mask?: RasterMask;
+    /** Pixel layers. */
+    surface?: PixelSurface;
+    offset?: {
+        x: number;
+        y: number;
+    };
+    fillOpacity?: number;
+    /** Groups. */
+    children?: readonly CompositorLayer[];
+}
+/** A pixel layer's filters as the engine runs them. */
+interface PixelFilterSpec {
+    /** Identifies the settings (part of the cache key). */
+    key: string;
+    /** Needs neighbouring pixels: runs once over the canvas instead of per tile. */
+    spatial: boolean;
+    /** Filters RGBA `data` (`width × height`) in place. */
+    apply(data: Uint8ClampedArray, width: number, height: number): void;
+}
+/** How an editor's own layer kinds composite. Every hook is optional. */
+interface CompositorProfile<L extends CompositorLayer, S extends RasterSources> {
+    /** Layers that change what is below them; adjacent ones run as one step. */
+    isFilterLayer?(layer: L): boolean;
+    /** Applies a run of visible filter layers to `acc` (RGBA over `r`); `coverage` holds masked ones by id. */
+    applyFilterRun?(layers: L[], acc: Uint8ClampedArray, r: RasterRect, coverage: Map<string, Float32Array> | undefined, sources: S): void;
+    /** RGBA of a content layer that is neither a pixel layer nor a group, over `r`, or `null`. */
+    contentTile?(layer: L, r: RasterRect, sources: S): Uint8ClampedArray | null;
+    /** The blend mode a content layer draws with (default `layer.blend`). */
+    contentBlend?(layer: L): BlendMode;
+    /** Properties of a layer beyond the generic ones that change its pixels (part of its signature). */
+    layerKey?(layer: L): unknown;
+    /** Active filters of a pixel layer, or `null`. */
+    pixelFilters?(layer: L): PixelFilterSpec | null;
+    /** Canvas coverage (0..1, `width × height`) of a parametric mask source, or `null` to reveal all. */
+    maskSourcePlane?(source: unknown, width: number, height: number, sources: S): Float32Array | null;
+}
+interface CompositorOptions {
+    /** Upper bound for cached tile buffers (default 256 MiB). */
+    maxCacheBytes?: number;
+}
+interface CompositeCallOptions {
+    /**
+     * The layer about to be edited (the active layer): every tile composited in this call keeps a
+     * checkpoint below its step, so strokes and slider drags on it start there.
+     */
+    checkpointLayerId?: string | null;
+    /**
+     * Where the layers changed since the previous call, when the caller knows (a stroke's dabs).
+     * Changed tiles are then recomposited only inside these rectangles. Changes outside them would
+     * be missed, so pass nothing when unsure.
+     */
+    dirty?: RasterRect[];
+}
+/**
+ * Blends straight-alpha `src` over `dst` (both RGBA) in place with `mode`, scaling the source
+ * alpha by `alpha` and, per pixel, by `coverage`. Same maths as `blendPixel`.
+ */
+declare function blendTile(dst: Uint8ClampedArray, src: ArrayLike<number>, mode: BlendMode, alpha: number, coverage: ArrayLike<number> | null): void;
+/** Statistics of the last `composite` call (for benchmarks and tests). */
+interface CompositeStats {
+    tiles: number;
+    /** Tiles returned straight from the cache. */
+    cached: number;
+    /** Steps actually run, summed over tiles. */
+    stepsRun: number;
+}
+declare class RasterCompositor<L extends CompositorLayer = CompositorLayer, S extends RasterSources = RasterSources> {
+    private readonly profile;
+    private readonly tiles;
+    private readonly maxCacheBytes;
+    private cacheBytes;
+    private stamp;
+    private sources;
+    private sourcesVersion;
+    private filteredCache;
+    private planeCache;
+    private planeIds;
+    private nextPlaneId;
+    private contentCache;
+    private readonly stepsCache;
+    private readonly propsKeyCache;
+    lastStats: CompositeStats;
+    private hint;
+    constructor(profile?: CompositorProfile<L, S>, options?: CompositorOptions);
+    /** Drops every cached tile and plane. */
+    clear(): void;
+    private setSources;
+    /** The composite of `layers` over `rect` as `rect.width × rect.height` RGBA (straight alpha). */
+    composite(layers: readonly L[], rect: RasterRect, sources: S, options?: CompositeCallOptions): Uint8ClampedArray;
+    /**
+     * Composites every tile intersecting `rect` and calls `onTile` with each tile's RGBA buffer
+     * (TILE × TILE). A tile whose inputs did not change since the last call returns the same buffer
+     * object; never mutate it.
+     */
+    compositeTiles(layers: readonly L[], rect: RasterRect, sources: S, onTile: (tx: number, ty: number, data: Uint8ClampedArray, changed: boolean) => void, options?: CompositeCallOptions): void;
+    /** The composite of one tile (cached; do not mutate the result). */
+    tile(layers: readonly L[], tx: number, ty: number, sources: S): Uint8ClampedArray;
+    /**
+     * A layer's effective mask coverage (0..1, after density, feather or parametric evaluation)
+     * over `r` in document space, or `null` when it reveals all of `r`.
+     */
+    maskCoverage(layer: L, r: RasterRect, sources: S): Float32Array | null;
+    private isFilter;
+    /**
+     * Groups a layer list into compositing steps: clipped layers join the nearest unclipped
+     * content or group layer below; consecutive unclipped filter layers form one run.
+     */
+    private buildSteps;
+    /** The index of the top-level step that holds layer `id` (searching groups and clipped layers), or -1. */
+    private stepIndexOf;
+    /** Properties of a layer that change pixels, minus its surfaces (memoised per object). */
+    private propsKey;
+    private compositeTile;
+    private entryBytes;
+    private evict;
+    private stepSig;
+    private layerSig;
+    private groupSig;
+    private contentSig;
+    private maskRefs;
+    /**
+     * A pixel layer's pixels after spatial filters: the surface and the offset to apply. Layers
+     * with a spatial filter are filtered once over the canvas (in document space, offset 0).
+     */
+    private layerPixels;
+    /** RGBA of a content layer over `r` (document space, inside one tile), or `null` when it has nothing there. */
+    private contentTile;
+    private planeKey;
+    /** Canvas-sized coverage of a feathered or parametric mask (cached). */
+    private planeFor;
+    private maskTile;
+    /** Runs one step onto `acc`; returns whether `acc` is still empty. */
+    private runStep;
+    private runSteps;
+    private contentBlend;
+    private blendOnto;
+    private applyClipped;
+    private applyFilterRun;
+}
+/** Tiles that differ between two surfaces (by tile identity), as tile keys. */
+declare function changedTiles(a: TiledSurface, b: TiledSurface): TileKey[];
+
+/** Above this σ a Gaussian is approximated by three box passes (cost independent of σ). */
+declare const DIRECT_GAUSSIAN_MAX_SIGMA = 8;
+/** How a blur treats pixels beyond the image: `zero`, or `clamp` (replicate the border). */
+type BlurEdge = 'zero' | 'clamp';
+type Edge = BlurEdge;
+/**
+ * Separable Gaussian blur of a single-channel float image. `edge` `zero` treats pixels beyond
+ * the image as 0 (selection feather), `clamp` replicates the border (mask refinement). σ up to
+ * {@link DIRECT_GAUSSIAN_MAX_SIGMA} is convolved directly; wider blurs use three box passes, so
+ * the cost per pixel never grows with σ.
+ */
+declare function gaussianBlur(src: ArrayLike<number>, w: number, h: number, sigma: number, edge?: Edge): Float32Array;
+
+/**
+ * Dependency-free, synchronous PNG encode / decode for layer pixels and masks, plus base64 and
+ * data-URL helpers. Canvas `toDataURL` is lossy for partly transparent pixels (it goes through
+ * premultiplied alpha), so layer assets use this codec and round-trip exactly.
+ *
+ * Encodes 8-bit greyscale (masks) or RGBA (layers). Decodes non-interlaced 1/2/4/8/16-bit
+ * greyscale, RGB, palette, grey + alpha and RGBA, always to 8-bit RGBA or grey.
+ */
+interface DecodedPng {
+    width: number;
+    height: number;
+    /** 4 for RGBA output, 1 for greyscale without alpha when `keepGray` was asked for. */
+    channels: 1 | 4;
+    data: Uint8ClampedArray;
+}
+/** PNG bytes for `width × height` pixels of 1 (grey) or 4 (RGBA) bytes each. */
+declare function encodePng(width: number, height: number, data: ArrayLike<number>, channels?: 1 | 4): Uint8Array;
+declare function isPng(bytes: Uint8Array): boolean;
+/**
+ * Decodes a PNG. Output is RGBA (4 channels) unless `keepGray` is set and the image is
+ * greyscale without alpha, in which case it is one byte per pixel.
+ */
+declare function decodePng(bytes: Uint8Array, options?: {
+    keepGray?: boolean;
+    maxPixels?: number;
+}): DecodedPng;
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function base64ToBytes(text: string): Uint8Array;
+/** The bytes and MIME type of a `data:` URL (base64 or percent-encoded). */
+declare function parseDataUrl(url: string): {
+    mime: string;
+    bytes: Uint8Array;
+} | null;
+declare function pngDataUrl(width: number, height: number, data: ArrayLike<number>, channels?: 1 | 4): string;
+
+/**
+ * Synchronous zlib (RFC 1950) and raw deflate (RFC 1951), dependency-free, for the image editor's
+ * layer PNGs and PSD ZIP channels. `CompressionStream` is asynchronous and not everywhere, and
+ * layer pixels must serialize inside the synchronous `toJSON()`.
+ *
+ * - `inflate` handles stored, fixed and dynamic blocks and refuses to produce more than
+ *   `maxOutput` bytes (a decompression bomb guard).
+ * - `deflate` is a greedy LZ77 (hash chains, 32 KiB window) with one dynamic Huffman block per
+ *   64 Ki symbols. It favours simplicity over the last few percent of ratio.
+ */
+declare class ZlibError extends Error {
+    constructor(message: string);
+}
+/** Inflates raw deflate data (no zlib header). */
+declare function inflateRaw(data: Uint8Array, options?: {
+    maxOutput?: number;
+    sizeHint?: number;
+}): Uint8Array;
+/** Adler-32 checksum (zlib trailer). */
+declare function adler32(data: Uint8Array): number;
+/** Inflates zlib data (header, deflate stream, Adler-32 trailer). */
+declare function inflate(data: Uint8Array, options?: {
+    maxOutput?: number;
+    sizeHint?: number;
+    verify?: boolean;
+}): Uint8Array;
+/** Raw deflate (no zlib header). `level` 0 stores the data uncompressed. */
+declare function deflateRaw(data: Uint8Array, level?: 0 | 1): Uint8Array;
+/** zlib stream: header, raw deflate, Adler-32. */
+declare function deflate(data: Uint8Array, level?: 0 | 1): Uint8Array;
+
+export { BlendMode, type BlurEdge, type CompositeCallOptions, type CompositeStats, type CompositorLayer, type CompositorOptions, type CompositorProfile, DIRECT_GAUSSIAN_MAX_SIGMA, type DecodedPng, type GroupBlendMode, type GroupIn, type LayerLocation, type LayerLocks, MaskSurface, type PixelFilterSpec, PixelSurface, RasterCompositor, type RasterGroupLayer, type RasterLayer, type RasterLayerBase, type RasterMask, type RasterNode, type RasterPixelLayer, RasterRect, type RasterSources, TileKey, TiledSurface, ZlibError, adler32, base64ToBytes, blendTile, bytesToBase64, changedTiles, decodePng, deflate, deflateRaw, encodePng, findLayer, flattenLayers, gaussianBlur, inflate, inflateRaw, insertLayer, isLayerLocked, isPng, mapLayer, parseDataUrl, pngDataUrl };

package/dist/raster/index.js

@@ -0,0 +1,121 @@
+import {
+  DIRECT_GAUSSIAN_MAX_SIGMA,
+  RasterCompositor,
+  ZlibError,
+  adler32,
+  base64ToBytes,
+  blendTile,
+  bytesToBase64,
+  changedTiles,
+  decodePng,
+  deflate,
+  deflateRaw,
+  encodePng,
+  findLayer,
+  flattenLayers,
+  gaussianBlur,
+  inflate,
+  inflateRaw,
+  insertLayer,
+  isLayerLocked,
+  isPng,
+  mapLayer,
+  parseDataUrl,
+  pngDataUrl
+} from "../chunk-P5TPUNBZ.js";
+import {
+  BLEND_MODES,
+  SurfaceDraft,
+  TILE,
+  TILE_SHIFT,
+  TiledSurface,
+  blendChannel,
+  blendImageData,
+  blendLum,
+  blendPixel,
+  blendRgb,
+  canvasCompositeOperation,
+  collectTiles,
+  contentBounds,
+  emptySurface,
+  fillRect,
+  finishTile,
+  isBlendMode,
+  isSeparableBlendMode,
+  normalizeBlendMode,
+  packRgba,
+  readPixel,
+  readRegion,
+  setLum,
+  solidSurface,
+  surfaceBytes,
+  surfaceFromPixels,
+  surfacesEqual,
+  tileCoord,
+  tileKey,
+  tileRect,
+  tilesInRect,
+  translateSurface,
+  uniformTile,
+  writeRegion
+} from "../chunk-D4ZCU72J.js";
+export {
+  BLEND_MODES,
+  DIRECT_GAUSSIAN_MAX_SIGMA,
+  RasterCompositor,
+  SurfaceDraft,
+  TILE,
+  TILE_SHIFT,
+  TiledSurface,
+  ZlibError,
+  adler32,
+  base64ToBytes,
+  blendChannel,
+  blendImageData,
+  blendLum,
+  blendPixel,
+  blendRgb,
+  blendTile,
+  bytesToBase64,
+  canvasCompositeOperation,
+  changedTiles,
+  collectTiles,
+  contentBounds,
+  decodePng,
+  deflate,
+  deflateRaw,
+  emptySurface,
+  encodePng,
+  fillRect,
+  findLayer,
+  finishTile,
+  flattenLayers,
+  gaussianBlur,
+  inflate,
+  inflateRaw,
+  insertLayer,
+  isBlendMode,
+  isLayerLocked,
+  isPng,
+  isSeparableBlendMode,
+  mapLayer,
+  normalizeBlendMode,
+  packRgba,
+  parseDataUrl,
+  pngDataUrl,
+  readPixel,
+  readRegion,
+  setLum,
+  solidSurface,
+  surfaceBytes,
+  surfaceFromPixels,
+  surfacesEqual,
+  tileCoord,
+  tileKey,
+  tileRect,
+  tilesInRect,
+  translateSurface,
+  uniformTile,
+  writeRegion
+};
+//# sourceMappingURL=index.js.map

package/dist/raster/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/serializers/index.cjs

@@ -9,7 +9,7 @@
 
 
 
-var _chunkROXFP2LQcjs = require('../chunk-ROXFP2LQ.cjs');
+var _chunkHNDSPZ5Tcjs = require('../chunk-HNDSPZ5T.cjs');
 
 
 
@@ -27,14 +27,14 @@ var _chunkROXFP2LQcjs = require('../chunk-ROXFP2LQ.cjs');
 
 
 
-var _chunkTYOAJDFDcjs = require('../chunk-TYOAJDFD.cjs');
-require('../chunk-IFHKKVXH.cjs');
+var _chunk66IMF6ODcjs = require('../chunk-66IMF6OD.cjs');
 
 
 
 
 
 var _chunkBVP3TSLHcjs = require('../chunk-BVP3TSLH.cjs');
+require('../chunk-IFHKKVXH.cjs');
 
 
 
@@ -65,5 +65,5 @@ var _chunkBVP3TSLHcjs = require('../chunk-BVP3TSLH.cjs');
 
 
 
-exports.MARKDOWN_MENTION_SPLIT_REGEX = _chunkTYOAJDFDcjs.MARKDOWN_MENTION_SPLIT_REGEX; exports.MENTION_REGEX = _chunkBVP3TSLHcjs.MENTION_REGEX; exports.PIXERATE_DOCUMENT_MIME = _chunkROXFP2LQcjs.PIXERATE_DOCUMENT_MIME; exports.escapeHtml = _chunkTYOAJDFDcjs.escapeHtml; exports.extractMentions = _chunkTYOAJDFDcjs.extractMentions; exports.extractMentionsFromDoc = _chunkTYOAJDFDcjs.extractMentionsFromDoc; exports.findTextMentions = _chunkBVP3TSLHcjs.findTextMentions; exports.formatMentionText = _chunkBVP3TSLHcjs.formatMentionText; exports.getClipboardData = _chunkROXFP2LQcjs.getClipboardData; exports.getEditorMarkdown = _chunkTYOAJDFDcjs.getEditorMarkdown; exports.getEditorText = _chunkTYOAJDFDcjs.getEditorText; exports.getSchemaSignature = _chunkROXFP2LQcjs.getSchemaSignature; exports.htmlToPlainText = _chunkTYOAJDFDcjs.htmlToPlainText; exports.markdownToTipTapHtml = _chunkTYOAJDFDcjs.markdownToTipTapHtml; exports.parseMentionSegments = _chunkTYOAJDFDcjs.parseMentionSegments; exports.parseRichClipboardPayload = _chunkROXFP2LQcjs.parseRichClipboardPayload; exports.plainTextToParagraphHtml = _chunkROXFP2LQcjs.plainTextToParagraphHtml; exports.plainTextToSlice = _chunkTYOAJDFDcjs.plainTextToSlice; exports.plainTextToTipTapHtml = _chunkTYOAJDFDcjs.plainTextToTipTapHtml; exports.preprocessMarkdownFileLinks = _chunkTYOAJDFDcjs.preprocessMarkdownFileLinks; exports.preprocessMarkdownMentions = _chunkTYOAJDFDcjs.preprocessMarkdownMentions; exports.readRichClipboard = _chunkROXFP2LQcjs.readRichClipboard; exports.rtfToPlainText = _chunkROXFP2LQcjs.rtfToPlainText; exports.sanitizeHtml = _chunkTYOAJDFDcjs.sanitizeHtml; exports.sanitizeImportedHtml = _chunkROXFP2LQcjs.sanitizeImportedHtml; exports.serializeRichClipboardPayload = _chunkROXFP2LQcjs.serializeRichClipboardPayload; exports.setMentionRoleInText = _chunkBVP3TSLHcjs.setMentionRoleInText; exports.splitMarkdownMentionParts = _chunkTYOAJDFDcjs.splitMarkdownMentionParts; exports.stripMarkdownCode = _chunkTYOAJDFDcjs.stripMarkdownCode;
+exports.MARKDOWN_MENTION_SPLIT_REGEX = _chunk66IMF6ODcjs.MARKDOWN_MENTION_SPLIT_REGEX; exports.MENTION_REGEX = _chunkBVP3TSLHcjs.MENTION_REGEX; exports.PIXERATE_DOCUMENT_MIME = _chunkHNDSPZ5Tcjs.PIXERATE_DOCUMENT_MIME; exports.escapeHtml = _chunk66IMF6ODcjs.escapeHtml; exports.extractMentions = _chunk66IMF6ODcjs.extractMentions; exports.extractMentionsFromDoc = _chunk66IMF6ODcjs.extractMentionsFromDoc; exports.findTextMentions = _chunkBVP3TSLHcjs.findTextMentions; exports.formatMentionText = _chunkBVP3TSLHcjs.formatMentionText; exports.getClipboardData = _chunkHNDSPZ5Tcjs.getClipboardData; exports.getEditorMarkdown = _chunk66IMF6ODcjs.getEditorMarkdown; exports.getEditorText = _chunk66IMF6ODcjs.getEditorText; exports.getSchemaSignature = _chunkHNDSPZ5Tcjs.getSchemaSignature; exports.htmlToPlainText = _chunk66IMF6ODcjs.htmlToPlainText; exports.markdownToTipTapHtml = _chunk66IMF6ODcjs.markdownToTipTapHtml; exports.parseMentionSegments = _chunk66IMF6ODcjs.parseMentionSegments; exports.parseRichClipboardPayload = _chunkHNDSPZ5Tcjs.parseRichClipboardPayload; exports.plainTextToParagraphHtml = _chunkHNDSPZ5Tcjs.plainTextToParagraphHtml; exports.plainTextToSlice = _chunk66IMF6ODcjs.plainTextToSlice; exports.plainTextToTipTapHtml = _chunk66IMF6ODcjs.plainTextToTipTapHtml; exports.preprocessMarkdownFileLinks = _chunk66IMF6ODcjs.preprocessMarkdownFileLinks; exports.preprocessMarkdownMentions = _chunk66IMF6ODcjs.preprocessMarkdownMentions; exports.readRichClipboard = _chunkHNDSPZ5Tcjs.readRichClipboard; exports.rtfToPlainText = _chunkHNDSPZ5Tcjs.rtfToPlainText; exports.sanitizeHtml = _chunk66IMF6ODcjs.sanitizeHtml; exports.sanitizeImportedHtml = _chunkHNDSPZ5Tcjs.sanitizeImportedHtml; exports.serializeRichClipboardPayload = _chunkHNDSPZ5Tcjs.serializeRichClipboardPayload; exports.setMentionRoleInText = _chunkBVP3TSLHcjs.setMentionRoleInText; exports.splitMarkdownMentionParts = _chunk66IMF6ODcjs.splitMarkdownMentionParts; exports.stripMarkdownCode = _chunk66IMF6ODcjs.stripMarkdownCode;
 //# sourceMappingURL=index.cjs.map

package/dist/serializers/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"],"names":[],"mappings":"AAAA,0GAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,w9DAAC","file":"/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"}
+{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"],"names":[],"mappings":"AAAA,0GAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACA;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,w9DAAC","file":"/home/runner/work/editor/editor/packages/core/dist/serializers/index.cjs"}

package/dist/serializers/index.js

@@ -9,7 +9,7 @@ import {
   rtfToPlainText,
   sanitizeImportedHtml,
   serializeRichClipboardPayload
-} from "../chunk-SVW2UNUC.js";
+} from "../chunk-WON34HKM.js";
 import {
   MARKDOWN_MENTION_SPLIT_REGEX,
   escapeHtml,
@@ -27,14 +27,14 @@ import {
   sanitizeHtml,
   splitMarkdownMentionParts,
   stripMarkdownCode
-} from "../chunk-ZQNDSUZO.js";
-import "../chunk-SWE3NPOU.js";
+} from "../chunk-UKI64KUD.js";
 import {
   MENTION_REGEX,
   findTextMentions,
   formatMentionText,
   setMentionRoleInText
 } from "../chunk-O5RYH2PG.js";
+import "../chunk-SWE3NPOU.js";
 export {
   MARKDOWN_MENTION_SPLIT_REGEX,
   MENTION_REGEX,