three-text 0.1.1 → 0.2.0

package/dist/p5/index.js

@@ -0,0 +1,31 @@
+// p5.js adapter - converts core geometry to p5.Geometry
+function createP5Geometry(p5Instance, textGeometry) {
+    // In global mode, p5.Geometry exists but createVector is global
+    // In instance mode, both are on the instance
+    const P5Geometry = p5Instance.Geometry || window.p5?.Geometry;
+    const createVec = p5Instance.createVector || window.createVector;
+    if (!P5Geometry || !createVec) {
+        throw new Error('p5.js not found. Make sure p5.js is loaded before calling this function.');
+    }
+    const geom = new P5Geometry();
+    const { vertices, normals, indices } = textGeometry;
+    // Convert vertices (flip Y for p5.js coordinate system)
+    for (let i = 0; i < vertices.length; i += 3) {
+        geom.vertices.push(createVec(vertices[i], -vertices[i + 1], vertices[i + 2]));
+    }
+    // Convert normals (flip Y)
+    for (let i = 0; i < normals.length; i += 3) {
+        geom.vertexNormals.push(createVec(normals[i], -normals[i + 1], normals[i + 2]));
+    }
+    // Convert indices to faces
+    for (let i = 0; i < indices.length; i += 3) {
+        geom.faces.push([
+            indices[i],
+            indices[i + 1],
+            indices[i + 2]
+        ]);
+    }
+    return geom;
+}
+
+export { createP5Geometry };

package/dist/three/index.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var three = require('three');
+var Text$1 = require('../index.cjs');
+
+// Three.js adapter - wraps core text processing and returns BufferGeometry
+// This is a thin convenience layer for Three.js users
+class Text {
+    // Delegate static methods to core
+    static { this.setHarfBuzzPath = Text$1.Text.setHarfBuzzPath; }
+    static { this.setHarfBuzzBuffer = Text$1.Text.setHarfBuzzBuffer; }
+    static { this.init = Text$1.Text.init; }
+    static { this.registerPattern = Text$1.Text.registerPattern; }
+    static { this.preloadPatterns = Text$1.Text.preloadPatterns; }
+    // Main API - wraps core result in BufferGeometry
+    static async create(options) {
+        const coreResult = await Text$1.Text.create(options);
+        // Create BufferGeometry from raw arrays
+        const geometry = new three.BufferGeometry();
+        geometry.setAttribute('position', new three.Float32BufferAttribute(coreResult.vertices, 3));
+        geometry.setAttribute('normal', new three.Float32BufferAttribute(coreResult.normals, 3));
+        geometry.setIndex(Array.from(coreResult.indices));
+        // Add optional attributes
+        if (coreResult.colors) {
+            geometry.setAttribute('color', new three.Float32BufferAttribute(coreResult.colors, 3));
+        }
+        if (coreResult.glyphAttributes) {
+            geometry.setAttribute('glyphCenter', new three.Float32BufferAttribute(coreResult.glyphAttributes.glyphCenter, 3));
+            geometry.setAttribute('glyphIndex', new three.Float32BufferAttribute(coreResult.glyphAttributes.glyphIndex, 1));
+            geometry.setAttribute('glyphLineIndex', new three.Float32BufferAttribute(coreResult.glyphAttributes.glyphLineIndex, 1));
+        }
+        geometry.computeBoundingBox();
+        // Return Three.js specific interface with utility methods
+        return {
+            geometry,
+            glyphs: coreResult.glyphs,
+            planeBounds: coreResult.planeBounds,
+            stats: coreResult.stats,
+            query: coreResult.query,
+            coloredRanges: coreResult.coloredRanges,
+            // Pass through utility methods from core
+            getLoadedFont: coreResult.getLoadedFont,
+            getCacheStatistics: coreResult.getCacheStatistics,
+            clearCache: coreResult.clearCache,
+            measureTextWidth: coreResult.measureTextWidth
+        };
+    }
+}
+
+exports.Text = Text;

package/dist/three/index.d.ts

