three-text 0.5.2 → 0.6.0

package/dist/vector/index.d.ts

@@ -1,35 +1,8 @@
-import { VectorGlyphInfo, TextQueryOptions, TextRange, LoadedFont as LoadedFont$1, TextOptions as TextOptions$1 } from '../core/types';
+import { Text as Text$1 } from '../core/Text';
+import { VectorGlyphInfo, TextQueryOptions, TextRange, LoadedFont, TextOptions } from '../core/types';
 export { LoadedFont, TextOptions, VectorGlyphInfo } from '../core/types';
 import * as THREE from 'three';
 
-interface HyphenationTrieNode {
-    patterns: number[] | null;
-    children: {
-        [char: string]: HyphenationTrieNode;
-    };
-}
-
-declare class Vec3 {
-    x: number;
-    y: number;
-    z: number;
-    constructor(x?: number, y?: number, z?: number);
-    set(x: number, y: number, z: number): Vec3;
-    clone(): Vec3;
-    copy(v: Vec3): Vec3;
-    add(v: Vec3): Vec3;
-    sub(v: Vec3): Vec3;
-    multiply(scalar: number): Vec3;
-    divide(scalar: number): Vec3;
-    length(): number;
-    lengthSq(): number;
-    normalize(): Vec3;
-    dot(v: Vec3): number;
-    cross(v: Vec3): Vec3;
-    distanceTo(v: Vec3): number;
-    distanceToSquared(v: Vec3): number;
-    equals(v: Vec3): boolean;
-}
 interface BoundingBox {
     min: {
         x: number;
@@ -43,386 +16,62 @@ interface BoundingBox {
     };
 }
 
-interface HarfBuzzGlyph {
-    g: number;
-    cl: number;
-    ax: number;
-    ay: number;
-    dx: number;
-    dy: number;
-    x?: number;
-    y?: number;
-    lineIndex: number;
-    absoluteTextIndex: number;
-}
-interface GlyphCluster {
-    text: string;
-    glyphs: HarfBuzzGlyph[];
-    position: Vec3;
-}
-type TextAlign = 'left' | 'center' | 'right' | 'justify';
-type TextDirection = 'ltr' | 'rtl';
-interface LineInfo {
-    text: string;
-    originalStart: number;
-    originalEnd: number;
-    xOffset: number;
-    adjustmentRatio?: number;
-    isLastLine?: boolean;
-    naturalWidth?: number;
-    endedWithHyphen?: boolean;
-}
-interface LoadedFont {
-    hb: HarfBuzzAPI;
-    fontBlob: HarfBuzzBlob;
-    face: HarfBuzzFace;
-    font: HarfBuzzFont;
-    module: HarfBuzzModule;
-    upem: number;
-    metrics: ExtractedMetrics;
-    fontVariations?: {
-        [key: string]: number;
-    };
-    fontFeatures?: {
-        [tag: string]: boolean | number;
-    };
-    isVariable?: boolean;
-    variationAxes?: {
-        [key: string]: VariationAxis;
-    };
-    availableFeatures?: string[];
-    featureNames?: {
-        [tag: string]: string;
-    };
-    _buffer?: ArrayBuffer;
-}
-interface HarfBuzzModule {
-    addFunction: (func: Function, signature: string) => number;
-    exports: any;
-    removeFunction: (ptr: number) => void;
-}
-interface VariationAxis {
-    min: number;
-    default: number;
-    max: number;
-    name?: string;
-}
-interface HarfBuzzAPI {
-    createBlob: (data: Uint8Array) => HarfBuzzBlob;
-    createFace: (blob: HarfBuzzBlob, index: number) => HarfBuzzFace;
-    createFont: (face: HarfBuzzFace) => HarfBuzzFont;
-    createBuffer: () => HarfBuzzBuffer;
-    shape: (font: HarfBuzzFont, buffer: HarfBuzzBuffer, features?: string) => void;
-}
-interface HarfBuzzBlob {
-    destroy: () => void;
-}
-interface HarfBuzzFace {
-    destroy: () => void;
-    getAxisInfos: () => {
-        [tag: string]: VariationAxis;
-    };
-}
-interface HarfBuzzFont {
-    ptr: number;
-    destroy: () => void;
-    setScale: (xScale: number, yScale: number) => void;
-    setVariations: (variations: {
-        [key: string]: number;
-    }) => void;
-}
-interface HarfBuzzBuffer {
-    addText: (text: string) => void;
-    guessSegmentProperties: () => void;
-    setDirection: (direction: string) => void;
-    json: (font: HarfBuzzFont) => any[];
-    destroy: () => void;
-}
-interface HarfBuzzInstance {
-    hb: HarfBuzzAPI;
-    module: HarfBuzzModule;
-}
-interface ExtractedMetrics {
-    isCFF: boolean;
-    unitsPerEm: number;
-    hheaAscender: number | null;
-    hheaDescender: number | null;
-    hheaLineGap: number | null;
-    typoAscender: number | null;
-    typoDescender: number | null;
-    typoLineGap: number | null;
-    winAscent: number | null;
-    winDescent: number | null;
-    axisNames: {
-        [tag: string]: string;
-    } | null;
-}
-interface FontMetrics {
-    ascender: number;
-    descender: number;
-    lineGap: number;
-    unitsPerEm: number;
-    naturalLineHeight: number;
-}
-interface TextLayoutData {
-    lines: LineInfo[];
-    scaledLineHeight: number;
-    letterSpacing: number;
-    align: string;
-    direction: TextDirection;
-    depth: number;
-    size: number;
-    pixelsPerFontUnit: number;
-}
-interface TextLayoutResult {
-    clustersByLine: GlyphCluster[][];
-    layoutData: TextLayoutData;
-    options: TextOptions;
-    loadedFont: LoadedFont;
-    fontId: string;
-}
-interface TextLayoutHandle extends TextLayoutResult {
-    getLoadedFont(): LoadedFont | undefined;
-    measureTextWidth(text: string, letterSpacing?: number): number;
-    update(options: Partial<TextOptions>): Promise<TextLayoutHandle>;
-    dispose(): void;
-}
-interface ColorByRange {
-    start: number;
-    end: number;
-    color: [number, number, number];
-}
-interface ColorOptions {
-    default?: [number, number, number];
-    byText?: {
-        [text: string]: [number, number, number];
+interface HyphenationTrieNode {
+    patterns: number[] | null;
+    children: {
+        [char: string]: HyphenationTrieNode;
     };
-    byCharRange?: ColorByRange[];
 }
-interface TextOptions {
-    text: string;
-    font: string | ArrayBuffer;
-    size?: number;
-    depth?: number;
-    lineHeight?: number;
-    letterSpacing?: number;
-    perGlyphAttributes?: boolean;
-    fontVariations?: {
-        [key: string]: number;
+
+interface SlugPackedTexture {
+    data: Float32Array | Uint32Array;
+    width: number;
+    height: number;
+}
+interface SlugGPUData {
+    curveTexture: SlugPackedTexture & {
+        data: Float32Array;
     };
-    fontFeatures?: {
-        [tag: string]: boolean | number;
+    bandTexture: SlugPackedTexture & {
+        data: Uint32Array;
     };
-    maxTextLength?: number;
-    removeOverlaps?: boolean;
-    curveSteps?: number;
-    curveFidelity?: CurveFidelityConfig;
-    geometryOptimization?: GeometryOptimizationOptions;
-    layout?: LayoutOptions;
-    color?: [number, number, number] | ColorOptions;
-}
-interface HyphenationPatternsMap {
-    [language: string]: HyphenationTrieNode;
-}
-interface CurveFidelityConfig {
-    distanceTolerance?: number;
-    angleTolerance?: number;
-    cuspLimit?: number;
-    collinearityEpsilon?: number;
-    recursionLimit?: number;
-}
-interface GeometryOptimizationOptions {
-    enabled?: boolean;
-    areaThreshold?: number;
-}
-interface LayoutOptions {
-    width?: number;
-    align?: TextAlign;
-    direction?: TextDirection;
-    respectExistingBreaks?: boolean;
-    hyphenate?: boolean;
-    language?: string;
-    patternsPath?: string;
-    tolerance?: number;
-    pretolerance?: number;
-    emergencyStretch?: number;
-    autoEmergencyStretch?: number;
-    hyphenationPatterns?: HyphenationPatternsMap;
-    lefthyphenmin?: number;
-    righthyphenmin?: number;
-    linepenalty?: number;
-    adjdemerits?: number;
-    hyphenpenalty?: number;
-    exhyphenpenalty?: number;
-    doublehyphendemerits?: number;
-}
-
-declare global {
-    interface Window {
-        hbjs?: any;
-        createHarfBuzz?: () => Promise<any>;
-    }
-}
-declare class Text$1 {
-    private static patternCache;
-    private static hbInitPromise;
-    private static fontCache;
-    private static fontLoadPromises;
-    private static fontRefCounts;
-    private static fontCacheMemoryBytes;
-    private static maxFontCacheMemoryBytes;
-    private static fontIdCounter;
-    static enableWoff2(decoder: (data: ArrayBuffer | Uint8Array) => Uint8Array | Promise<Uint8Array>): void;
-    private static stableStringify;
-    private fontLoader;
-    private loadedFont?;
-    private currentFontId;
-    private currentFontCacheKey?;
-    private textShaper?;
-    private textLayout?;
-    private constructor();
-    static setHarfBuzzPath(path: string): void;
-    static setHarfBuzzBuffer(wasmBuffer: ArrayBuffer): void;
-    static init(): Promise<HarfBuzzInstance>;
-    static create(options: TextOptions): Promise<TextLayoutHandle>;
-    private static retainFont;
-    private static releaseFont;
-    private static resolveFont;
-    private static loadAndCacheFont;
-    private static trackFontCacheAdd;
-    private static trackFontCacheRemove;
-    private static enforceFontCacheMemoryLimit;
-    private static generateFontContentHash;
-    private setLoadedFont;
-    private releaseCurrentFont;
-    private loadFont;
-    private createLayout;
-    private prepareHyphenation;
-    private validateOptions;
-    private updateFontVariations;
-    private prepareLayout;
-    getFontMetrics(): FontMetrics;
-    static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
-    static registerPattern(language: string, pattern: HyphenationTrieNode): void;
-    static setMaxFontCacheMemoryMB(limitMB: number): void;
-    getLoadedFont(): LoadedFont | undefined;
-    measureTextWidth(text: string, letterSpacing?: number): number;
-    private resetHelpers;
-    destroy(): void;
+    vertices: Float32Array;
+    indices: Uint16Array;
+    shapeCount: number;
 }
 
-interface QuadraticSegment {
-    p0x: number;
-    p0y: number;
-    p1x: number;
-    p1y: number;
-    p2x: number;
-    p2y: number;
-}
-interface ContourVertex {
-    x: number;
-    y: number;
-}
-interface VectorContour {
-    vertices: ContourVertex[];
-    segments: QuadraticSegment[];
-}
-interface VectorGlyphAttributes {
-    glyphCenter: Float32Array;
-    glyphIndex: Float32Array;
-    glyphProgress: Float32Array;
-    glyphLineIndex: Float32Array;
-    glyphBaselineY: Float32Array;
-}
-interface GlyphRange {
-    interiorIndexStart: number;
-    interiorIndexCount: number;
-    curveVertexStart: number;
-    curveVertexCount: number;
-}
-interface VectorGeometryData {
-    interiorPositions: Float32Array;
-    interiorIndices: Uint32Array;
-    curvePositions: Float32Array;
-    fillPositions: Float32Array;
-    fillIndices: Uint32Array;
-    glyphRanges: GlyphRange[];
-    interiorGlyphAttrs?: VectorGlyphAttributes;
-    curveGlyphAttrs?: VectorGlyphAttributes;
-    fillGlyphAttrs?: VectorGlyphAttributes;
-    planeBounds: BoundingBox;
-    stats: {
-        glyphCount: number;
-        contourCount: number;
-        interiorTriangleCount: number;
-        curveTriangleCount: number;
-    };
-}
-interface LoopBlinnGlyphInput {
-    offsetX: number;
-    offsetY: number;
-    segments: QuadraticSegment[];
-    bounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
+interface SlugGLSLMeshOptions {
+    color?: {
+        r: number;
+        g: number;
+        b: number;
     };
-    lineIndex: number;
-    baselineY: number;
-}
-interface LoopBlinnInput {
-    glyphs: LoopBlinnGlyphInput[];
-    planeBounds: BoundingBox;
+    animationDeclarations?: string;
+    animationBody?: string;
+    uniforms?: Record<string, THREE.IUniform>;
+    adaptiveSupersampling?: boolean;
+}
+interface SlugGLSLMesh {
+    mesh: THREE.Mesh;
+    uniforms: Record<string, THREE.IUniform>;
+    setOffset(x: number, y: number, z?: number): void;
+    setColor(r: number, g: number, b: number): void;
+    dispose(): void;
 }
-declare function extractContours(segments: QuadraticSegment[]): VectorContour[];
-declare function buildVectorGeometry(input: LoopBlinnInput): VectorGeometryData;
+declare function createSlugGLSLMesh(gpuData: SlugGPUData, options?: SlugGLSLMeshOptions): SlugGLSLMesh;
 
 interface VectorTextResult {
+    group: THREE.Group;
+    mesh: THREE.Mesh;
+    gpuData: SlugGPUData;
     glyphs: VectorGlyphInfo[];
-    geometryData: VectorGeometryData;
+    planeBounds: BoundingBox;
     query(options: TextQueryOptions): TextRange[];
-    getLoadedFont(): LoadedFont$1 | undefined;
+    getLoadedFont(): LoadedFont | undefined;
     measureTextWidth(text: string, letterSpacing?: number): number;
-    update(options: Partial<TextOptions$1>): Promise<VectorTextResult>;
-    dispose(): void;
-}
-
-interface VectorMeshOptions {
-    color?: THREE.ColorRepresentation;
-    positionNode?: any;
-    colorNode?: any;
-    center?: boolean;
-}
-interface VectorMeshes {
-    group: THREE.Group;
-    interiorMesh: THREE.Object3D;
-    curveMesh: THREE.Object3D;
-    fillMesh: THREE.Mesh;
-    interiorGeometry: THREE.BufferGeometry;
-    curveGeometry: THREE.BufferGeometry;
-    fillGeometry: THREE.BufferGeometry;
-    setOffset(x: number, y: number, z?: number): void;
-    updateMaterials(options?: VectorMeshOptions): void;
+    update(options: Partial<TextOptions>): Promise<VectorTextResult>;
     dispose(): void;
 }
-declare const loopBlinnFragment: any;
-declare function createVectorMeshes(data: VectorGeometryData, options?: VectorMeshOptions | THREE.ColorRepresentation): VectorMeshes;
-
-interface VectorTextOptions extends TextOptions$1 {
-    color?: any;
-    positionNode?: any;
-    colorNode?: any;
-    center?: boolean;
-}
-interface VectorResult extends VectorTextResult {
-    group: THREE.Group;
-    interiorGeometry: THREE.BufferGeometry;
-    curveGeometry: THREE.BufferGeometry;
-    fillGeometry: THREE.BufferGeometry;
-    updateMaterials(options?: VectorMeshOptions): void;
-    update(newOptions: Partial<VectorTextOptions>): Promise<VectorResult>;
-}
 declare class Text {
     static setHarfBuzzPath: typeof Text$1.setHarfBuzzPath;
     static setHarfBuzzBuffer: typeof Text$1.setHarfBuzzBuffer;
@@ -431,7 +80,7 @@ declare class Text {
     static preloadPatterns: typeof Text$1.preloadPatterns;
     static setMaxFontCacheMemoryMB: typeof Text$1.setMaxFontCacheMemoryMB;
     static enableWoff2: typeof Text$1.enableWoff2;
-    static create(options: VectorTextOptions): Promise<VectorResult>;
+    static create(options: TextOptions): Promise<VectorTextResult>;
 }
 
-export { GlyphRange, HyphenationTrieNode, LoopBlinnGlyphInput, LoopBlinnInput, QuadraticSegment, Text, VectorContour, VectorGeometryData, VectorGlyphAttributes, VectorMeshOptions, VectorMeshes, VectorResult, VectorTextOptions, VectorTextResult, buildVectorGeometry, createVectorMeshes, extractContours, loopBlinnFragment };
+export { HyphenationTrieNode, SlugGLSLMesh, SlugGLSLMeshOptions, SlugGPUData, Text, VectorTextResult as TextGeometryInfo, VectorTextResult, createSlugGLSLMesh };

package/dist/vector/index.js

@@ -1,223 +1,3 @@
-import { Text as Text$1 } from './core.js';
-import { createVectorMeshes } from './loopBlinnTSL.js';
-export { createVectorMeshes, loopBlinnFragment } from './loopBlinnTSL.js';
-
-const CONTOUR_EPSILON = 0.001;
-const CURVE_LINEARITY_EPSILON = 1e-5;
-function nearlyEqual(a, b, epsilon) {
-    return Math.abs(a - b) < epsilon;
-}
-function extractContours(segments) {
-    const contours = [];
-    let contourVertices = [];
-    let contourSegments = [];
-    const pushCurrentContour = () => {
-        if (contourVertices.length < 3) {
-            contourVertices = [];
-            contourSegments = [];
-            return;
-        }
-        const first = contourVertices[0];
-        const last = contourVertices[contourVertices.length - 1];
-        if (nearlyEqual(first.x, last.x, CONTOUR_EPSILON) &&
-            nearlyEqual(first.y, last.y, CONTOUR_EPSILON)) {
-            contourVertices.pop();
-        }
-        if (contourVertices.length >= 3) {
-            contours.push({
-                vertices: contourVertices,
-                segments: contourSegments
-            });
-        }
-        contourVertices = [];
-        contourSegments = [];
-    };
-    for (const segment of segments) {
-        if (contourVertices.length === 0) {
-            contourVertices.push({ x: segment.p0x, y: segment.p0y }, { x: segment.p2x, y: segment.p2y });
-            contourSegments.push(segment);
-            continue;
-        }
-        const previousEnd = contourVertices[contourVertices.length - 1];
-        if (nearlyEqual(segment.p0x, previousEnd.x, CONTOUR_EPSILON) &&
-            nearlyEqual(segment.p0y, previousEnd.y, CONTOUR_EPSILON)) {
-            contourVertices.push({ x: segment.p2x, y: segment.p2y });
-            contourSegments.push(segment);
-            continue;
-        }
-        pushCurrentContour();
-        contourVertices.push({ x: segment.p0x, y: segment.p0y }, { x: segment.p2x, y: segment.p2y });
-        contourSegments.push(segment);
-    }
-    pushCurrentContour();
-    return contours;
-}
-function triangulateContourFan(vertices, offsetX, offsetY, positions, indices) {
-    const baseIndex = positions.length / 3;
-    for (const vertex of vertices) {
-        positions.push(vertex.x + offsetX, vertex.y + offsetY, 0);
-    }
-    if (vertices.length < 3)
-        return 0;
-    for (let index = 1; index < vertices.length - 1; index++) {
-        indices.push(baseIndex, baseIndex + index, baseIndex + index + 1);
-    }
-    return vertices.length - 2;
-}
-function shouldSkipCurveSegment(segment) {
-    const dx = segment.p2x - segment.p0x;
-    const dy = segment.p2y - segment.p0y;
-    const lenSq = dx * dx + dy * dy;
-    if (lenSq <= 0)
-        return true;
-    const cross = (segment.p1x - segment.p0x) * dy - (segment.p1y - segment.p0y) * dx;
-    return Math.abs(cross) < CURVE_LINEARITY_EPSILON * lenSq;
-}
-function fillGlyphAttrs(center, idx, progress, lineIdx, baselineY, vertCount, gc, gi, gp, gl, gb) {
-    for (let v = 0; v < vertCount; v++) {
-        gc.push(center[0], center[1], center[2]);
-        gi.push(idx);
-        gp.push(progress);
-        gl.push(lineIdx);
-        gb.push(baselineY);
-    }
-}
-function packAttrs(gc, gi, gp, gl, gb) {
-    return {
-        glyphCenter: new Float32Array(gc),
-        glyphIndex: new Float32Array(gi),
-        glyphProgress: new Float32Array(gp),
-        glyphLineIndex: new Float32Array(gl),
-        glyphBaselineY: new Float32Array(gb)
-    };
-}
-function buildVectorGeometry(input) {
-    const interiorPositions = [];
-    const interiorIndices = [];
-    const curvePositions = [];
-    const iGC = [], iGI = [], iGP = [], iGL = [], iGB = [];
-    const cGC = [], cGI = [], cGP = [], cGL = [], cGB = [];
-    const fGC = [], fGI = [], fGP = [], fGL = [], fGB = [];
-    const glyphCount = input.glyphs.length;
-    let contourCount = 0;
-    let interiorTriangleCount = 0;
-    let curveTriangleCount = 0;
-    const glyphRanges = [];
-    const fillPositions = new Float32Array(glyphCount * 12);
-    const fillIndices = new Uint32Array(glyphCount * 6);
-    for (let i = 0; i < glyphCount; i++) {
-        const glyph = input.glyphs[i];
-        const { minX, minY, maxX, maxY } = glyph.bounds;
-        const cx = glyph.offsetX + (minX + maxX) * 0.5;
-        const cy = glyph.offsetY + (minY + maxY) * 0.5;
-        const center = [cx, cy, 0];
-        const progress = glyphCount > 1 ? i / (glyphCount - 1) : 0;
-        const intIdxStart = interiorIndices.length;
-        const curveVertStart = curvePositions.length / 3;
-        const contours = extractContours(glyph.segments);
-        contourCount += contours.length;
-        for (const contour of contours) {
-            const intVertsBefore = interiorPositions.length / 3;
-            interiorTriangleCount += triangulateContourFan(contour.vertices, glyph.offsetX, glyph.offsetY, interiorPositions, interiorIndices);
-            const intVertsAfter = interiorPositions.length / 3;
-            fillGlyphAttrs(center, i, progress, glyph.lineIndex, glyph.baselineY, intVertsAfter - intVertsBefore, iGC, iGI, iGP, iGL, iGB);
-            for (const segment of contour.segments) {
-                if (shouldSkipCurveSegment(segment))
-                    continue;
-                curvePositions.push(glyph.offsetX + segment.p0x, glyph.offsetY + segment.p0y, 0, glyph.offsetX + segment.p1x, glyph.offsetY + segment.p1y, 0, glyph.offsetX + segment.p2x, glyph.offsetY + segment.p2y, 0);
-                curveTriangleCount++;
-                fillGlyphAttrs(center, i, progress, glyph.lineIndex, glyph.baselineY, 3, cGC, cGI, cGP, cGL, cGB);
-            }
-        }
-        glyphRanges.push({
-            interiorIndexStart: intIdxStart,
-            interiorIndexCount: interiorIndices.length - intIdxStart,
-            curveVertexStart: curveVertStart,
-            curveVertexCount: (curvePositions.length / 3) - curveVertStart
-        });
-        const fp = i * 12;
-        fillPositions[fp] = glyph.offsetX + minX;
-        fillPositions[fp + 1] = glyph.offsetY + minY;
-        fillPositions[fp + 2] = 0;
-        fillPositions[fp + 3] = glyph.offsetX + maxX;
-        fillPositions[fp + 4] = glyph.offsetY + minY;
-        fillPositions[fp + 5] = 0;
-        fillPositions[fp + 6] = glyph.offsetX + maxX;
-        fillPositions[fp + 7] = glyph.offsetY + maxY;
-        fillPositions[fp + 8] = 0;
-        fillPositions[fp + 9] = glyph.offsetX + minX;
-        fillPositions[fp + 10] = glyph.offsetY + maxY;
-        fillPositions[fp + 11] = 0;
-        fillGlyphAttrs(center, i, progress, glyph.lineIndex, glyph.baselineY, 4, fGC, fGI, fGP, fGL, fGB);
-        const fi = i * 6;
-        const fv = i * 4;
-        fillIndices[fi] = fv;
-        fillIndices[fi + 1] = fv + 1;
-        fillIndices[fi + 2] = fv + 2;
-        fillIndices[fi + 3] = fv;
-        fillIndices[fi + 4] = fv + 2;
-        fillIndices[fi + 5] = fv + 3;
-    }
-    return {
-        interiorPositions: new Float32Array(interiorPositions),
-        interiorIndices: new Uint32Array(interiorIndices),
-        curvePositions: new Float32Array(curvePositions),
-        fillPositions,
-        fillIndices,
-        glyphRanges,
-        interiorGlyphAttrs: packAttrs(iGC, iGI, iGP, iGL, iGB),
-        curveGlyphAttrs: packAttrs(cGC, cGI, cGP, cGL, cGB),
-        fillGlyphAttrs: packAttrs(fGC, fGI, fGP, fGL, fGB),
-        planeBounds: input.planeBounds,
-        stats: {
-            glyphCount,
-            contourCount,
-            interiorTriangleCount,
-            curveTriangleCount
-        }
-    };
-}
-
-function wrapResult(coreResult, opts) {
-    const meshes = createVectorMeshes(coreResult.geometryData, {
-        color: opts.color,
-        positionNode: opts.positionNode,
-        colorNode: opts.colorNode,
-        center: opts.center,
-    });
-    return {
-        glyphs: coreResult.glyphs,
-        geometryData: coreResult.geometryData,
-        group: meshes.group,
-        interiorGeometry: meshes.interiorGeometry,
-        curveGeometry: meshes.curveGeometry,
-        fillGeometry: meshes.fillGeometry,
-        query: coreResult.query,
-        getLoadedFont: coreResult.getLoadedFont,
-        measureTextWidth: coreResult.measureTextWidth,
-        updateMaterials: meshes.updateMaterials,
-        async update(newOptions) {
-            const newCore = await coreResult.update(newOptions);
-            return wrapResult(newCore, { ...opts, ...newOptions });
-        },
-        dispose() {
-            meshes.dispose();
-            coreResult.dispose();
-        }
-    };
-}
-class Text {
-    static { this.setHarfBuzzPath = Text$1.setHarfBuzzPath; }
-    static { this.setHarfBuzzBuffer = Text$1.setHarfBuzzBuffer; }
-    static { this.init = Text$1.init; }
-    static { this.registerPattern = Text$1.registerPattern; }
-    static { this.preloadPatterns = Text$1.preloadPatterns; }
-    static { this.setMaxFontCacheMemoryMB = Text$1.setMaxFontCacheMemoryMB; }
-    static { this.enableWoff2 = Text$1.enableWoff2; }
-    static async create(options) {
-        const coreResult = await Text$1.create(options);
-        return wrapResult(coreResult, options);
-    }
-}
-
-export { Text, buildVectorGeometry, extractContours };
+import './core/index.js';
+export { T as Text, c as createSlugGLSLMesh } from './index2.js';
+import 'three';