meshwriter-cudu 3.0.0

package/dist/src/babylonImports.d.ts

@@ -0,0 +1,11 @@
+export { Color3 } from "@babylonjs/core/Maths/math.color";
+export { Mesh } from "@babylonjs/core/Meshes/mesh";
+export { VertexData } from "@babylonjs/core/Meshes/mesh.vertexData";
+export { PolygonMeshBuilder } from "@babylonjs/core/Meshes/polygonMesh";
+export { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial";
+export { MaterialPluginBase } from "@babylonjs/core/Materials/materialPluginBase";
+export { SolidParticleSystem } from "@babylonjs/core/Particles/solidParticleSystem";
+export { CSG } from "@babylonjs/core/Meshes/csg";
+export { Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector";
+export { Path2, Curve3 } from "@babylonjs/core/Maths/math.path";
+export { CSG2, InitializeCSG2Async, IsCSG2Ready } from "@babylonjs/core/Meshes/csg2";

package/dist/src/bakedFontLoader.d.ts

@@ -0,0 +1,43 @@
+/**
+ * MeshWriter Baked Font Loader
+ * Loads pre-baked FontSpec JSON files at runtime.
+ * Zero dependencies - just fetch and use.
+ */
+/**
+ * Load a pre-baked font from a JSON file
+ * @param {string} url - URL to the baked FontSpec JSON file
+ * @returns {Promise<object>} - FontSpec object ready for use with MeshWriter
+ *
+ * @example
+ * const fontSpec = await loadBakedFont('/fonts/baked/atkinson-hyperlegible-next-400.json');
+ * registerFont('Atkinson400', fontSpec);
+ */
+export function loadBakedFont(url: string): Promise<object>;
+/**
+ * Load multiple pre-baked weights from a manifest
+ * @param {string} manifestUrl - URL to the manifest.json file
+ * @param {number[]} [weights] - Specific weights to load (loads all if omitted)
+ * @returns {Promise<Map<number, object>>} - Map of weight -> FontSpec
+ *
+ * @example
+ * const fonts = await loadBakedFontsFromManifest('/fonts/baked/manifest.json', [400, 450]);
+ * const fontSpec = fonts.get(400);
+ */
+export function loadBakedFontsFromManifest(manifestUrl: string, weights?: number[]): Promise<Map<number, object>>;
+/**
+ * Find the nearest available weight from a set of baked weights
+ * @param {number} targetWeight - Desired weight
+ * @param {number[]} availableWeights - Array of available weights
+ * @returns {number} - Nearest available weight
+ *
+ * @example
+ * const nearest = findNearestWeight(425, [400, 450, 500]);
+ * // Returns 450 (closest to 425)
+ */
+export function findNearestWeight(targetWeight: number, availableWeights: number[]): number;
+/**
+ * Get manifest info without loading fonts
+ * @param {string} manifestUrl - URL to the manifest.json file
+ * @returns {Promise<object>} - Manifest object with fontName, weights, etc.
+ */
+export function getBakedFontManifest(manifestUrl: string): Promise<object>;

package/dist/src/colorContrast.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Color Contrast Utilities for WCAG Compliance
+ * Provides color manipulation for dyslexia accessibility
+ */
+/**
+ * Convert hex color string to RGB object (0-1 range)
+ * @param {string} hex - Hex color string (e.g., "#FF0000" or "FF0000")
+ * @returns {{r: number, g: number, b: number}}
+ */
+export function hexToRgb(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * Convert RGB object (0-1 range) to hex color string
+ * @param {{r: number, g: number, b: number}} rgb
+ * @returns {string}
+ */
+export function rgbToHex(rgb: {
+    r: number;
+    g: number;
+    b: number;
+}): string;
+/**
+ * Convert RGB to HSL
+ * @param {number} r - Red (0-1)
+ * @param {number} g - Green (0-1)
+ * @param {number} b - Blue (0-1)
+ * @returns {{h: number, s: number, l: number}} - h in degrees (0-360), s and l in 0-1
+ */
+export function rgbToHsl(r: number, g: number, b: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+/**
+ * Convert HSL to RGB
+ * @param {number} h - Hue in degrees (0-360)
+ * @param {number} s - Saturation (0-1)
+ * @param {number} l - Lightness (0-1)
+ * @returns {{r: number, g: number, b: number}}
+ */
+export function hslToRgb(h: number, s: number, l: number): {
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * Calculate relative luminance per WCAG 2.1
+ * @param {number} r - Red (0-1)
+ * @param {number} g - Green (0-1)
+ * @param {number} b - Blue (0-1)
+ * @returns {number} - Relative luminance (0-1)
+ */
+export function relativeLuminance(r: number, g: number, b: number): number;
+/**
+ * Calculate WCAG contrast ratio between two luminance values
+ * @param {number} L1 - Luminance of first color (0-1)
+ * @param {number} L2 - Luminance of second color (0-1)
+ * @returns {number} - Contrast ratio (1-21)
+ */
+export function contrastRatio(L1: number, L2: number): number;
+/**
+ * Auto-derive edge colors (diffuse/ambient) from emissive color
+ * Creates high-contrast edges for text legibility
+ *
+ * INVERTED APPROACH: Since emissive adds to all surfaces equally,
+ * we flip the strategy - put bright color in diffuse (shows on lit surfaces)
+ * and dark color in emissive (base for unlit surfaces).
+ * Returns modified emissive along with diffuse/ambient.
+ *
+ * @param {string} emissiveHex - Hex color string for desired face color
+ * @param {number} [targetContrast=4.5] - Target WCAG contrast ratio
+ * @returns {{diffuse: string, ambient: string, emissive: string}}
+ */
+export function deriveEdgeColors(emissiveHex: string, targetContrast?: number): {
+    diffuse: string;
+    ambient: string;
+    emissive: string;
+};
+/**
+ * Adjust colors to achieve WCAG contrast while preserving user intent
+ * Priority: prefer edge modifications over face modifications
+ *
+ * @param {object} colors - User-provided colors
+ * @param {string} colors.emissive - Face color (hex)
+ * @param {string} colors.diffuse - Edge lit color (hex)
+ * @param {string} [colors.ambient] - Edge shadow color (hex)
+ * @param {object} [options]
+ * @param {number} [options.targetContrast=4.5] - Target contrast ratio
+ * @param {number} [options.edgeRange=0.4] - Max edge modification (0-1)
+ * @param {number} [options.faceRange=0.1] - Max face modification (0-1)
+ * @param {boolean} [options.allowHueShift=true] - Allow hue modifications
+ * @returns {{emissive: string, diffuse: string, ambient: string, achieved: number}}
+ */
+export function adjustForContrast(colors: {
+    emissive: string;
+    diffuse: string;
+    ambient?: string;
+}, options?: {
+    targetContrast?: number;
+    edgeRange?: number;
+    faceRange?: number;
+    allowHueShift?: boolean;
+}): {
+    emissive: string;
+    diffuse: string;
+    ambient: string;
+    achieved: number;
+};
+export namespace CONTRAST_LEVELS {
+    let AA_NORMAL: number;
+    let AA_LARGE: number;
+    let AAA_NORMAL: number;
+    let AAA_LARGE: number;
+}

package/dist/src/csg.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Initialize CSG module with Babylon.js CSG classes
+ * Must be called before using any CSG functionality
+ * @param {Object} babylon - Object containing CSG, CSG2, InitializeCSG2Async, IsCSG2Ready
+ */
+export function initCSGModule(babylon: any): void;
+/**
+ * Detect which CSG implementation is available
+ * @returns {'CSG2'|'CSG'|null}
+ */
+export function detectCSGVersion(): "CSG2" | "CSG" | null;
+/**
+ * Mark CSG as ready and notify all listeners
+ */
+export function markCSGInitialized(): void;
+/**
+ * Check if CSG is ready for use
+ * @returns {boolean}
+ */
+export function isCSGReady(): boolean;
+/**
+ * Initialize CSG2 asynchronously
+ * @returns {Promise<void>}
+ */
+export function initializeCSG2(): Promise<void>;
+/**
+ * Get the current CSG version being used
+ * @returns {'CSG2'|'CSG'|null}
+ */
+export function getCSGVersion(): "CSG2" | "CSG" | null;
+/**
+ * Set an external CSG2 initializer function
+ * @param {Function} fn - Async function that initializes CSG2
+ */
+export function setCSGInitializer(fn: Function): void;
+/**
+ * Set an external CSG2 ready check function
+ * @param {Function} fn - Function that returns true when CSG2 is ready
+ */
+export function setCSGReadyCheck(fn: Function): void;
+/**
+ * Register a callback to be called when CSG is ready
+ * If CSG is already ready, callback is called immediately
+ * @param {Function} listener
+ */
+export function onCSGReady(listener: Function): void;
+/**
+ * Get the CSG library to use for operations
+ * @returns {Object} - CSG or CSG2 class
+ */
+export function getCSGLib(): any;
+export let CSG: typeof BabylonCSG;
+export let CSG2: typeof BabylonCSG2;
+import { CSG as BabylonCSG } from './babylonImports.js';
+import { CSG2 as BabylonCSG2 } from './babylonImports.js';

package/dist/src/curves.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Install optimized curve methods on Path2 prototype
+ * Must be called after Babylon.js is loaded
+ */
+export function installCurveExtensions(): void;
+/**
+ * Extended Path2 interface with MeshWriter curve methods
+ * @typedef {Object} Path2Extensions
+ * @property {(redX: number, redY: number, blueX: number, blueY: number) => Path2} addQuadraticCurveTo
+ * @property {(redX: number, redY: number, greenX: number, greenY: number, blueX: number, blueY: number) => Path2} addCubicCurveTo
+ */
+export const curveSampleSize: 6;
+/**
+ * Extended Path2 interface with MeshWriter curve methods
+ */
+export type Path2Extensions = {
+    addQuadraticCurveTo: (redX: number, redY: number, blueX: number, blueY: number) => Path2;
+    addCubicCurveTo: (redX: number, redY: number, greenX: number, greenY: number, blueX: number, blueY: number) => Path2;
+};
+import { Path2 } from './babylonImports.js';

package/dist/src/fogPlugin.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Plugin that applies scene fog to text materials by modifying
+ * the final fragment color before output.
+ */
+export class TextFogPlugin extends MaterialPluginBase {
+    /**
+     * @param {import('@babylonjs/core/Materials/material').Material} material
+     */
+    constructor(material: import("@babylonjs/core/Materials/material").Material);
+    /**
+     * Set the define based on whether scene fog is enabled
+     * @param {object} defines
+     * @param {import('@babylonjs/core/scene').Scene} scene
+     * @param {import('@babylonjs/core/Meshes/mesh').Mesh} mesh
+     */
+    prepareDefines(defines: object, scene: import("@babylonjs/core/scene").Scene, mesh: import("@babylonjs/core/Meshes/mesh").Mesh): void;
+    getUniforms(): {
+        ubo: any[];
+    };
+    /**
+     * Clean up the plugin
+     */
+    dispose(): void;
+    /**
+     * Inject shader code to apply fog to emissive color
+     * @param {string} shaderType - 'vertex' or 'fragment'
+     */
+    getCustomCode(shaderType: string): {
+        CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: string;
+    };
+}
+import { MaterialPluginBase } from './babylonImports.js';

package/dist/src/fontCompression.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Decode a compressed command list string
+ * @param {string} str - Compressed string (space-separated encoded commands)
+ * @returns {Array} - Array of decoded command arrays
+ */
+export function decodeList(str: string): any[];
+/**
+ * Encode a command list to compressed string
+ * @param {Array} list - Array of command arrays
+ * @returns {string} - Compressed string
+ */
+export function codeList(list: any[]): string;

package/dist/src/fontRegistry.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Register a font for use with MeshWriter
+ * @param {string} name - Font name (case-sensitive, used in "font-family" option)
+ * @param {Function|Object} fontData - Font factory function or pre-initialized font object
+ *
+ * @example
+ * // Register a font factory (receives codeList for encoding)
+ * import helvetica from 'meshwriter/fonts/helvetica';
+ * registerFont('Helvetica', helvetica);
+ *
+ * // Register with aliases
+ * registerFont('Arial', helvetica);
+ * registerFont('sans-serif', helvetica);
+ */
+export function registerFont(name: string, fontData: Function | any): void;
+/**
+ * Register multiple font aliases pointing to the same font
+ * @param {string} targetName - Name of already-registered font
+ * @param {...string} aliases - Alias names to register
+ *
+ * @example
+ * registerFont('Helvetica', helveticaData);
+ * registerFontAliases('Helvetica', 'Arial', 'sans-serif');
+ */
+export function registerFontAliases(targetName: string, ...aliases: string[]): void;
+/**
+ * Get a registered font by name
+ * @param {string} name - Font name
+ * @returns {Object|undefined} - Font object or undefined if not found
+ */
+export function getFont(name: string): any | undefined;
+/**
+ * Check if a font is registered
+ * @param {string} name - Font name
+ * @returns {boolean}
+ */
+export function isFontRegistered(name: string): boolean;
+/**
+ * Get list of all registered font names
+ * @returns {string[]}
+ */
+export function getRegisteredFonts(): string[];
+/**
+ * Unregister a font (mainly for testing)
+ * @param {string} name - Font name to remove
+ */
+export function unregisterFont(name: string): void;
+/**
+ * Clear all registered fonts (mainly for testing)
+ */
+export function clearFonts(): void;
+import { codeList } from './fontCompression.js';
+import { decodeList } from './fontCompression.js';
+export { codeList, decodeList };

package/dist/src/index.d.ts

@@ -0,0 +1,47 @@
+export { TextFogPlugin } from "./fogPlugin.js";
+export namespace MeshWriter {
+    export { createMeshWriterAsync as createAsync };
+    export { createMeshWriter as create };
+    export { isCSGReady as isReady };
+    export { getCSGVersion };
+    export { setCSGInitializer };
+    export { setCSGReadyCheck };
+    export { onCSGReady };
+    export { markCSGReady };
+    export { initCSGModule };
+    export { registerFont };
+    export { registerFontAliases };
+    export { getFont };
+    export { isFontRegistered };
+    export { codeList };
+    export { decodeList };
+    export { loadBakedFont };
+    export { loadBakedFontsFromManifest };
+    export { findNearestWeight };
+    export { getBakedFontManifest };
+}
+export default MeshWriter;
+import { createMeshWriterAsync } from './meshwriter.js';
+import { createMeshWriter } from './meshwriter.js';
+import { isCSGReady } from './meshwriter.js';
+import { getCSGVersion } from './meshwriter.js';
+import { setCSGInitializer } from './meshwriter.js';
+import { setCSGReadyCheck } from './meshwriter.js';
+import { onCSGReady } from './meshwriter.js';
+import { markCSGReady } from './meshwriter.js';
+import { initCSGModule } from './meshwriter.js';
+import { registerFont } from './fontRegistry.js';
+import { registerFontAliases } from './fontRegistry.js';
+import { getFont } from './fontRegistry.js';
+import { isFontRegistered } from './fontRegistry.js';
+import { codeList } from './fontCompression.js';
+import { decodeList } from './fontCompression.js';
+import { loadBakedFont } from './bakedFontLoader.js';
+import { loadBakedFontsFromManifest } from './bakedFontLoader.js';
+import { findNearestWeight } from './bakedFontLoader.js';
+import { getBakedFontManifest } from './bakedFontLoader.js';
+export { createMeshWriter, createMeshWriterAsync, isCSGReady, getCSGVersion, setCSGInitializer, setCSGReadyCheck, onCSGReady, markCSGReady, initCSGModule } from "./meshwriter.js";
+export { registerFont, registerFontAliases, getFont, isFontRegistered, getRegisteredFonts, unregisterFont, clearFonts, codeList, decodeList } from "./fontRegistry.js";
+export { loadBakedFont, loadBakedFontsFromManifest, findNearestWeight, getBakedFontManifest } from "./bakedFontLoader.js";
+export { codeList as encodeFontData, decodeList as decodeFontData } from "./fontCompression.js";
+export { deriveEdgeColors, adjustForContrast, relativeLuminance, contrastRatio, hexToRgb, rgbToHex, rgbToHsl, hslToRgb, CONTRAST_LEVELS } from "./colorContrast.js";

package/dist/src/letterMesh.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @typedef {Object} LetterPolygonsResult
+ * @property {number} xWidth - Total width of all letters
+ * @property {number} count - Number of valid letter meshes
+ */
+/**
+ * @typedef {(any[] & LetterPolygonsResult) & { faceMeshes: Mesh[] }} LetterPolygonsCollection
+ */
+/**
+ * Construct meshes for all letters in a string
+ * @param {string} letters - Text string
+ * @param {Object} fontSpec - Font specification
+ * @param {number} xOffset - X offset
+ * @param {number} yOffset - Y offset (unused, kept for API compatibility)
+ * @param {number} zOffset - Z offset
+ * @param {number} letterScale - Scale factor for letters
+ * @param {number} thickness - Letter thickness (depth)
+ * @param {Material} material - Material (unused in this function)
+ * @param {string} meshOrigin - "letterCenter" or "fontOrigin"
+ * @param {Scene} scene - Babylon scene
+ * @param {Object} [spacingOpts] - Optional spacing options
+ * @param {number} [spacingOpts.letterSpacing=0] - Extra spacing between letters (world units, added after kerning)
+ * @param {number} [spacingOpts.wordSpacing=0] - Extra spacing for spaces (world units, added to space width)
+ * @returns {any[] & LetterPolygonsResult} - [meshes, boxes, origins] with xWidth and count properties
+ */
+export function constructLetterPolygons(letters: string, fontSpec: any, xOffset: number, yOffset: number, zOffset: number, letterScale: number, thickness: number, material: Material, meshOrigin: string, scene: Scene, spacingOpts?: {
+    letterSpacing?: number;
+    wordSpacing?: number;
+}): any[] & LetterPolygonsResult;
+export type LetterPolygonsResult = {
+    /**
+     * - Total width of all letters
+     */
+    xWidth: number;
+    /**
+     * - Number of valid letter meshes
+     */
+    count: number;
+};
+export type LetterPolygonsCollection = (any[] & LetterPolygonsResult) & {
+    faceMeshes: Mesh[];
+};
+export type Scene = import("@babylonjs/core/scene").Scene;
+export type Material = import("@babylonjs/core/Materials/material").Material;
+export const naturalLetterHeight: 1000;
+import { Mesh } from './babylonImports.js';

package/dist/src/material.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Convert hex color string to Babylon Color3
+ * @param {string} rgb - Hex color string (e.g., "#FF0000" or "FF0000")
+ * @returns {Color3}
+ */
+export function rgb2Color3(rgb: string): Color3;
+/**
+ * Create a StandardMaterial for text
+ * @param {Scene} scene - Babylon scene
+ * @param {string} letters - Text string (used for material naming)
+ * @param {string} emissive - Hex color for emissive
+ * @param {string} ambient - Hex color for ambient
+ * @param {string} specular - Hex color for specular
+ * @param {string} diffuse - Hex color for diffuse
+ * @param {number} opac - Opacity (0-1)
+ * @param {boolean} [emissiveOnly=false] - If true, disables lighting (only emissive color shows)
+ * @param {boolean} [fogEnabled=true] - If true, the material is affected by scene fog
+ * @returns {StandardMaterial}
+ */
+export function makeMaterial(scene: Scene, letters: string, emissive: string, ambient: string, specular: string, diffuse: string, opac: number, emissiveOnly?: boolean, fogEnabled?: boolean): StandardMaterial;
+/**
+ * Create a dedicated emissive material for front faces.
+ * This keeps the face self-lit while still respecting fog settings.
+ * @param {Scene} scene
+ * @param {string} letters
+ * @param {string} emissive
+ * @param {number} opac
+ * @param {boolean} fogEnabled
+ * @returns {StandardMaterial}
+ */
+export function makeFaceMaterial(scene: Scene, letters: string, emissive: string, opac: number, fogEnabled?: boolean): StandardMaterial;
+export type Scene = import("@babylonjs/core/scene").Scene;
+import { Color3 } from './babylonImports.js';
+import { StandardMaterial } from './babylonImports.js';

package/dist/src/meshSplitter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Split a mesh into two meshes: emissive face geometry and lit rim geometry.
+ * @param {import('@babylonjs/core').Mesh} mesh
+ * @param {import('@babylonjs/core').Scene} scene
+ * @returns {{ rimMesh: import('@babylonjs/core').Mesh, faceMesh: import('@babylonjs/core').Mesh | null }}
+ */
+export function splitMeshByFaceNormals(mesh: import("@babylonjs/core").Mesh, scene: import("@babylonjs/core").Scene): {
+    rimMesh: import("@babylonjs/core").Mesh;
+    faceMesh: import("@babylonjs/core").Mesh | null;
+};

package/dist/src/meshwriter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Create a MeshWriter factory configured for a scene
+ * @param {Scene} scene - Babylon.js scene
+ * @param {MeshWriterPreferences} [preferences={}] - Configuration options
+ * @returns {Function} - MeshWriter constructor
+ */
+export function createMeshWriter(scene: Scene, preferences?: MeshWriterPreferences): Function;
+/**
+ * Async factory for Babylon 8+ with CSG2
+ * Handles CSG2 initialization automatically
+ * @param {Scene} scene - Babylon.js scene
+ * @param {MeshWriterPreferences} [preferences={}] - Configuration options
+ * @returns {Promise<Function>} - MeshWriter constructor
+ */
+export function createMeshWriterAsync(scene: Scene, preferences?: MeshWriterPreferences): Promise<Function>;
+export type Scene = import("@babylonjs/core/scene").Scene;
+export type MeshWriterPreferences = {
+    /**
+     * - Default font family
+     */
+    defaultFont?: string;
+    /**
+     * - Scale factor
+     */
+    scale?: number;
+    /**
+     * - "letterCenter" or "fontOrigin"
+     */
+    meshOrigin?: string;
+    /**
+     * - Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * - Babylon.js namespace object with CSG classes (for ES module builds)
+     */
+    babylon?: any;
+};
+import { isCSGReady } from './csg.js';
+import { getCSGVersion } from './csg.js';
+import { setCSGInitializer } from './csg.js';
+import { setCSGReadyCheck } from './csg.js';
+import { onCSGReady } from './csg.js';
+import { markCSGInitialized } from './csg.js';
+import { initCSGModule } from './csg.js';
+export { isCSGReady, getCSGVersion, setCSGInitializer, setCSGReadyCheck, onCSGReady, markCSGInitialized as markCSGReady, initCSGModule };

package/dist/src/sps.d.ts

@@ -0,0 +1,27 @@
+/** @typedef {import('@babylonjs/core/scene').Scene} Scene */
+/** @typedef {import('@babylonjs/core/Materials/material').Material} Material */
+/** @typedef {import('@babylonjs/core/Meshes/mesh').Mesh} BabylonMesh */
+/** @typedef {(any[] & { faceMeshes?: BabylonMesh[] })} MeshCollection */
+/**
+ * @typedef {[SolidParticleSystem | undefined, BabylonMesh | undefined] & {
+ *   face: [SolidParticleSystem | undefined, BabylonMesh | undefined];
+ * }} SPSCombo
+ */
+/**
+ * Create an SPS from letter meshes
+ * @param {Scene} scene - Babylon scene
+ * @param {MeshCollection} meshesAndBoxes - [meshes, boxes, origins] with optional face geometry
+ * @param {Material} material - Material to apply to SPS mesh
+ * @returns {SPSCombo} - Combined SPS + emissive face SPS
+ */
+export function makeSPS(scene: Scene, meshesAndBoxes: MeshCollection, material: Material): SPSCombo;
+export type Scene = import("@babylonjs/core/scene").Scene;
+export type Material = import("@babylonjs/core/Materials/material").Material;
+export type BabylonMesh = import("@babylonjs/core/Meshes/mesh").Mesh;
+export type MeshCollection = (any[] & {
+    faceMeshes?: BabylonMesh[];
+});
+export type SPSCombo = [SolidParticleSystem | undefined, BabylonMesh | undefined] & {
+    face: [SolidParticleSystem | undefined, BabylonMesh | undefined];
+};
+import { SolidParticleSystem } from './babylonImports.js';

package/dist/src/umd-entry.d.ts

@@ -0,0 +1,3 @@
+export default factory;
+/** @type {any} */
+declare const factory: any;

package/dist/src/utils.d.ts

@@ -0,0 +1,12 @@
+export function isPositiveNumber(mn: any): boolean;
+export function isNumber(mn: any): mn is number;
+export function isBoolean(mn: any): mn is boolean;
+export function isAmplitude(ma: any): boolean;
+export function isObject(mo: any): boolean;
+export function isPromiseLike(mo: any): boolean;
+export function isArray(ma: any): boolean;
+export function isString(ms: any): boolean;
+export function isRelativeLength(l: any): boolean;
+export function round(n: any): number;
+export function weeid(): number;
+export function setOption(opts: any, field: any, tst: any, defalt: any): any;

package/dist/src/variableFontCache.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Create a cache key for a glyph at a specific weight
+ * @param {number} weight - Font weight value
+ * @param {string} char - Character
+ * @returns {string} - Cache key
+ */
+export function createGlyphCacheKey(weight: number, char: string): string;
+/**
+ * MeshWriter Variable Font Cache
+ * LRU cache for variable font glyphs to prevent memory bloat
+ */
+/**
+ * LRU Cache for glyph specifications
+ * Prevents memory bloat when using many weight variations
+ */
+export class GlyphCache {
+    /**
+     * Create a new glyph cache
+     * @param {number} [maxSize=5000] - Maximum number of cached entries
+     */
+    constructor(maxSize?: number);
+    _maxSize: number;
+    _cache: Map<any, any>;
+    /**
+     * Get a cached value (moves it to most recently used)
+     * @param {string} key - Cache key
+     * @returns {*} - Cached value or undefined
+     */
+    get(key: string): any;
+    /**
+     * Set a cache value (evicts oldest if at capacity)
+     * @param {string} key - Cache key
+     * @param {*} value - Value to cache
+     */
+    set(key: string, value: any): void;
+    /**
+     * Check if key exists in cache
+     * @param {string} key - Cache key
+     * @returns {boolean}
+     */
+    has(key: string): boolean;
+    /**
+     * Clear all cached entries
+     */
+    clear(): void;
+    /**
+     * Get current cache size
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * Get maximum cache size
+     * @returns {number}
+     */
+    get maxSize(): number;
+}

package/dist/src/variableFontConverter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * MeshWriter Variable Font Converter
+ * Converts fontkit glyph paths to MeshWriter FontSpec format at runtime
+ */
+/**
+ * Convert fontkit glyph to MeshWriter GlyphSpec
+ * @param {object} glyph - fontkit glyph object
+ * @param {number} [scale=1] - Scale factor
+ * @returns {object|null} - GlyphSpec with shapeCmds/holeCmds, or null if empty
+ */
+export function convertFontkitGlyphToSpec(glyph: object, scale?: number): object | null;
+/**
+ * Extract kerning pairs from fontkit font for given character set
+ * @param {object} font - fontkit font object
+ * @param {string} charset - Characters to extract kerning for
+ * @param {number} [scale=1] - Scale factor
+ * @returns {object} - Kerning table mapping "char1,char2" to adjustment value
+ */
+export function extractFontkitKerningPairs(font: object, charset: string, scale?: number): object;
+export function convertGlyphToSpec(glyph: any, scale?: number): any;
+export function extractKerningPairs(font: any, charset: any, scale?: number): any;