@@ -0,0 +1,29 @@
+import { BufferGeometry } from 'three';
+import { Text as Text$1 } from '../core/Text';
+import { TextGeometryInfo, LoadedFont, TextOptions } from '../core/types';
+export { LoadedFont, TextOptions } from '../core/types';
+
+interface HyphenationTrieNode {
+    patterns: number[] | null;
+    children: {
+        [char: string]: HyphenationTrieNode;
+    };
+}
+
+interface ThreeTextGeometryInfo extends Omit<TextGeometryInfo, 'vertices' | 'normals' | 'indices' | 'colors' | 'glyphAttributes'> {
+    geometry: BufferGeometry;
+    getLoadedFont(): LoadedFont | undefined;
+    getCacheStatistics(): any;
+    clearCache(): void;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+}
+declare class Text {
+    static setHarfBuzzPath: typeof Text$1.setHarfBuzzPath;
+    static setHarfBuzzBuffer: typeof Text$1.setHarfBuzzBuffer;
+    static init: typeof Text$1.init;
+    static registerPattern: typeof Text$1.registerPattern;
+    static preloadPatterns: typeof Text$1.preloadPatterns;
+    static create(options: TextOptions): Promise<ThreeTextGeometryInfo>;
+}
+
+export { HyphenationTrieNode, Text, ThreeTextGeometryInfo as TextGeometryInfo, ThreeTextGeometryInfo };

package/dist/three/index.js

@@ -0,0 +1,48 @@
+import { BufferGeometry, Float32BufferAttribute } from 'three';
+import { Text as Text$1 } from '../index.js';
+
+// Three.js adapter - wraps core text processing and returns BufferGeometry
+// This is a thin convenience layer for Three.js users
+class Text {
+    // Delegate static methods to core
+    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; }
+    // Main API - wraps core result in BufferGeometry
+    static async create(options) {
+        const coreResult = await Text$1.create(options);
+        // Create BufferGeometry from raw arrays
+        const geometry = new BufferGeometry();
+        geometry.setAttribute('position', new Float32BufferAttribute(coreResult.vertices, 3));
+        geometry.setAttribute('normal', new Float32BufferAttribute(coreResult.normals, 3));
+        geometry.setIndex(Array.from(coreResult.indices));
+        // Add optional attributes
+        if (coreResult.colors) {
+            geometry.setAttribute('color', new Float32BufferAttribute(coreResult.colors, 3));
+        }
+        if (coreResult.glyphAttributes) {
+            geometry.setAttribute('glyphCenter', new Float32BufferAttribute(coreResult.glyphAttributes.glyphCenter, 3));
+            geometry.setAttribute('glyphIndex', new Float32BufferAttribute(coreResult.glyphAttributes.glyphIndex, 1));
+            geometry.setAttribute('glyphLineIndex', new Float32BufferAttribute(coreResult.glyphAttributes.glyphLineIndex, 1));
+        }
+        geometry.computeBoundingBox();
+        // Return Three.js specific interface with utility methods
+        return {
+            geometry,
+            glyphs: coreResult.glyphs,
+            planeBounds: coreResult.planeBounds,
+            stats: coreResult.stats,
+            query: coreResult.query,
+            coloredRanges: coreResult.coloredRanges,
+            // Pass through utility methods from core
+            getLoadedFont: coreResult.getLoadedFont,
+            getCacheStatistics: coreResult.getCacheStatistics,
+            clearCache: coreResult.clearCache,
+            measureTextWidth: coreResult.measureTextWidth
+        };
+    }
+}
+
+export { Text };

package/dist/{react/index.cjs → three/react.cjs}

@@ -3,7 +3,7 @@
 var jsxRuntime = require('react/jsx-runtime');
 var react = require('react');
 var THREE = require('three');
-var Text = require('../index.cjs');
+var index = require('./index');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -50,7 +50,7 @@ function useDeepCompareMemo(value) {
     }
     return ref.current;
 }
