@codexo/exojs 0.6.8 → 0.6.9

package/dist/exo.esm.js

@@ -6211,19 +6211,6 @@ const createCanvas = (options = {}) => {
     context.fillRect(0, 0, newCanvas.width, newCanvas.height);
     return newCanvas;
 };
-const heightCache = new Map();
-const determineFontHeight = (font) => {
-    if (!heightCache.has(font)) {
-        const body = document.body;
-        const dummy = document.createElement('div');
-        dummy.appendChild(document.createTextNode('M'));
-        dummy.setAttribute('style', `font: ${font};position:absolute;top:0;left:0`);
-        body.appendChild(dummy);
-        heightCache.set(font, dummy.offsetHeight);
-        body.removeChild(dummy);
-    }
-    return heightCache.get(font);
-};
 
 class Texture {
     static _black = null;
@@ -17629,14 +17616,227 @@ class AnimatedSprite extends Sprite {
     }
 }
 
+const glyphPadding = 2;
+class ShelfPacker {
+    _shelves = [];
+    _width;
+    _height;
+    constructor(width, height) {
+        this._width = width;
+        this._height = height;
+    }
+    insert(width, height) {
+        // Try existing shelves in order (ascending y)
+        for (const shelf of this._shelves) {
+            if (shelf.height >= height && shelf.cursorX + width <= this._width) {
+                const x = shelf.cursorX;
+                shelf.cursorX += width;
+                return { x, y: shelf.y };
+            }
+        }
+        // Create a new shelf at the bottom
+        const last = this._shelves[this._shelves.length - 1];
+        const bottomY = last === undefined ? 0 : last.y + last.height;
+        if (bottomY + height > this._height) {
+            throw new Error(`GlyphAtlas full — clear() and re-render, or instantiate with larger dims`);
+        }
+        this._shelves.push({ y: bottomY, height, cursorX: width });
+        return { x: 0, y: bottomY };
+    }
+    reset() {
+        this._shelves.length = 0;
+    }
+}
+/**
+ * A shared atlas that rasterizes glyphs on demand into an offscreen canvas
+ * and wraps it as a Texture for use by the Mesh-based Text renderer.
+ *
+ * Glyphs are always rasterized in white so that runtime tinting via
+ * `Mesh.tint` applies the fill color without requiring re-rasterization.
+ *
+ * Use `getDefaultGlyphAtlas()` from `atlas-singleton.ts` rather than
+ * constructing directly.
+ */
+class DynamicGlyphAtlas {
+    texture;
+    _canvas;
+    _ctx;
+    _packer;
+    _cache = new Map();
+    _width;
+    _height;
+    constructor(width = 1024, height = 1024) {
+        this._width = width;
+        this._height = height;
+        // Use OffscreenCanvas when available, fall back to HTMLCanvasElement.
+        // In jsdom / Node the global may be absent; createCanvas falls through
+        // to document.createElement which jsdom provides.
+        const canvas = typeof OffscreenCanvas !== 'undefined'
+            ? new OffscreenCanvas(width, height)
+            : document.createElement('canvas');
+        if ('width' in canvas) {
+            canvas.width = width;
+            canvas.height = height;
+        }
+        this._canvas = canvas;
+        const ctx = canvas.getContext('2d');
+        if (ctx === null) {
+            throw new Error('DynamicGlyphAtlas: could not obtain a 2D context.');
+        }
+        this._ctx = ctx;
+        this._packer = new ShelfPacker(width, height);
+        this.texture = new Texture(canvas);
+        this.texture.setSize(width, height);
+    }
+    /**
+     * Returns the cached GlyphInfo for the given character + font parameters,
+     * rasterizing it into the atlas if not already present.
+     */
+    getGlyph(char, family, size, weight, style) {
+        const key = `${char}:${family}:${size}:${weight}:${style}`;
+        const cached = this._cache.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const info = this._rasterize(char, family, size, weight, style, key);
+        this._cache.set(key, info);
+        // Bump texture version so GPU backends re-upload the canvas data.
+        this.texture.updateSource();
+        return info;
+    }
+    /**
+     * Clears all cached glyphs and resets the atlas packer.
+     * The underlying canvas pixels are also cleared.
+     */
+    clear() {
+        this._cache.clear();
+        this._packer.reset();
+        this._ctx.clearRect(0, 0, this._width, this._height);
+        this.texture.updateSource();
+    }
+    // -----------------------------------------------------------------------
+    _rasterize(char, family, size, weight, fontStyle, _key) {
+        const ctx = this._ctx;
+        const padding = glyphPadding;
+        ctx.font = `${fontStyle} ${weight} ${size}px ${family}`;
+        ctx.textBaseline = 'alphabetic';
+        ctx.fillStyle = '#ffffff';
+        const metrics = ctx.measureText(char);
+        const ascent = Math.ceil(metrics.fontBoundingBoxAscent
+            ?? metrics.actualBoundingBoxAscent
+            ?? size * 0.8);
+        const descent = Math.ceil(metrics.fontBoundingBoxDescent
+            ?? metrics.actualBoundingBoxDescent
+            ?? size * 0.2);
+        const advance = metrics.width;
+        const glyphWidth = Math.max(1, Math.ceil((metrics.actualBoundingBoxLeft ?? 0) + (metrics.actualBoundingBoxRight ?? 0)) || Math.ceil(advance));
+        const glyphHeight = Math.max(1, ascent + descent);
+        const slotW = glyphWidth + padding * 2;
+        const slotH = glyphHeight + padding * 2;
+        const slot = this._packer.insert(slotW, slotH);
+        // Draw the glyph white into the atlas slot
+        ctx.fillText(char, slot.x + padding + (metrics.actualBoundingBoxLeft ?? 0), slot.y + padding + ascent);
+        const info = {
+            x: slot.x,
+            y: slot.y,
+            width: glyphWidth,
+            height: glyphHeight,
+            advance,
+            ascent,
+            uvLeft: slot.x / this._width,
+            uvTop: slot.y / this._height,
+            uvRight: (slot.x + slotW) / this._width,
+            uvBottom: (slot.y + slotH) / this._height,
+        };
+        return info;
+    }
+}
+
+let _defaultAtlas = null;
+/**
+ * Returns the shared process-wide glyph atlas, creating it lazily on first
+ * call.  All `Text` instances share this atlas so that identical glyph shapes
+ * (same char + family + size + weight + style) are rasterized only once.
+ */
+function getDefaultGlyphAtlas() {
+    if (_defaultAtlas === null) {
+        _defaultAtlas = new DynamicGlyphAtlas();
+    }
+    return _defaultAtlas;
+}
+
+/**
+ * Computes per-glyph quad placements for the given text and style.
+ *
+ * Handles `\n` line breaks and left/center/right alignment. No word-wrap,
+ * no RTL, no ligature shaping — Unicode/diacritics are delegated to the
+ * browser's font engine via canvas `fillText`.
+ *
+ * Returns an empty array for empty text.
+ */
+function layoutText(text, style, atlas) {
+    if (text.length === 0) {
+        return [];
+    }
+    const { fontSize, fontFamily, fontWeight, fontStyle, lineHeight, align } = style;
+    const computedLineHeight = fontSize * lineHeight;
+    const lines = text.split('\n');
+    // Pass 1: gather glyph info per line, track line widths
+    const linePlacements = [];
+    let maxLineWidth = 0;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        const y = lineIndex * computedLineHeight;
+        let cursorX = 0;
+        const placements = [];
+        for (const char of line) {
+            const info = atlas.getGlyph(char, fontFamily, fontSize, fontWeight, fontStyle);
+            placements.push({ info, x: cursorX, y });
+            cursorX += info.advance;
+        }
+        const lineWidth = cursorX;
+        if (lineWidth > maxLineWidth) {
+            maxLineWidth = lineWidth;
+        }
+        linePlacements.push({ placements, width: lineWidth });
+    }
+    // Pass 2: apply alignment and build final GlyphPlacement array
+    const result = [];
+    for (const line of linePlacements) {
+        let offsetX = 0;
+        if (align === 'right') {
+            offsetX = maxLineWidth - line.width;
+        }
+        else if (align === 'center') {
+            offsetX = (maxLineWidth - line.width) / 2;
+        }
+        for (const { info, x, y } of line.placements) {
+            result.push({
+                x: x + offsetX,
+                y,
+                width: info.width,
+                height: info.height,
+                uvLeft: info.uvLeft,
+                uvTop: info.uvTop,
+                uvRight: info.uvRight,
+                uvBottom: info.uvBottom,
+            });
+        }
+    }
+    return result;
+}
+
 class TextStyle {
     _align;
     _fill;
+    _fillColor;
+    _lineHeight;
     _stroke;
     _strokeThickness;
     _fontSize;
     _fontWeight;
     _fontFamily;
+    _fontStyle;
     _wordWrap;
     _wordWrapWidth;
     _baseline;
@@ -17647,11 +17847,14 @@ class TextStyle {
     constructor(options = {}) {
         this._align = options.align ?? 'left';
         this._fill = options.fill ?? 'black';
+        this._fillColor = options.fillColor ?? Color.white.clone();
+        this._lineHeight = options.lineHeight ?? 1.2;
         this._stroke = options.stroke ?? 'black';
         this._strokeThickness = options.strokeThickness ?? 1;
         this._fontSize = options.fontSize ?? 20;
         this._fontWeight = options.fontWeight ?? 'bold';
         this._fontFamily = options.fontFamily ?? 'Arial';
+        this._fontStyle = options.fontStyle ?? 'normal';
         this._wordWrap = options.wordWrap ?? false;
         this._wordWrapWidth = options.wordWrapWidth ?? 100;
         this._baseline = options.baseline ?? 'alphabetic';
@@ -17677,6 +17880,31 @@ class TextStyle {
             this._dirty = true;
         }
     }
+    /**
+     * Runtime fill color applied via `Mesh.tint`. Glyphs are always
+     * rasterized white; this color multiplies them at draw time so that
+     * changing the color never requires re-rasterizing cached glyphs.
+     */
+    get fillColor() {
+        return this._fillColor;
+    }
+    set fillColor(color) {
+        this._fillColor = color;
+        this._dirty = true;
+    }
+    /**
+     * Line-height multiplier applied to `fontSize` when computing vertical
+     * spacing between lines. Defaults to 1.2.
+     */
+    get lineHeight() {
+        return this._lineHeight;
+    }
+    set lineHeight(lineHeight) {
+        if (this._lineHeight !== lineHeight) {
+            this._lineHeight = lineHeight;
+            this._dirty = true;
+        }
+    }
     get stroke() {
         return this._stroke;
     }
@@ -17722,6 +17950,15 @@ class TextStyle {
             this._dirty = true;
         }
     }
+    get fontStyle() {
+        return this._fontStyle;
+    }
+    set fontStyle(fontStyle) {
+        if (this._fontStyle !== fontStyle) {
+            this._fontStyle = fontStyle;
+            this._dirty = true;
+        }
+    }
     get wordWrap() {
         return this._wordWrap;
     }
@@ -17799,11 +18036,14 @@ class TextStyle {
         if (style !== this) {
             this.align = style.align;
             this.fill = style.fill;
+            this._fillColor = style.fillColor.clone();
+            this.lineHeight = style.lineHeight;
             this.stroke = style.stroke;
             this.strokeThickness = style.strokeThickness;
             this.fontSize = style.fontSize;
             this.fontWeight = style.fontWeight;
             this.fontFamily = style.fontFamily;
+            this.fontStyle = style.fontStyle;
             this.wordWrap = style.wordWrap;
             this.wordWrapWidth = style.wordWrapWidth;
             this.baseline = style.baseline;
@@ -17819,26 +18059,81 @@ class TextStyle {
     }
 }
 
-const newLinePattern = /(?:\r\n|\r|\n)/;
-class Text extends Sprite {
+function buildMesh(placements, style) {
+    const n = placements.length;
+    const vertices = new Float32Array(n * 4 * 2);
+    const uvs = new Float32Array(n * 4 * 2);
+    const indices = new Uint16Array(n * 6);
+    for (let i = 0; i < n; i++) {
+        const p = placements[i];
+        const v = i * 8;
+        const u = i * 8;
+        const idx = i * 6;
+        const baseV = i * 4;
+        // Vertices: TL, TR, BR, BL
+        vertices[v + 0] = p.x;
+        vertices[v + 1] = p.y;
+        vertices[v + 2] = p.x + p.width;
+        vertices[v + 3] = p.y;
+        vertices[v + 4] = p.x + p.width;
+        vertices[v + 5] = p.y + p.height;
+        vertices[v + 6] = p.x;
+        vertices[v + 7] = p.y + p.height;
+        // UVs: TL, TR, BR, BL
+        uvs[u + 0] = p.uvLeft;
+        uvs[u + 1] = p.uvTop;
+        uvs[u + 2] = p.uvRight;
+        uvs[u + 3] = p.uvTop;
+        uvs[u + 4] = p.uvRight;
+        uvs[u + 5] = p.uvBottom;
+        uvs[u + 6] = p.uvLeft;
+        uvs[u + 7] = p.uvBottom;
+        // Indices: [TL, TR, BR, TL, BR, BL]
+        indices[idx + 0] = baseV + 0;
+        indices[idx + 1] = baseV + 1;
+        indices[idx + 2] = baseV + 2;
+        indices[idx + 3] = baseV + 0;
+        indices[idx + 4] = baseV + 2;
+        indices[idx + 5] = baseV + 3;
+    }
+    const atlas = getDefaultGlyphAtlas();
+    const mesh = new Mesh({
+        vertices,
+        uvs,
+        indices,
+        texture: atlas.texture,
+    });
+    mesh.tint = style.fillColor;
+    return mesh;
+}
+/**
+ * GPU-accelerated text node that rasterizes individual glyphs into a shared
+ * atlas ({@link DynamicGlyphAtlas}) and renders them as a single quad-per-
+ * glyph {@link Mesh} (one draw call per Text instance).
+ *
+ * Glyphs are always rasterized in white and tinted at runtime via
+ * `Mesh.tint`; changing `style.fillColor` only updates the mesh tint —
+ * no atlas re-rasterization is needed.
+ *
+ * The internal {@link Mesh} is the sole child of this {@link Container}.
+ * All transform properties (position, rotation, scale, origin) are
+ * inherited from {@link Container} → {@link RenderNode}.
+ */
+class Text extends Container {
     _text;
     _style;
-    _canvas;
-    _context;
-    _dirty = true;
-    constructor(text, style, samplerOptions, canvas = document.createElement('canvas')) {
-        super(new Texture(canvas, samplerOptions));
+    _mesh = null;
+    constructor(text, style) {
+        super();
         this._text = text;
         this._style = (style && style instanceof TextStyle) ? style : new TextStyle(style);
-        this._canvas = canvas;
-        this._context = canvas.getContext('2d');
-        this.updateTexture();
+        this._rebuild();
     }
     get text() {
         return this._text;
     }
-    set text(text) {
-        this.setText(text);
+    set text(value) {
+        this.setText(value);
     }
     get style() {
         return this._style;
@@ -17846,98 +18141,43 @@ class Text extends Sprite {
     set style(style) {
         this.setStyle(style);
     }
-    get canvas() {
-        return this._canvas;
-    }
-    set canvas(canvas) {
-        this.setCanvas(canvas);
-    }
     setText(text) {
         if (this._text !== text) {
             this._text = text;
-            this._dirty = true;
+            this._rebuild();
         }
         return this;
     }
     setStyle(style) {
         this._style = (style instanceof TextStyle) ? style : new TextStyle(style);
-        this._dirty = true;
-        return this;
-    }
-    setCanvas(canvas) {
-        if (this._canvas !== canvas) {
-            this._canvas = canvas;
-            this._context = this._getContext(canvas);
-            this._dirty = true;
-            this.texture.setSource.call(this.texture, canvas);
-            this.setTextureFrame(Rectangle.temp.set(0, 0, canvas.width, canvas.height));
-        }
+        this._rebuild();
         return this;
     }
-    updateTexture() {
-        if (this._style && (this._dirty || this._style.dirty)) {
-            const canvas = this._canvas, context = this._context, style = this._style.apply(context), text = style.wordWrap ? this.getWordWrappedText() : this._text, lineHeight = determineFontHeight(context.font) + style.strokeThickness, lines = text.split(newLinePattern), lineMetrics = lines.map((line) => context.measureText(line)), maxLineWidth = lineMetrics.reduce((max, measure) => Math.max(max, measure.width), 0), canvasWidth = Math.ceil((maxLineWidth + style.strokeThickness) + (style.padding * 2)), canvasHeight = Math.ceil((lineHeight * lines.length) + (style.padding * 2));
-            if (canvasWidth !== canvas.width || canvasHeight !== canvas.height) {
-                canvas.width = canvasWidth;
-                canvas.height = canvasHeight;
-                this.setTextureFrame(Rectangle.temp.set(0, 0, canvasWidth, canvasHeight));
-            }
-            else {
-                context.clearRect(0, 0, canvasWidth, canvasHeight);
-            }
-            style.apply(context);
-            for (let i = 0; i < lines.length; i++) {
-                const metrics = lineMetrics[i], lineWidth = (maxLineWidth - metrics.width), offset = (style.align === 'right') ? lineWidth : lineWidth / 2, padding = style.padding + (style.strokeThickness / 2), lineX = metrics.actualBoundingBoxLeft + (style.align === 'left' ? 0 : offset) + padding, lineY = metrics.actualBoundingBoxAscent + (lineHeight * i) + padding;
-                if (style.stroke && style.strokeThickness) {
-                    context.strokeText(lines[i], lineX, lineY);
-                }
-                if (style.fill) {
-                    context.fillText(lines[i], lineX, lineY);
-                }
-            }
-            this.texture.updateSource();
-            this._dirty = false;
-            this._style.dirty = false;
-        }
-        return this;
-    }
-    getWordWrappedText() {
-        const context = this._context, wrapWidth = this._style.wordWrapWidth, lines = this._text.split('\n'), spaceWidth = context.measureText(' ').width;
-        let spaceLeft = wrapWidth, result = '';
-        for (let y = 0; y < lines.length; y++) {
-            const words = lines[y].split(' ');
-            if (y > 0) {
-                result += '\n';
-            }
-            for (let x = 0; x < words.length; x++) {
-                const word = words[x], wordWidth = context.measureText(word).width, pairWidth = wordWidth + spaceWidth;
-                if (pairWidth > spaceLeft) {
-                    if (x > 0) {
-                        result += '\n';
-                    }
-                    spaceLeft = wrapWidth;
-                }
-                else {
-                    spaceLeft -= pairWidth;
-                }
-                result += `${word} `;
-            }
+    destroy() {
+        if (this._mesh !== null) {
+            this._mesh.destroy();
+            this._mesh = null;
         }
-        return result;
+        super.destroy();
     }
-    render(backend) {
-        if (this.visible) {
-            this.updateTexture();
-            super.render(backend);
+    // -----------------------------------------------------------------------
+    _rebuild() {
+        // Remove and discard the old mesh (if any).
+        if (this._mesh !== null) {
+            this.removeChild(this._mesh);
+            this._mesh.destroy();
+            this._mesh = null;
+        }
+        if (this._text.length === 0) {
+            return;
         }
-        return this;
-    }
-    _getContext(canvas) {
-        const context = canvas.getContext('2d');
-        if (context === null) {
-            throw new Error('Could not create a 2D canvas context.');
+        const atlas = getDefaultGlyphAtlas();
+        const placements = layoutText(this._text, this._style, atlas);
+        if (placements.length === 0) {
+            return;
         }
-        return context;
+        this._mesh = buildMesh(placements, this._style);
+        this.addChild(this._mesh);
     }
 }
 
@@ -18519,5 +18759,5 @@ class IndexedDbStore {
     }
 }
 
-export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign$1 as sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
+export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, Container, Drawable, DynamicGlyphAtlas, Ellipse, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, Graphics, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, Particle, ParticleOptions, ParticleSystem, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuSpriteRenderer, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, layoutText, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, normalizeIds, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign$1 as sign, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
 //# sourceMappingURL=exo.esm.js.map