three-text 0.5.1 → 0.6.0

package/dist/three/index.cjs

@@ -55,7 +55,8 @@ function buildThreeResult(layoutHandle, meshPipeline, options) {
         getCacheSize: () => meshPipeline.getCacheSize(),
         clearCache: () => meshPipeline.clearCache(),
         measureTextWidth: (text, letterSpacing) => layoutHandle.measureTextWidth(text, letterSpacing),
-        update
+        update,
+        dispose: () => layoutHandle.dispose()
     };
 }
 class Text {

package/dist/three/index.d.ts

@@ -17,6 +17,7 @@ interface ThreeTextGeometryInfo extends Omit<TextGeometryInfo, 'vertices' | 'nor
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<ThreeTextGeometryInfo>;
+    dispose(): void;
 }
 declare class Text {
     static setHarfBuzzPath: typeof Text$1.setHarfBuzzPath;

package/dist/three/index.js

@@ -53,7 +53,8 @@ function buildThreeResult(layoutHandle, meshPipeline, options) {
         getCacheSize: () => meshPipeline.getCacheSize(),
         clearCache: () => meshPipeline.clearCache(),
         measureTextWidth: (text, letterSpacing) => layoutHandle.measureTextWidth(text, letterSpacing),
-        update
+        update,
+        dispose: () => layoutHandle.dispose()
     };
 }
 class Text {

package/dist/three/react.cjs

@@ -69,7 +69,12 @@ 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);
-    const geometryRef = react.useRef(null);
+    const textRef = react.useRef(null);
+    const opRef = react.useRef(Promise.resolve(null));
+    const onLoadRef = react.useRef(onLoad);
+    const onErrorRef = react.useRef(onError);
+    onLoadRef.current = onLoad;
+    onErrorRef.current = onError;
     const defaultMaterial = react.useMemo(() => {
         return new THREE__namespace.MeshBasicMaterial({
             color: 0xffffff,
@@ -86,29 +91,42 @@ const Text$1 = react.forwardRef(function Text(props, ref) {
                 setError(null);
                 if (cancelled)
                     return;
-                const text = await index.Text.create({
-                    text: children,
-                    font,
-                    ...memoizedTextOptions
+                const textPromise = opRef.current.catch(() => null).then(() => {
+                    if (cancelled)
+                        return null;
+                    return textRef.current
+                        ? textRef.current.update({
+                            text: children,
+                            font,
+                            ...memoizedTextOptions
+                        })
+                        : index.Text.create({
+                            text: children,
+                            font,
+                            ...memoizedTextOptions
+                        });
                 });
+                opRef.current = textPromise.catch(() => null);
+                const text = await textPromise;
+                if (!text)
+                    return;
                 if (cancelled) {
-                    // If a newer render superseded this request, avoid leaking geometry
-                    text.geometry.dispose();
+                    text.dispose();
                     return;
                 }
-                // Dispose previous geometry (if any) before swapping
-                geometryRef.current?.dispose();
-                geometryRef.current = text.geometry;
+                const prev = textRef.current;
+                textRef.current = text;
                 setGeometry(text.geometry);
-                if (onLoad)
-                    onLoad(text.geometry, text);
+                if (onLoadRef.current)
+                    onLoadRef.current(text.geometry, text);
+                requestAnimationFrame(() => prev?.dispose());
             }
             catch (err) {
                 const error = err;
                 if (!cancelled) {
                     setError(error);
-                    if (onError)
-                        onError(error);
+                    if (onErrorRef.current)
+                        onErrorRef.current(error);
                     else
                         console.error('ThreeText error:', error);
                 }
@@ -118,12 +136,12 @@ const Text$1 = react.forwardRef(function Text(props, ref) {
         return () => {
             cancelled = true;
         };
-    }, [font, children, memoizedTextOptions, onLoad, onError]);
+    }, [font, children, memoizedTextOptions]);
     // Cleanup geometry on unmount
     react.useEffect(() => {
         return () => {
-            geometryRef.current?.dispose();
-            geometryRef.current = null;
+            textRef.current?.dispose();
+            textRef.current = null;
         };
     }, []);
     // Cleanup default material when it changes or on unmount

package/dist/three/react.d.ts

@@ -208,6 +208,8 @@ interface TextOptions {
     geometryOptimization?: GeometryOptimizationOptions;
     layout?: LayoutOptions;
     color?: [number, number, number] | ColorOptions;
+    /** Enable rotated RGSS-4 adaptive supersampling (4 samples per pixel). Takes effect when the GLSL rendering path is active. */
+    adaptiveSupersampling?: boolean;
 }
 interface HyphenationPatternsMap {
     [language: string]: HyphenationTrieNode;
@@ -255,6 +257,8 @@ 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;
@@ -263,6 +267,7 @@ declare class Text$1 {
     private fontLoader;
     private loadedFont?;
     private currentFontId;
+    private currentFontCacheKey?;
     private textShaper?;
     private textLayout?;
     private constructor();
@@ -270,6 +275,8 @@ declare class Text$1 {
     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;
@@ -277,6 +284,7 @@ declare class Text$1 {
     private static enforceFontCacheMemoryLimit;
     private static generateFontContentHash;
     private setLoadedFont;
+    private releaseCurrentFont;
     private loadFont;
     private createLayout;
     private prepareHyphenation;

package/dist/three/react.js

@@ -48,7 +48,12 @@ 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);
-    const geometryRef = useRef(null);
+    const textRef = useRef(null);
+    const opRef = useRef(Promise.resolve(null));
+    const onLoadRef = useRef(onLoad);
+    const onErrorRef = useRef(onError);
+    onLoadRef.current = onLoad;
+    onErrorRef.current = onError;
     const defaultMaterial = useMemo(() => {
         return new THREE.MeshBasicMaterial({
             color: 0xffffff,
@@ -65,29 +70,42 @@ const Text$1 = forwardRef(function Text(props, ref) {
                 setError(null);
                 if (cancelled)
                     return;
-                const text = await Text$2.create({
-                    text: children,
-                    font,
-                    ...memoizedTextOptions
+                const textPromise = opRef.current.catch(() => null).then(() => {
+                    if (cancelled)
+                        return null;
+                    return textRef.current
+                        ? textRef.current.update({
+                            text: children,
+                            font,
+                            ...memoizedTextOptions
+                        })
+                        : Text$2.create({
+                            text: children,
+                            font,
+                            ...memoizedTextOptions
+                        });
                 });
+                opRef.current = textPromise.catch(() => null);
+                const text = await textPromise;
+                if (!text)
+                    return;
                 if (cancelled) {
-                    // If a newer render superseded this request, avoid leaking geometry
-                    text.geometry.dispose();
+                    text.dispose();
                     return;
                 }
-                // Dispose previous geometry (if any) before swapping
-                geometryRef.current?.dispose();
-                geometryRef.current = text.geometry;
+                const prev = textRef.current;
+                textRef.current = text;
                 setGeometry(text.geometry);
-                if (onLoad)
-                    onLoad(text.geometry, text);
+                if (onLoadRef.current)
+                    onLoadRef.current(text.geometry, text);
+                requestAnimationFrame(() => prev?.dispose());
             }
             catch (err) {
                 const error = err;
                 if (!cancelled) {
                     setError(error);
-                    if (onError)
-                        onError(error);
+                    if (onErrorRef.current)
+                        onErrorRef.current(error);
                     else
                         console.error('ThreeText error:', error);
                 }
@@ -97,12 +115,12 @@ const Text$1 = forwardRef(function Text(props, ref) {
         return () => {
             cancelled = true;
         };
-    }, [font, children, memoizedTextOptions, onLoad, onError]);
+    }, [font, children, memoizedTextOptions]);
     // Cleanup geometry on unmount
     useEffect(() => {
         return () => {
-            geometryRef.current?.dispose();
-            geometryRef.current = null;
+            textRef.current?.dispose();
+            textRef.current = null;
         };
     }, []);
     // Cleanup default material when it changes or on unmount

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

@@ -10,6 +10,8 @@ export declare class Text {
     private static patternCache;
     private static hbInitPromise;
     private static fontCache;
+    private static fontLoadPromises;
+    private static fontRefCounts;
     private static fontCacheMemoryBytes;
     private static maxFontCacheMemoryBytes;
     private static fontIdCounter;
@@ -18,6 +20,7 @@ export declare class Text {
     private fontLoader;
     private loadedFont?;
     private currentFontId;
+    private currentFontCacheKey?;
     private textShaper?;
     private textLayout?;
     private constructor();
@@ -25,6 +28,8 @@ export declare class Text {
     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;
@@ -32,6 +37,7 @@ export declare class Text {
     private static enforceFontCacheMemoryLimit;
     private static generateFontContentHash;
     private setLoadedFont;
+    private releaseCurrentFont;
     private loadFont;
     private createLayout;
     private prepareHyphenation;

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

@@ -294,39 +294,6 @@ export interface VectorGlyphInfo extends GlyphGeometryInfo {
     segmentStart: number;
     segmentCount: number;
 }
-export interface PackedFloatTexture {
-    width: number;
-    height: number;
-    data: Float32Array;
-}
-export interface VectorTextGeometryInfo {
-    quadVertices: Float32Array;
-    quadIndices: Uint16Array;
-    instances: {
-        position: Float32Array;
-        bounds: Float32Array;
-        segmentRange: Uint32Array;
-        glyphDataIndex: Uint32Array;
-        glyphIndex: Uint32Array;
-        textIndex: Uint32Array;
-        lineIndex: Uint32Array;
-    };
-    segmentTexelsPerSegment: number;
-    segments: PackedFloatTexture;
-    segmentBounds?: PackedFloatTexture;
-    bandCount?: number;
-    bandRanges?: PackedFloatTexture;
-    bandIndices?: PackedFloatTexture;
-    xBandCount?: number;
-    xBandRanges?: PackedFloatTexture;
-    xBandIndices?: PackedFloatTexture;
-    tileCountX?: number;
-    tileCountY?: number;
-    tileRanges?: PackedFloatTexture;
-    tileIndices?: PackedFloatTexture;
-    glyphs: VectorGlyphInfo[];
-    planeBounds: BoundingBox;
-}
 export interface TextLayoutData {
     lines: LineInfo[];
     scaledLineHeight: number;
@@ -403,6 +370,8 @@ export interface TextOptions {
     geometryOptimization?: GeometryOptimizationOptions;
     layout?: LayoutOptions;
     color?: [number, number, number] | ColorOptions;
+    /** Enable rotated RGSS-4 adaptive supersampling (4 samples per pixel). Takes effect when the GLSL rendering path is active. */
+    adaptiveSupersampling?: boolean;
 }
 export interface HyphenationPatternsMap {
     [language: string]: HyphenationTrieNode;

package/dist/types/three/index.d.ts

@@ -9,6 +9,7 @@ export interface ThreeTextGeometryInfo extends Omit<CoreTextGeometryInfo, 'verti
     clearCache(): void;
     measureTextWidth(text: string, letterSpacing?: number): number;
     update(options: Partial<TextOptions>): Promise<ThreeTextGeometryInfo>;
+    dispose(): void;
 }
 export declare class Text {
     static setHarfBuzzPath: typeof TextCore.setHarfBuzzPath;

package/dist/types/vector/core/index.d.ts

@@ -0,0 +1,28 @@
+import { Text as TextCore } from '../../core/Text';
+import type { TextOptions, VectorGlyphInfo, LoadedFont, TextQueryOptions, TextRange } from '../../core/types';
+import type { BoundingBox } from '../../utils/vectors';
+import type { SlugGPUData } from '../slug/types';
+import type { HyphenationTrieNode } from '../../hyphenation';
+export interface VectorTextResult {
+    gpuData: SlugGPUData;
+    glyphs: VectorGlyphInfo[];
+    planeBounds: BoundingBox;
+    query(options: TextQueryOptions): TextRange[];
+    getLoadedFont(): LoadedFont | undefined;
+    measureTextWidth(text: string, letterSpacing?: number): number;
+    update(options: Partial<TextOptions>): Promise<VectorTextResult>;
+    dispose(): void;
+}
+export declare class Text {
+    static setHarfBuzzPath: typeof TextCore.setHarfBuzzPath;
+    static setHarfBuzzBuffer: typeof TextCore.setHarfBuzzBuffer;
+    static init: typeof TextCore.init;
+    static registerPattern: typeof TextCore.registerPattern;
+    static preloadPatterns: typeof TextCore.preloadPatterns;
+    static setMaxFontCacheMemoryMB: typeof TextCore.setMaxFontCacheMemoryMB;
+    static enableWoff2: typeof TextCore.enableWoff2;
+    static create(options: TextOptions): Promise<VectorTextResult>;
+}
+export type { TextOptions, VectorTextResult as TextGeometryInfo, VectorGlyphInfo, LoadedFont };
+export type { HyphenationTrieNode };
+export type { SlugGPUData } from '../slug/types';

package/dist/types/vector/index.d.ts

@@ -1,10 +1,14 @@
-import { Text as TextCore } from '../core/Text';
 import type { TextOptions, VectorGlyphInfo, LoadedFont, TextQueryOptions, TextRange } from '../core/types';
-import type { VectorGeometryData } from './LoopBlinnGeometry';
+import type { BoundingBox } from '../utils/vectors';
+import type { SlugGPUData } from './slug/types';
 import type { HyphenationTrieNode } from '../hyphenation';
+import * as THREE from 'three';
 export interface VectorTextResult {
+    group: THREE.Group;
+    mesh: THREE.Mesh;
+    gpuData: SlugGPUData;
     glyphs: VectorGlyphInfo[];
-    geometryData: VectorGeometryData;
+    planeBounds: BoundingBox;
     query(options: TextQueryOptions): TextRange[];
     getLoadedFont(): LoadedFont | undefined;
     measureTextWidth(text: string, letterSpacing?: number): number;
@@ -12,16 +16,17 @@ export interface VectorTextResult {
     dispose(): void;
 }
 export declare class Text {
-    static setHarfBuzzPath: typeof TextCore.setHarfBuzzPath;
-    static setHarfBuzzBuffer: typeof TextCore.setHarfBuzzBuffer;
-    static init: typeof TextCore.init;
-    static registerPattern: typeof TextCore.registerPattern;
-    static preloadPatterns: typeof TextCore.preloadPatterns;
-    static setMaxFontCacheMemoryMB: typeof TextCore.setMaxFontCacheMemoryMB;
-    static enableWoff2: typeof TextCore.enableWoff2;
+    static setHarfBuzzPath: typeof import("..").Text.setHarfBuzzPath;
+    static setHarfBuzzBuffer: typeof import("..").Text.setHarfBuzzBuffer;
+    static init: typeof import("..").Text.init;
+    static registerPattern: typeof import("..").Text.registerPattern;
+    static preloadPatterns: typeof import("..").Text.preloadPatterns;
+    static setMaxFontCacheMemoryMB: typeof import("..").Text.setMaxFontCacheMemoryMB;
+    static enableWoff2: typeof import("..").Text.enableWoff2;
     static create(options: TextOptions): Promise<VectorTextResult>;
 }
 export type { TextOptions, VectorTextResult as TextGeometryInfo, VectorGlyphInfo, LoadedFont };
 export type { HyphenationTrieNode };
-export { buildVectorGeometry, extractContours } from './LoopBlinnGeometry';
-export type { VectorGeometryData, VectorGlyphAttributes, GlyphRange, VectorContour, LoopBlinnInput, LoopBlinnGlyphInput, QuadraticSegment } from './LoopBlinnGeometry';
+export { createSlugGLSLMesh } from './slug/slugGLSL';
+export type { SlugGLSLMesh, SlugGLSLMeshOptions } from './slug/slugGLSL';
+export type { SlugGPUData } from './slug/types';

package/dist/types/vector/react.d.ts

@@ -1,7 +1,5 @@
 import * as THREE from 'three';
-import { Text as VectorTextCore } from './index';
-import type { VectorTextResult } from './index';
-import type { TextOptions } from '../core/types';
+import { Text as VectorText, type VectorTextResult, type TextOptions } from './index';
 export interface TextProps extends Omit<TextOptions, 'text' | 'color'> {
     children: string;
     font: string | ArrayBuffer;
@@ -9,6 +7,7 @@ export interface TextProps extends Omit<TextOptions, 'text' | 'color'> {
     position?: [number, number, number];
     rotation?: [number, number, number];
     scale?: [number, number, number];
+    positionNode?: any;
     onLoad?: (result: VectorTextResult) => void;
     onError?: (error: Error) => void;
 }
@@ -20,5 +19,5 @@ export declare const Text: import("react").ForwardRefExoticComponent<TextProps &
     preloadPatterns: typeof import("..").Text.preloadPatterns;
     setMaxFontCacheMemoryMB: typeof import("..").Text.setMaxFontCacheMemoryMB;
     enableWoff2: typeof import("..").Text.enableWoff2;
-    create: typeof VectorTextCore.create;
+    create: typeof VectorText.create;
 };

package/dist/types/vector/slug/SlugPacker.d.ts

@@ -0,0 +1,2 @@
+import type { SlugShape, SlugGPUData, SlugPackOptions } from './types';
+export declare function packSlugData(shapes: SlugShape[], options?: SlugPackOptions): SlugGPUData;

package/dist/types/vector/slug/curveUtils.d.ts

@@ -0,0 +1,6 @@
+import type { QuadCurve, SlugVec2 } from './types';
+export declare function lineToQuadratic(p0: SlugVec2, p1: SlugVec2): QuadCurve;
+export declare function cubicToQuadratics(p0: SlugVec2, p1: SlugVec2, p2: SlugVec2, p3: SlugVec2, options?: {
+    maxError?: number;
+    maxDepth?: number;
+}): QuadCurve[];

package/dist/types/vector/slug/index.d.ts

@@ -0,0 +1,8 @@
+export { packSlugData } from './SlugPacker';
+export { lineToQuadratic, cubicToQuadratics } from './curveUtils';
+export { unpackSlugVertices } from './unpackVertices';
+export { vertexShaderGLSL300, fragmentShaderGLSL300, vertexShaderWGSL, fragmentShaderWGSL } from './shaderStrings';
+export type { QuadCurve, SlugVec2, SlugShape, SlugPackedTexture, SlugGPUData, SlugPackOptions } from './types';
+export type { SlugVertexArrays } from './unpackVertices';
+export { createSlugTSLMesh } from './slugTSL';
+export type { SlugTSLMesh } from './slugTSL';

package/dist/types/vector/slug/shaderStrings.d.ts

@@ -0,0 +1,4 @@
+export declare const vertexShaderGLSL300: string;
+export declare const fragmentShaderGLSL300: string;
+export declare const vertexShaderWGSL: string;
+export declare const fragmentShaderWGSL: string;

package/dist/types/vector/slug/slugGLSL.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+import type { SlugGPUData } from './types';
+export interface SlugGLSLMeshOptions {
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    animationDeclarations?: string;
+    animationBody?: string;
+    uniforms?: Record<string, THREE.IUniform>;
+    adaptiveSupersampling?: boolean;
+}
+export 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;
+}
+export declare function createSlugGLSLMesh(gpuData: SlugGPUData, options?: SlugGLSLMeshOptions): SlugGLSLMesh;

package/dist/types/vector/slug/slugTSL.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+import type { SlugGPUData } from './types';
+export interface SlugTSLMesh {
+    mesh: THREE.Mesh;
+    setOffset(x: number, y: number, z?: number): void;
+    setColor(r: number, g: number, b: number): void;
+    dispose(): void;
+}
+export declare function createSlugTSLMesh(gpuData: SlugGPUData, color?: {
+    r: number;
+    g: number;
+    b: number;
+}): SlugTSLMesh;

package/dist/types/vector/slug/types.d.ts

@@ -0,0 +1,30 @@
+export interface QuadCurve {
+    p1: [number, number];
+    p2: [number, number];
+    p3: [number, number];
+}
+export type SlugVec2 = [number, number];
+export interface SlugShape {
+    curves: QuadCurve[];
+    bounds: [number, number, number, number];
+}
+export interface SlugPackedTexture {
+    data: Float32Array | Uint32Array;
+    width: number;
+    height: number;
+}
+export interface SlugGPUData {
+    curveTexture: SlugPackedTexture & {
+        data: Float32Array;
+    };
+    bandTexture: SlugPackedTexture & {
+        data: Uint32Array;
+    };
+    vertices: Float32Array;
+    indices: Uint16Array;
+    shapeCount: number;
+}
+export interface SlugPackOptions {
+    bandCount?: number;
+    evenOdd?: boolean;
+}

package/dist/types/vector/slug/unpackVertices.d.ts

@@ -0,0 +1,11 @@
+import type { SlugGPUData } from './types';
+export interface SlugVertexArrays {
+    positions: Float32Array;
+    texcoords: Float32Array;
+    bandings: Float32Array;
+    glyphData: Float32Array;
+    colors: Float32Array;
+    glyphCenters: Float32Array;
+    glyphIndices: Float32Array;
+}
+export declare function unpackSlugVertices(gpuData: SlugGPUData): SlugVertexArrays;

package/dist/types/vector/webgl/index.d.ts

@@ -1,7 +1,11 @@
-import type { VectorGeometryData } from '../LoopBlinnGeometry';
+import type { SlugGPUData } from '../slug/types';
 export interface WebGLVectorRenderer {
-    setGeometry(data: VectorGeometryData): void;
+    setGeometry(data: SlugGPUData): void;
     render(mvp: Float32Array, color: Float32Array): void;
     dispose(): void;
 }
-export declare function createWebGLVectorRenderer(gl: WebGL2RenderingContext): WebGLVectorRenderer;
+export interface WebGLVectorRendererOptions {
+    adaptiveSupersampling?: boolean;
+}
+export declare function createWebGLVectorRenderer(gl: WebGL2RenderingContext, options?: WebGLVectorRendererOptions): WebGLVectorRenderer;
+export type { SlugGPUData };

package/dist/types/vector/webgpu/index.d.ts

@@ -1,11 +1,11 @@
-import type { VectorGeometryData } from '../LoopBlinnGeometry';
+import type { SlugGPUData } from '../slug/types';
 export interface WebGPUVectorRenderer {
-    setGeometry(data: VectorGeometryData): void;
-    render(passEncoder: GPURenderPassEncoder, mvp: Float32Array, color: Float32Array): void;
+    setGeometry(data: SlugGPUData): void;
+    render(passEncoder: GPURenderPassEncoder, mvp: Float32Array, color: Float32Array, viewportWidth?: number, viewportHeight?: number): void;
     dispose(): void;
 }
 export interface WebGPUVectorRendererOptions {
-    depthStencilFormat?: GPUTextureFormat;
     sampleCount?: number;
 }
 export declare function createWebGPUVectorRenderer(device: GPUDevice, format: GPUTextureFormat, options?: WebGPUVectorRendererOptions): WebGPUVectorRenderer;
+export type { SlugGPUData };

package/dist/vector/all.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var index = require('./index.cjs');
+var loopBlinnTSL = require('./loopBlinnTSL.cjs');
+
+
+
+Object.defineProperty(exports, 'createVectorMeshes', {
+	enumerable: true,
+	get: function () { return loopBlinnTSL.createVectorMeshes; }
+});
+Object.defineProperty(exports, 'loopBlinnFragment', {
+	enumerable: true,
+	get: function () { return loopBlinnTSL.loopBlinnFragment; }
+});
+Object.keys(index).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return index[k]; }
+	});
+});