-const ThreeText = react.forwardRef(function ThreeText(props, ref) {
+const Text$1 = react.forwardRef(function Text(props, ref) {
     const { children, font, material, position = [0, 0, 0], rotation = [0, 0, 0], scale = [1, 1, 1], onLoad, onError, vertexColors = true, ...restOptions } = props;
     const [geometry, setGeometry] = react.useState(null);
     const [error, setError] = react.useState(null);
@@ -67,7 +67,7 @@ const ThreeText = react.forwardRef(function ThreeText(props, ref) {
                 setError(null);
                 if (cancelled)
                     return;
-                const text = await Text.Text.create({
+                const text = await index.Text.create({
                     text: children,
                     font,
                     ...memoizedTextOptions,
@@ -118,4 +118,14 @@ const ThreeText = react.forwardRef(function ThreeText(props, ref) {
     return (jsxRuntime.jsx("mesh", { ref: ref, geometry: geometry, material: finalMaterial, position: position, rotation: rotation, scale: scale }));
 });
 
-exports.ThreeText = ThreeText;
+// Attach static methods from ThreeText to the React component
+const Text = Object.assign(Text$1, {
+    setHarfBuzzPath: index.Text.setHarfBuzzPath,
+    setHarfBuzzBuffer: index.Text.setHarfBuzzBuffer,
+    init: index.Text.init,
+    registerPattern: index.Text.registerPattern,
+    preloadPatterns: index.Text.preloadPatterns,
+    create: index.Text.create
+});
+
+exports.Text = Text;

package/dist/three/react.d.ts

@@ -0,0 +1,346 @@
+import * as react from 'react';
+import * as THREE from 'three';
+import { TextOptions as TextOptions$1, ThreeTextGeometryInfo, Text as Text$2 } from './index';
+
+interface BoundingBox {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+
+interface HyphenationTrieNode {
+    patterns: number[] | null;
+    children: {
+        [char: string]: HyphenationTrieNode;
+    };
+}
+
+type TextAlign = 'left' | 'center' | 'right' | 'justify';
+type TextDirection = 'ltr' | 'rtl';
+interface LoadedFont {
+    hb: HarfBuzzAPI;
+    fontBlob: HarfBuzzBlob;
+    face: HarfBuzzFace;
+    font: HarfBuzzFont;
+    module: HarfBuzzModule;
+    upem: number;
+    metrics: ExtractedMetrics;
+    fontVariations?: {
+        [key: string]: number;
+    };
+    isVariable?: boolean;
+    variationAxes?: {
+        [key: string]: VariationAxis;
+    };
+    _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) => 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 PathInfo {
+    start: number;
+    count: number;
+}
+interface GlyphGeometryInfo {
+    textIndex: number;
+    lineIndex: number;
+    vertexStart: number;
+    vertexCount: number;
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    paths?: PathInfo[];
+}
+interface TextRange {
+    start: number;
+    end: number;
+    originalText: string;
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }[];
+    glyphs: GlyphGeometryInfo[];
+    lineIndices: number[];
+}
+interface TextQueryOptions {
+    byText?: string[];
+    byCharRange?: {
+        start: number;
+        end: number;
+    }[];
+}
+interface TextGeometryInfo {
+    vertices: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    colors?: Float32Array;
+    glyphAttributes?: {
+        glyphCenter: Float32Array;
+        glyphIndex: Float32Array;
+        glyphLineIndex: Float32Array;
+    };
+    glyphs: GlyphGeometryInfo[];
+    planeBounds: BoundingBox;
+    stats: {
+        trianglesGenerated: number;
+        verticesGenerated: number;
+        pointsRemovedByVisvalingam: number;
+        pointsRemovedByColinear: number;
+        originalPointCount: number;
+    };
+    query(options: TextQueryOptions): TextRange[];
+    coloredRanges?: ColoredRange[];
+}
+interface ColorByRange {
+    start: number;
+    end: number;
+    color: [number, number, number];
+}
+interface ColorOptions {
+    default?: [number, number, number];
+    byText?: {
+        [text: string]: [number, number, number];
+    };
+    byCharRange?: ColorByRange[];
+}
+interface ColoredRange {
+    start: number;
+    end: number;
+    originalText: string;
+    color: [number, number, number];
+    bounds: {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }[];
+    glyphs: GlyphGeometryInfo[];
+    lineIndices: number[];
+}
+interface TextOptions {
+    text: string;
+    font?: string | ArrayBuffer;
+    size?: number;
+    depth?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+    separateGlyphsWithAttributes?: boolean;
+    fontVariations?: {
+        [key: string]: number;
+    };
+    maxTextLength?: number;
+    removeOverlaps?: boolean;
+    curveFidelity?: CurveFidelityConfig;
+    geometryOptimization?: GeometryOptimizationOptions;
+    layout?: LayoutOptions;
+    color?: [number, number, number] | ColorOptions;
+    maxCacheSizeMB?: number;
+}
+interface HyphenationPatternsMap {
+    [language: string]: HyphenationTrieNode;
+}
+interface CurveFidelityConfig {
+    distanceTolerance?: number;
+    angleTolerance?: number;
+}
+interface GeometryOptimizationOptions {
+    enabled?: boolean;
+    areaThreshold?: number;
+    colinearThreshold?: number;
+    minSegmentLength?: 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;
+    looseness?: number;
+    disableSingleWordDetection?: boolean;
+}
+
+interface GlyphCacheStats {
+    hits: number;
+    misses: number;
+    totalGlyphs: number;
+    uniqueGlyphs: number;
+    cacheSize: number;
+    saved: number;
+    memoryUsage: 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 fontIdCounter;
+    private fontLoader;
+    private loadedFont?;
+    private currentFontId;
+    private geometryBuilder?;
+    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<TextGeometryInfo & Pick<Text$1, 'getLoadedFont' | 'getCacheStatistics' | 'clearCache' | 'measureTextWidth'>>;
+    private static loadAndCacheFont;
+    private static generateFontContentHash;
+    private setLoadedFont;
+    private loadFont;
+    private createGeometry;
+    private prepareHyphenation;
+    private validateOptions;
+    private updateFontVariations;
+    private prepareLayout;
+    private applyColorSystem;
+    private finalizeGeometry;
+    getFontMetrics(): FontMetrics;
+    static preloadPatterns(languages: string[], patternsPath?: string): Promise<void>;
+    static registerPattern(language: string, pattern: HyphenationTrieNode): void;
+    getLoadedFont(): LoadedFont | undefined;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    getCacheStatistics(): GlyphCacheStats | null;
+    clearCache(): void;
+    private createGlyphAttributes;
+    destroy(): void;
+}
+
+interface ThreeTextProps extends Omit<TextOptions$1, "text"> {
+    children: string;
+    font: string | ArrayBuffer;
+    material?: THREE.Material;
+    position?: [number, number, number];
+    rotation?: [number, number, number];
+    scale?: [number, number, number];
+    onLoad?: (geometry: THREE.BufferGeometry, info: ThreeTextGeometryInfo) => void;
+    onError?: (error: Error) => void;
+    vertexColors?: boolean;
+}
+
+declare const Text: react.ForwardRefExoticComponent<ThreeTextProps & react.RefAttributes<THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>>> & {
+    setHarfBuzzPath: typeof Text$1.setHarfBuzzPath;
+    setHarfBuzzBuffer: typeof Text$1.setHarfBuzzBuffer;
+    init: typeof Text$1.init;
+    registerPattern: typeof Text$1.registerPattern;
+    preloadPatterns: typeof Text$1.preloadPatterns;
+    create: typeof Text$2.create;
+};
+
+export { Text, ThreeTextProps };

package/dist/{react/index.js → three/react.js}

@@ -1,7 +1,7 @@
 import { jsx } from 'react/jsx-runtime';
 import { forwardRef, useState, useMemo, useEffect, useRef } from 'react';
 import * as THREE from 'three';
-import { Text } from '../index.js';
+import { Text as Text$2 } from './index';
 
 function deepEqual(a, b) {
     if (a === b)
@@ -29,7 +29,7 @@ function useDeepCompareMemo(value) {
     }
     return ref.current;
 }
-const ThreeText = forwardRef(function ThreeText(props, ref) {
+const Text$1 = forwardRef(function Text(props, ref) {
     const { children, font, material, position = [0, 0, 0], rotation = [0, 0, 0], scale = [1, 1, 1], onLoad, onError, vertexColors = true, ...restOptions } = props;
     const [geometry, setGeometry] = useState(null);
     const [error, setError] = useState(null);
@@ -46,7 +46,7 @@ const ThreeText = forwardRef(function ThreeText(props, ref) {
                 setError(null);
                 if (cancelled)
                     return;
-                const text = await Text.create({
+                const text = await Text$2.create({
                     text: children,
                     font,
                     ...memoizedTextOptions,
@@ -97,4 +97,14 @@ const ThreeText = forwardRef(function ThreeText(props, ref) {
     return (jsx("mesh", { ref: ref, geometry: geometry, material: finalMaterial, position: position, rotation: rotation, scale: scale }));
 });
 
-export { ThreeText };
+// Attach static methods from ThreeText to the React component
+const Text = Object.assign(Text$1, {
+    setHarfBuzzPath: Text$2.setHarfBuzzPath,
+    setHarfBuzzBuffer: Text$2.setHarfBuzzBuffer,
+    init: Text$2.init,
+    registerPattern: Text$2.registerPattern,
+    preloadPatterns: Text$2.preloadPatterns,
+    create: Text$2.create
+});
+
+export { Text };

package/dist/types/core/Text.d.ts

@@ -40,6 +40,6 @@ export declare class Text {
     measureTextWidth(text: string, letterSpacing?: number): number;
     getCacheStatistics(): import("./cache/GlyphCache").GlyphCacheStats | null;
     clearCache(): void;
-    private addGlyphAttributes;
+    private createGlyphAttributes;
     destroy(): void;
 }

package/dist/types/core/cache/GlyphCache.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from 'three';
+import { Vec3 } from '../vectors';
 import { ProcessedGeometry } from '../types';
 export interface GlyphData {
     geometry: ProcessedGeometry;
@@ -6,14 +6,14 @@ export interface GlyphData {
     normals: Float32Array;
     indices: Uint16Array | Uint32Array;
     bounds: {
-        min: Vector3;
-        max: Vector3;
+        min: Vec3;
+        max: Vec3;
     };
     useCount: number;
 }
 export interface GlyphInstance {
     glyphId: number;
-    position: Vector3;
+    position: Vec3;
     scale: number;
     textIndex: number;
     lineIndex: number;

package/dist/types/core/cache/GlyphContourCollector.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from 'three';
+import { Vec2 } from '../vectors';
 import { GlyphContours } from '../types';
 import { OptimizationStats } from '../geometry/PathOptimizer';
 import { CurveFidelityConfig, GeometryOptimizationOptions } from '../types';
@@ -28,7 +28,7 @@ export declare class GlyphContourCollector {
     private finishPath;
     private updateBounds;
     getCollectedGlyphs(): GlyphContours[];
-    getGlyphPositions(): Vector2[];
+    getGlyphPositions(): Vec2[];
     getTextIndices(): number[];
     reset(): void;
     setCurveFidelityConfig(config?: CurveFidelityConfig): void;

package/dist/types/core/cache/GlyphGeometryBuilder.d.ts

@@ -1,9 +1,10 @@
-import { BufferGeometry } from 'three';
 import { GlyphCache } from './GlyphCache';
 import { GlyphGeometryInfo, LoadedFont, GlyphCluster } from '../types';
 import { CurveFidelityConfig, GeometryOptimizationOptions } from '../types';
 export interface InstancedTextGeometry {
-    geometry: BufferGeometry;
+    vertices: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
     glyphInfos: GlyphGeometryInfo[];
     planeBounds: {
         min: {

package/dist/types/core/geometry/BoundaryClusterer.d.ts

@@ -1,8 +1,8 @@
-import { Vector3 } from 'three';
+import { Vec3 } from '../vectors';
 import type { GlyphContours } from '../types';
 export declare class BoundaryClusterer {
     constructor();
-    cluster(glyphContoursList: GlyphContours[], positions: Vector3[]): number[][];
+    cluster(glyphContoursList: GlyphContours[], positions: Vec3[]): number[][];
     private clusterSweepLine;
     private getWorldBounds;
 }

package/dist/types/core/geometry/Polygonizer.d.ts

@@ -35,7 +35,7 @@
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
-import { Vector2 } from 'three';
+import { Vec2 } from '../vectors';
 import { CurveFidelityConfig } from '../types';
 export declare const DEFAULT_CURVE_FIDELITY: CurveFidelityConfig;
 export declare const COLLINEARITY_EPSILON = 0.000001;
@@ -43,8 +43,8 @@ export declare class Polygonizer {
     private curveFidelityConfig;
     constructor(curveFidelityConfig?: CurveFidelityConfig);
     setCurveFidelityConfig(curveFidelityConfig?: CurveFidelityConfig): void;
-    polygonizeQuadratic(start: Vector2, control: Vector2, end: Vector2): Vector2[];
-    polygonizeCubic(start: Vector2, control1: Vector2, control2: Vector2, end: Vector2): Vector2[];
+    polygonizeQuadratic(start: Vec2, control: Vec2, end: Vec2): Vec2[];
+    polygonizeCubic(start: Vec2, control1: Vec2, control2: Vec2, end: Vec2): Vec2[];
     private recursiveQuadratic;
     private recursiveCubic;
     private addPoint;