@vectojs/core 0.1.0 → 0.2.1

package/dist/renderer/IRenderer.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Renderer abstraction consumed by every {@link Entity}.
+ *
+ * Implementations wrap a concrete drawing backend (Canvas 2D, WebGL, …) and
+ * expose a path-based drawing API.  Entities must only depend on `IRenderer`
+ * so they remain backend-agnostic.
+ *
+ * @example
+ * // Inside an Entity.render() implementation:
+ * render(r: IRenderer) {
+ *   r.beginPath();
+ *   r.fill('#38bdf8');
+ * }
+ */
+export interface IRenderer {
+    /** Clear the entire drawing surface to transparent / background color. */
+    clear(): void;
+    /** Push the current transform + state onto the renderer's stack. */
+    save(): void;
+    /** Pop the last saved transform + state from the renderer's stack. */
+    restore(): void;
+    /**
+     * Apply a translation to the current transform matrix.
+     *
+     * @param x - Horizontal offset in pixels.
+     * @param y - Vertical offset in pixels.
+     */
+    translate(x: number, y: number): void;
+    /**
+     * Apply a scale to the current transform matrix.
+     *
+     * @param x - Horizontal scale factor.
+     * @param y - Vertical scale factor.
+     */
+    scale(x: number, y: number): void;
+    /**
+     * Apply a clockwise rotation to the current transform matrix.
+     *
+     * @param angle - Rotation angle in radians.
+     */
+    rotate(angle: number): void;
+    /**
+     * Set the global opacity applied to all subsequent draw calls.
+     *
+     * @param alpha - Opacity in the range `[0, 1]`.
+     */
+    setGlobalAlpha(alpha: number): void;
+    /**
+     * Intersect the current clip region with a rectangle. Affects all subsequent
+     * draws until the next {@link restore}; wrap in {@link save}/{@link restore}.
+     *
+     * @param x - Left edge.
+     * @param y - Top edge.
+     * @param width - Rectangle width.
+     * @param height - Rectangle height.
+     */
+    clip(x: number, y: number, width: number, height: number): void;
+    /** Begin a new sub-path, discarding the current path. */
+    beginPath(): void;
+    /**
+     * Move the pen to the given point without drawing a line.
+     *
+     * @param x - Target X coordinate.
+     * @param y - Target Y coordinate.
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * Add a straight line segment from the current pen position to the given point.
+     *
+     * @param x - Target X coordinate.
+     * @param y - Target Y coordinate.
+     */
+    lineTo(x: number, y: number): void;
+    /**
+     * Add a cubic Bézier curve to the current path.
+     *
+     * @param cp1x - X of the first control point.
+     * @param cp1y - Y of the first control point.
+     * @param cp2x - X of the second control point.
+     * @param cp2y - Y of the second control point.
+     * @param x - X of the end point.
+     * @param y - Y of the end point.
+     */
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    /** Close the current sub-path by drawing a line back to its starting point. */
+    closePath(): void;
+    /**
+     * Add a circular arc to the current path.
+     *
+     * @param x - X of the arc center.
+     * @param y - Y of the arc center.
+     * @param radius - Arc radius in pixels.
+     * @param startAngle - Start angle in radians (0 = 3 o'clock).
+     * @param endAngle - End angle in radians.
+     * @param counterclockwise - If `true`, draws the arc counter-clockwise.
+     */
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    /**
+     * Add a rounded rectangle to the current path.
+     *
+     * @param x - Left edge.
+     * @param y - Top edge.
+     * @param width - Rectangle width.
+     * @param height - Rectangle height.
+     * @param radii - Corner radius (uniform) or per-corner array as accepted by `CanvasRenderingContext2D.roundRect()`.
+     */
+    roundRect(x: number, y: number, width: number, height: number, radii: number | number[]): void;
+    /**
+     * Draw an image or video frame into the canvas.
+     *
+     * @param source - The image source (HTMLImageElement, HTMLVideoElement, HTMLCanvasElement, etc.).
+     * @param dx - Destination X.
+     * @param dy - Destination Y.
+     * @param dw - Destination width.
+     * @param dh - Destination height.
+     */
+    drawImage(source: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
+    /**
+     * Fill the current path with the given color or gradient.
+     *
+     * @param colorOrGradient - CSS color string or a gradient object.
+     */
+    fill(colorOrGradient: string | any): void;
+    /**
+     * Stroke the current path with the given color or gradient.
+     *
+     * @param colorOrGradient - CSS color string or a gradient object.
+     * @param lineWidth - Stroke width in pixels (default: `1`).
+     */
+    stroke(colorOrGradient: string | any, lineWidth?: number): void;
+    /**
+     * Render a text string at the given position.
+     *
+     * @param text - The string to draw.
+     * @param x - Left edge of the text baseline.
+     * @param y - Baseline Y coordinate.
+     * @param font - CSS font shorthand, e.g. `'16px monospace'`.
+     * @param color - CSS color string or gradient.
+     */
+    fillText(text: string, x: number, y: number, font: string, color: string | any): void;
+    /**
+     * Draw a filled circle through the order-preserving batch.
+     *
+     * Consecutive calls sharing the same `color` and `alpha` are coalesced into a
+     * single path and committed with one `fill()` on {@link flush} (or when the
+     * style changes / another draw call intervenes). Coordinates are in the
+     * current transform space. This collapses the per-entity
+     * `beginPath`/`arc`/`fill` of large point clouds into a handful of draw calls
+     * while preserving painter's-order semantics.
+     *
+     * @param cx - Center X in the current transform space.
+     * @param cy - Center Y in the current transform space.
+     * @param radius - Circle radius.
+     * @param color - CSS color string.
+     * @param alpha - Opacity in `[0, 1]` (default `1`).
+     */
+    fillCircle(cx: number, cy: number, radius: number, color: string, alpha?: number): void;
+    /**
+     * Commit any pending batched draws (see {@link fillCircle}). Safe to call when
+     * no batch is active (no-op). The {@link Scene} flushes at the end of each
+     * sibling group and frame.
+     */
+    flush(): void;
+    /**
+     * Create a linear gradient between two points with the given color stops.
+     *
+     * @param x0 - X of the gradient start point.
+     * @param y0 - Y of the gradient start point.
+     * @param x1 - X of the gradient end point.
+     * @param y1 - Y of the gradient end point.
+     * @param colorStops - Array of `{ stop, color }` pairs where `stop` is in `[0, 1]`.
+     * @returns An opaque gradient object suitable for {@link fill} or {@link stroke}.
+     */
+    createLinearGradient(x0: number, y0: number, x1: number, y1: number, colorStops: {
+        stop: number;
+        color: string;
+    }[]): any;
+}

package/dist/renderer/SVGRenderer.d.ts

@@ -0,0 +1,69 @@
+import { IRenderer } from './IRenderer';
+export interface SVGLinearGradient {
+    type: 'linear';
+    id?: string;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    colorStops: {
+        stop: number;
+        color: string;
+    }[];
+    createMatrix: number[];
+}
+export declare class SVGRenderer implements IRenderer {
+    private width;
+    private height;
+    private buffer;
+    private defsBuffer;
+    private currentPath;
+    private mStack;
+    private ma;
+    private mb;
+    private mc;
+    private md;
+    private me;
+    private mf;
+    private alphaStack;
+    private globalAlpha;
+    private clipDepthStack;
+    private clipDepth;
+    private clipCounter;
+    private batchCircles;
+    private batchMatrix;
+    private batchColor;
+    private batchAlpha;
+    private batchActive;
+    private gradientCounter;
+    private gradientCache;
+    constructor(width: number, height: number);
+    clear(): void;
+    save(): void;
+    restore(): void;
+    translate(dx: number, dy: number): void;
+    scale(sx: number, sy: number): void;
+    rotate(angle: number): void;
+    setGlobalAlpha(alpha: number): void;
+    beginPath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    closePath(): void;
+    arc(x: number, y: number, r: number, startAngle: number, endAngle: number, ccw?: boolean): void;
+    roundRect(x: number, y: number, w: number, h: number, radii: number | number[]): void;
+    fill(colorOrGradient: string | SVGLinearGradient): void;
+    stroke(colorOrGradient: string | SVGLinearGradient, lineWidth?: number): void;
+    fillText(text: string, x: number, y: number, font: string, color: string | SVGLinearGradient): void;
+    fillCircle(cx: number, cy: number, radius: number, color: string, alpha?: number): void;
+    drawImage(source: any, dx: number, dy: number, dw: number, dh: number): void;
+    flush(): void;
+    createLinearGradient(x0: number, y0: number, x1: number, y1: number, colorStops: {
+        stop: number;
+        color: string;
+    }[]): SVGLinearGradient;
+    clip(x: number, y: number, width: number, height: number): void;
+    toXMLString(): string;
+    private resolveGradient;
+    private escapeXML;
+}

package/dist/renderer/WebGLPointRenderer.d.ts

@@ -0,0 +1,62 @@
+/**
+ * A GPU-accelerated layer that draws large sets of circles and rectangles in a
+ * couple of draw calls. Used by {@link Scene} (via `pointBackend: 'webgl'`) to
+ * render `getBatchCircle()` / `getBatchRect()` entities — the point-cloud /
+ * particle case where Canvas2D tops out at ~7 fps for 100k primitives.
+ */
+export interface PointRenderer {
+    /** Resize the backing buffer + GL viewport to a logical `w × h` (DPR applied). */
+    resize(width: number, height: number): void;
+    /** Begin a frame: reset the accumulated primitive buffers. */
+    begin(): void;
+    /** Add one circle in world (CSS-pixel) coordinates; `alpha` multiplies the color's. */
+    addCircle(x: number, y: number, radius: number, color: string, alpha?: number): void;
+    /**
+     * Add one rectangle: top-left at world `(x, y)`, `width × height` in world units,
+     * rotated `rotation` radians about `(x, y)`; `alpha` multiplies the color's.
+     */
+    addRect(x: number, y: number, width: number, height: number, color: string, alpha?: number, rotation?: number): void;
+    /**
+     * Upload a texture atlas used by {@link addSprite}. Pass any `TexImageSource`
+     * (HTMLImageElement, HTMLCanvasElement, ImageBitmap, …). Call once (or whenever
+     * the atlas changes) before adding sprites.
+     */
+    setTexture(source: TexImageSource): void;
+    /**
+     * Add one textured sprite sampling the atlas region `[u0,v0]–[u1,v1]` (UVs in
+     * `0..1`): top-left at world `(x, y)`, `width × height` in world units, rotated
+     * `rotation` radians about `(x, y)`. `color` multiplies the sampled texel
+     * (white = unchanged; use it to tint white glyphs); `alpha` multiplies further.
+     * No-op until a texture is set via {@link setTexture}.
+     */
+    addSprite(x: number, y: number, width: number, height: number, u0: number, v0: number, u1: number, v1: number, color?: string, alpha?: number, rotation?: number): void;
+    /**
+     * Upload an MSDF (multi-channel signed distance field) glyph atlas used by
+     * {@link addGlyph}, kept separate from the {@link setTexture} atlas so both can
+     * be active. `distanceRange` is the field's pixel range (the atlas JSON's
+     * `atlas.distanceRange`) — it drives the shader's edge sharpness. Pair with
+     * `MSDFFont.layout` to position the glyphs.
+     */
+    setMSDFTexture(source: TexImageSource, distanceRange: number): void;
+    /**
+     * Add one MSDF glyph quad sampling `[u0,v0]–[u1,v1]` (UVs in `0..1`): top-left
+     * at world `(x, y)`, `width × height` in world units. The fragment shader
+     * reconstructs a crisp, resolution-independent edge from the distance field, so
+     * glyphs stay sharp at any scale. `color` tints the glyph (default white);
+     * `alpha` multiplies coverage. No-op until {@link setMSDFTexture} is called.
+     */
+    addGlyph(x: number, y: number, width: number, height: number, u0: number, v0: number, u1: number, v1: number, color?: string, alpha?: number, rotation?: number): void;
+    /** Clear the layer and draw all accumulated primitives. */
+    flush(): void;
+    /** Release GL resources. */
+    destroy(): void;
+}
+/**
+ * Create a WebGL2-backed {@link PointRenderer} on `canvas`, or `null` when WebGL2
+ * (or shader compilation) is unavailable — callers fall back to Canvas2D.
+ *
+ * @param canvas - A dedicated canvas (WebGL2 context); should be stacked over the
+ *   scene's 2D canvas.
+ * @returns A point renderer, or `null` if WebGL2 isn't supported.
+ */
+export declare function createWebGLPointRenderer(canvas: HTMLCanvasElement): PointRenderer | null;

package/dist/renderer/WebGPUParticleSystemManager.d.ts

@@ -0,0 +1,14 @@
+import { ComputeParticleEntity } from '../tree/ComputeParticleEntity';
+export declare class WebGPUParticleSystemManager {
+    private device;
+    private computePipeline;
+    private renderPipeline;
+    private computeBindGroupLayout;
+    private renderBindGroupLayout;
+    constructor(device: GPUDevice);
+    initPipelines(format: GPUTextureFormat): void;
+    setupEntityResources(entity: ComputeParticleEntity): void;
+    recordComputePass(pass: GPUComputePassEncoder, entity: ComputeParticleEntity, dt: number, mouseX: number, mouseY: number, width: number, height: number): void;
+    recordRenderPass(pass: GPURenderPassEncoder, entity: ComputeParticleEntity): void;
+    destroy(): void;
+}

package/dist/renderer/colorParse.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Parsed color as normalized `[r, g, b, a]` floats in `[0, 1]`.
+ */
+export type RGBA = [number, number, number, number];
+/**
+ * Parse a CSS color string into normalized `[r, g, b, a]` floats.
+ *
+ * Fast paths handle `#rgb`/`#rgba`/`#rrggbb`/`#rrggbbaa` and `rgb()`/`rgba()`;
+ * other forms (named colors, `hsl()`, …) resolve via a cached 1×1 canvas when a
+ * DOM is available. Results are cached per input string and shared by identity,
+ * so callers must treat the returned array as read-only. Unparseable input with
+ * no DOM yields opaque black `[0, 0, 0, 1]`.
+ *
+ * @param css - A CSS color string, e.g. `'#38bdf8'` or `'rgba(0,0,0,.5)'`.
+ * @returns The cached `[r, g, b, a]` tuple in `[0, 1]`.
+ */
+export declare function parseColorToRGBA(css: string): RGBA;

package/dist/renderer/index.d.ts

@@ -0,0 +1,6 @@
+export * from './CanvasRenderer';
+export * from './SVGRenderer';
+export * from './WebGLPointRenderer';
+export * from './WebGPUParticleSystemManager';
+export * from './IRenderer';
+export * from './colorParse';

package/dist/text/ArabicShaper.d.ts

@@ -0,0 +1,10 @@
+export interface ShapedResult {
+    shapedText: string;
+    indexMap: Int32Array;
+}
+export declare class ArabicShaper {
+    private static MAPPINGS;
+    private static isHarakat;
+    private static getJoiningType;
+    static shapeArabic(text: string): ShapedResult;
+}

package/dist/text/BidiResolver.d.ts

@@ -0,0 +1,6 @@
+export declare class BidiResolver {
+    private static getDirectionClass;
+    static getBaseLevel(text: string): number;
+    static resolveLevels(text: string): Uint8Array;
+    static reorderVisual(nodes: any[], baseLevel: number): void;
+}

package/dist/{text.d.ts → text/MSDFFont.d.ts}

@@ -1,5 +1,3 @@
-import { E as Entity, I as IRenderer } from './Entity-D-rfAFCf.js';
-
 /**
  * MSDF (Multi-channel Signed Distance Field) font support.
  *
@@ -14,7 +12,7 @@ import { E as Entity, I as IRenderer } from './Entity-D-rfAFCf.js';
  * Y-flip, the same as `setTexture`/`addSprite`).
  */
 /** Atlas section of an `msdf-atlas-gen` JSON file. */
-interface MSDFAtlasInfo {
+export interface MSDFAtlasInfo {
     /** Field type, e.g. `'msdf'` | `'mtsdf'` | `'sdf'`. */
     type: string;
     /** Distance field range in atlas pixels — drives the shader's edge sharpness. */
@@ -29,7 +27,7 @@ interface MSDFAtlasInfo {
     yOrigin: 'bottom' | 'top';
 }
 /** Font-wide metrics in em units. */
-interface MSDFMetrics {
+export interface MSDFMetrics {
     emSize: number;
     /** Line advance in em (multiply by font size for px). */
     lineHeight: number;
@@ -41,14 +39,14 @@ interface MSDFMetrics {
     underlineThickness?: number;
 }
 /** Em-unit / atlas-pixel rectangle as emitted by `msdf-atlas-gen`. */
-interface MSDFBounds {
+export interface MSDFBounds {
     left: number;
     bottom: number;
     right: number;
     top: number;
 }
 /** One glyph's metrics. Whitespace has `advance` but no plane/atlas bounds. */
-interface MSDFGlyphDef {
+export interface MSDFGlyphDef {
     unicode: number;
     /** Horizontal advance in em units. */
     advance: number;
@@ -58,20 +56,20 @@ interface MSDFGlyphDef {
     atlasBounds?: MSDFBounds;
 }
 /** Kerning pair adjustment in em units. */
-interface MSDFKerning {
+export interface MSDFKerning {
     unicode1: number;
     unicode2: number;
     advance: number;
 }
 /** A parsed `msdf-atlas-gen` JSON document. */
-interface MSDFFontData {
+export interface MSDFFontData {
     atlas: MSDFAtlasInfo;
     metrics: MSDFMetrics;
     glyphs: MSDFGlyphDef[];
     kerning?: MSDFKerning[];
 }
 /** A glyph positioned for rendering: a CSS-pixel quad + atlas UVs (0..1). */
-interface PositionedGlyph {
+export interface PositionedGlyph {
     /** Source character (may be a surrogate-pair astral codepoint). */
     char: string;
     /** Quad top-left in local CSS pixels (y-down). */
@@ -87,7 +85,7 @@ interface PositionedGlyph {
     v1: number;
 }
 /** Result of {@link MSDFFont.layout}. */
-interface MSDFLayoutResult {
+export interface MSDFLayoutResult {
     glyphs: PositionedGlyph[];
     /** Total pen advance of the widest line in CSS pixels. */
     width: number;
@@ -95,7 +93,7 @@ interface MSDFLayoutResult {
     height: number;
 }
 /** Options for {@link MSDFFont.layout}. */
-interface MSDFLayoutOptions {
+export interface MSDFLayoutOptions {
     /** Pen origin x (left of the first glyph), CSS pixels. Default 0. */
     x?: number;
     /** Text-block top y (baseline of line 0 = `y + ascender×size`). Default 0. */
@@ -107,7 +105,7 @@ interface MSDFLayoutOptions {
  * A loaded MSDF font. Construct from parsed {@link MSDFFontData}, or use
  * {@link MSDFFont.parse} to read the JSON string straight from `msdf-atlas-gen`.
  */
-declare class MSDFFont {
+export declare class MSDFFont {
     private static idCounter;
     readonly id: string;
     readonly data: MSDFFontData;
@@ -129,73 +127,3 @@ declare class MSDFFont {
      */
     layout(text: string, fontSizePx: number, opts?: MSDFLayoutOptions): MSDFLayoutResult;
 }
-
-interface MSDFTextEntityOptions {
-    font: MSDFFont;
-    texture: TexImageSource;
-    fallbackFont?: string;
-    fontSize?: number;
-    color?: string;
-    lineHeight?: number;
-    letterSpacing?: number;
-}
-declare class MSDFTextEntity extends Entity {
-    private font;
-    private texture;
-    private fallbackFont;
-    private fontSize;
-    color: string;
-    private letterSpacing;
-    private lineHeight?;
-    private text;
-    private lastRenderedSeqId;
-    private rgbColorCache;
-    private fontStringCache;
-    private layoutResult;
-    constructor(text: string, options: MSDFTextEntityOptions);
-    setText(text: string): void;
-    isPointInside(globalX: number, globalY: number): boolean;
-    render(renderer: any): void;
-    destroy(): void;
-}
-
-declare class SVGEntity extends Entity {
-    private svgSource;
-    private imageBitmap;
-    private imageElement;
-    private blobURL;
-    private currentImg;
-    private lodTimeout;
-    private cachedDoc;
-    private baseWidth;
-    private baseHeight;
-    private lastRasterizedScale;
-    private targetScale;
-    constructor(svgSource: string, id?: string);
-    setSVGSource(svgSource: string): void;
-    private parseSVGDimensions;
-    private triggerRasterization;
-    isPointInside(globalX: number, globalY: number): boolean;
-    render(r: IRenderer): void;
-    destroy(): void;
-}
-
-interface ShapedResult {
-    shapedText: string;
-    indexMap: Int32Array;
-}
-declare class ArabicShaper {
-    private static MAPPINGS;
-    private static isHarakat;
-    private static getJoiningType;
-    static shapeArabic(text: string): ShapedResult;
-}
-
-declare class BidiResolver {
-    private static getDirectionClass;
-    static getBaseLevel(text: string): number;
-    static resolveLevels(text: string): Uint8Array;
-    static reorderVisual(nodes: any[], baseLevel: number): void;
-}
-
-export { ArabicShaper, BidiResolver, type MSDFAtlasInfo, type MSDFBounds, MSDFFont, type MSDFFontData, type MSDFGlyphDef, type MSDFKerning, type MSDFLayoutOptions, type MSDFLayoutResult, type MSDFMetrics, MSDFTextEntity, type MSDFTextEntityOptions, type PositionedGlyph, SVGEntity, type ShapedResult };

package/dist/text/MSDFTextEntity.d.ts

@@ -0,0 +1,30 @@
+import { Entity } from '../tree/Entity';
+import { MSDFFont } from './MSDFFont';
+export interface MSDFTextEntityOptions {
+    font: MSDFFont;
+    texture: TexImageSource;
+    fallbackFont?: string;
+    fontSize?: number;
+    color?: string;
+    lineHeight?: number;
+    letterSpacing?: number;
+}
+export declare class MSDFTextEntity extends Entity {
+    private font;
+    private texture;
+    private fallbackFont;
+    private fontSize;
+    color: string;
+    private letterSpacing;
+    private lineHeight?;
+    private text;
+    private lastRenderedSeqId;
+    private rgbColorCache;
+    private fontStringCache;
+    private layoutResult;
+    constructor(text: string, options: MSDFTextEntityOptions);
+    setText(text: string): void;
+    isPointInside(globalX: number, globalY: number): boolean;
+    render(renderer: any): void;
+    destroy(): void;
+}

package/dist/text/SVGEntity.d.ts

@@ -0,0 +1,22 @@
+import { Entity } from '../tree/Entity';
+import { IRenderer } from '../renderer/IRenderer';
+export declare class SVGEntity extends Entity {
+    private svgSource;
+    private imageBitmap;
+    private imageElement;
+    private blobURL;
+    private currentImg;
+    private lodTimeout;
+    private cachedDoc;
+    private baseWidth;
+    private baseHeight;
+    private lastRasterizedScale;
+    private targetScale;
+    constructor(svgSource: string, id?: string);
+    setSVGSource(svgSource: string): void;
+    private parseSVGDimensions;
+    private triggerRasterization;
+    isPointInside(globalX: number, globalY: number): boolean;
+    render(r: IRenderer): void;
+    destroy(): void;
+}

package/dist/text/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ArabicShaper';
+export * from './BidiResolver';
+export * from './MSDFFont';
+export * from './MSDFTextEntity';
+export * from './SVGEntity';

package/dist/text.js

@@ -2,7 +2,7 @@
 
 
 
-var _chunk53DAQC3Ujs = require('./chunk-53DAQC3U.js');
+var _chunkLA3FJLP2js = require('./chunk-LA3FJLP2.js');
 
 
 
@@ -13,4 +13,4 @@ var _chunkRW6NC4RBjs = require('./chunk-RW6NC4RB.js');
 
 
 
-exports.ArabicShaper = _chunkRW6NC4RBjs.ArabicShaper; exports.BidiResolver = _chunkRW6NC4RBjs.BidiResolver; exports.MSDFFont = _chunk53DAQC3Ujs.MSDFFont; exports.MSDFTextEntity = _chunk53DAQC3Ujs.MSDFTextEntity; exports.SVGEntity = _chunk53DAQC3Ujs.SVGEntity;
+exports.ArabicShaper = _chunkRW6NC4RBjs.ArabicShaper; exports.BidiResolver = _chunkRW6NC4RBjs.BidiResolver; exports.MSDFFont = _chunkLA3FJLP2js.MSDFFont; exports.MSDFTextEntity = _chunkLA3FJLP2js.MSDFTextEntity; exports.SVGEntity = _chunkLA3FJLP2js.SVGEntity;

package/dist/text.mjs

@@ -2,7 +2,7 @@ import {
   MSDFFont,
   MSDFTextEntity,
   SVGEntity
-} from "./chunk-M2IZPGOL.mjs";
+} from "./chunk-H3QIE77O.mjs";
 import {
   ArabicShaper,
   BidiResolver