@codexo/exojs 0.6.10 → 0.6.11

package/dist/exo.esm.js

@@ -1,3 +1,448 @@
+const bounceOutFn = (t) => {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (t < 1 / d1) {
+        return n1 * t * t;
+    }
+    else if (t < 2 / d1) {
+        return n1 * (t -= 1.5 / d1) * t + 0.75;
+    }
+    else if (t < 2.5 / d1) {
+        return n1 * (t -= 2.25 / d1) * t + 0.9375;
+    }
+    else {
+        return n1 * (t -= 2.625 / d1) * t + 0.984375;
+    }
+};
+/**
+ * Standard Robert Penner easing functions as static methods.
+ * Each function accepts a normalized time `t` in [0, 1] and returns a value
+ * that equals 0 at t=0 and 1 at t=1 (overshoot functions like back/elastic
+ * may exceed that range between the endpoints).
+ *
+ * Usage: `Ease.cubicOut`, `Ease.bounceIn`, etc.
+ *
+ * Note: only scalar numeric properties are supported in v1. Vector, Color, and
+ * Matrix interpolation are out of scope.
+ */
+class Ease {
+    static linear = (t) => t;
+    static quadIn = (t) => t * t;
+    static quadOut = (t) => t * (2 - t);
+    static quadInOut = (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+    static cubicIn = (t) => t * t * t;
+    static cubicOut = (t) => (--t) * t * t + 1;
+    static cubicInOut = (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+    static quartIn = (t) => t * t * t * t;
+    static quartOut = (t) => 1 - (--t) * t * t * t;
+    static quartInOut = (t) => t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
+    static quintIn = (t) => t * t * t * t * t;
+    static quintOut = (t) => 1 + (--t) * t * t * t * t;
+    static quintInOut = (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 - Math.pow(-2 * t + 2, 5) / 2;
+    static sineIn = (t) => 1 - Math.cos((t * Math.PI) / 2);
+    static sineOut = (t) => Math.sin((t * Math.PI) / 2);
+    static sineInOut = (t) => -(Math.cos(Math.PI * t) - 1) / 2;
+    static expoIn = (t) => t === 0 ? 0 : Math.pow(2, 10 * t - 10);
+    static expoOut = (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t);
+    static expoInOut = (t) => {
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        return t < 0.5
+            ? Math.pow(2, 20 * t - 10) / 2
+            : (2 - Math.pow(2, -20 * t + 10)) / 2;
+    };
+    static circIn = (t) => 1 - Math.sqrt(1 - Math.pow(t, 2));
+    static circOut = (t) => Math.sqrt(1 - Math.pow(t - 1, 2));
+    static circInOut = (t) => t < 0.5
+        ? (1 - Math.sqrt(1 - Math.pow(2 * t, 2))) / 2
+        : (Math.sqrt(1 - Math.pow(-2 * t + 2, 2)) + 1) / 2;
+    static backIn = (t) => {
+        const c1 = 1.70158;
+        const c3 = c1 + 1;
+        return c3 * t * t * t - c1 * t * t;
+    };
+    static backOut = (t) => {
+        const c1 = 1.70158;
+        const c3 = c1 + 1;
+        return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+    };
+    static backInOut = (t) => {
+        const c1 = 1.70158;
+        const c2 = c1 * 1.525;
+        return t < 0.5
+            ? (Math.pow(2 * t, 2) * ((c2 + 1) * 2 * t - c2)) / 2
+            : (Math.pow(2 * t - 2, 2) * ((c2 + 1) * (2 * t - 2) + c2) + 2) / 2;
+    };
+    static bounceOut = bounceOutFn;
+    static bounceIn = (t) => 1 - bounceOutFn(1 - t);
+    static bounceInOut = (t) => t < 0.5
+        ? (1 - bounceOutFn(1 - 2 * t)) / 2
+        : (1 + bounceOutFn(2 * t - 1)) / 2;
+    static elasticIn = (t) => {
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        const c4 = (2 * Math.PI) / 3;
+        return -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * c4);
+    };
+    static elasticOut = (t) => {
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        const c4 = (2 * Math.PI) / 3;
+        return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c4) + 1;
+    };
+    static elasticInOut = (t) => {
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        const c5 = (2 * Math.PI) / 4.5;
+        return t < 0.5
+            ? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * c5)) / 2
+            : (Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * c5)) / 2 + 1;
+    };
+}
+
+var TweenState;
+(function (TweenState) {
+    TweenState["Idle"] = "idle";
+    TweenState["Active"] = "active";
+    TweenState["Paused"] = "paused";
+    TweenState["Complete"] = "complete";
+    TweenState["Stopped"] = "stopped";
+})(TweenState || (TweenState = {}));
+
+class Tween {
+    _target;
+    _state = TweenState.Idle;
+    _properties = {};
+    _startValues = null;
+    _duration = 0;
+    _delay = 0;
+    _easing = Ease.linear;
+    _elapsed = 0;
+    _delayElapsed = 0;
+    /**
+     * Remaining repeat cycles. -1 = infinite.
+     * At start this is set to _repeatTotal. Decremented on each cycle boundary.
+     */
+    _repeatCount = 0;
+    /** The value as configured by .repeat(). Preserved for reset. */
+    _repeatTotal = 0;
+    _yoyo = false;
+    /** Current playback direction: 1 = forward, -1 = reverse. */
+    _direction = 1;
+    _onStart = null;
+    _onUpdate = null;
+    _onComplete = null;
+    _onRepeat = null;
+    _chained = null;
+    _manager = null;
+    /** Whether onStart has already fired this tween lifecycle. */
+    _startFired = false;
+    constructor(target) {
+        this._target = target;
+    }
+    get target() {
+        return this._target;
+    }
+    get state() {
+        return this._state;
+    }
+    /**
+     * Current eased progress in 0..1. Reflects the eased t after applying the
+     * easing function, not the raw elapsed/duration ratio.
+     */
+    get progress() {
+        if (this._duration === 0)
+            return 1;
+        const rawT = Math.min(this._elapsed / this._duration, 1);
+        const t = this._direction === 1 ? rawT : 1 - rawT;
+        return this._easing(t);
+    }
+    /**
+     * Set target end-values and duration in seconds. Replaces any prior to().
+     * The starting values are captured lazily on first update() after start(),
+     * so mutating target between to() and start() is safe.
+     */
+    to(properties, duration) {
+        this._properties = { ...properties };
+        this._duration = duration;
+        this._startValues = null;
+        return this;
+    }
+    /** Delay in seconds before the tween begins interpolating. Default 0. */
+    delay(seconds) {
+        this._delay = seconds;
+        return this;
+    }
+    /** Easing function applied to the normalized time. Default Ease.linear. */
+    easing(fn) {
+        this._easing = fn;
+        return this;
+    }
+    /**
+     * Number of additional repeat cycles. -1 = infinite. Default 0 (runs once).
+     * Note: repeat(2) means the animation runs 3 times total.
+     */
+    repeat(count) {
+        this._repeatTotal = count;
+        return this;
+    }
+    /**
+     * Reverse playback direction on each repeat cycle. Only meaningful when
+     * combined with repeat(). Calling yoyo() without repeat() is a no-op.
+     */
+    yoyo(enabled = true) {
+        this._yoyo = enabled;
+        return this;
+    }
+    onStart(callback) {
+        this._onStart = callback;
+        return this;
+    }
+    onUpdate(callback) {
+        this._onUpdate = callback;
+        return this;
+    }
+    onComplete(callback) {
+        this._onComplete = callback;
+        return this;
+    }
+    onRepeat(callback) {
+        this._onRepeat = callback;
+        return this;
+    }
+    /**
+     * Start the tween. If a manager owns this tween it is already tracked;
+     * otherwise this is a stand-alone tween driven by manual update() calls.
+     */
+    start() {
+        this._state = TweenState.Active;
+        this._elapsed = 0;
+        this._delayElapsed = 0;
+        this._startValues = null;
+        this._startFired = false;
+        this._direction = 1;
+        this._repeatCount = this._repeatTotal;
+        return this;
+    }
+    /** Pause the tween. update() calls are ignored while paused. */
+    pause() {
+        if (this._state === TweenState.Active) {
+            this._state = TweenState.Paused;
+        }
+        return this;
+    }
+    /** Resume a paused tween from where it left off. */
+    resume() {
+        if (this._state === TweenState.Paused) {
+            this._state = TweenState.Active;
+        }
+        return this;
+    }
+    /**
+     * Stop the tween without finishing. Target properties stay at their
+     * current interpolated values. onComplete does NOT fire. The tween is
+     * removed from its manager if one is assigned.
+     */
+    stop() {
+        if (this._state === TweenState.Active || this._state === TweenState.Paused) {
+            this._state = TweenState.Stopped;
+            this._manager?.remove(this);
+        }
+        return this;
+    }
+    /**
+     * When this tween completes naturally, automatically start `next`.
+     * Returns `next` for fluent chaining:
+     *   `fadeIn.chain(moveOut).start()` — note that start() here starts moveOut,
+     *   so typically you only call start() on the first tween.
+     */
+    chain(next) {
+        this._chained = next;
+        return next;
+    }
+    /**
+     * Attach this tween to a manager. Called by TweenManager.create() and
+     * TweenManager.add(). Not part of the public fluent API.
+     * @internal
+     */
+    _attachManager(manager) {
+        this._manager = manager;
+    }
+    /**
+     * Advance the tween by deltaSeconds. Called by TweenManager each frame, or
+     * manually for stand-alone usage. No-ops when Paused, Stopped, or Complete.
+     */
+    update(deltaSeconds) {
+        if (this._state !== TweenState.Active)
+            return;
+        // Handle delay phase.
+        if (this._delayElapsed < this._delay) {
+            this._delayElapsed += deltaSeconds;
+            if (this._delayElapsed < this._delay)
+                return;
+            // Carry overflow past delay into elapsed.
+            const overflow = this._delayElapsed - this._delay;
+            this._delayElapsed = this._delay;
+            deltaSeconds = overflow;
+        }
+        // Lazy snapshot of start values on the first update after delay.
+        if (this._startValues === null) {
+            this._captureStartValues();
+        }
+        // Fire onStart once.
+        if (!this._startFired) {
+            this._startFired = true;
+            this._onStart?.();
+        }
+        this._elapsed += deltaSeconds;
+        // Clamp to duration for this cycle.
+        if (this._elapsed >= this._duration) {
+            this._elapsed = this._duration;
+        }
+        // Apply interpolation.
+        this._applyProgress();
+        if (this._elapsed >= this._duration) {
+            // Cycle complete.
+            const hasMoreRepeats = this._repeatCount === -1 || this._repeatCount > 0;
+            if (hasMoreRepeats) {
+                // Decrement repeat counter (skip for infinite).
+                if (this._repeatCount !== -1) {
+                    this._repeatCount--;
+                }
+                this._onRepeat?.();
+                // Flip direction for yoyo.
+                if (this._yoyo) {
+                    this._direction = this._direction === 1 ? -1 : 1;
+                }
+                // Reset elapsed for next cycle; carry overflow.
+                const overflow = this._elapsed - this._duration;
+                this._elapsed = overflow > 0 ? Math.min(overflow, this._duration) : 0;
+                this._startFired = false; // allow onStart to re-fire next cycle? No — spec says once.
+                // Actually spec says onStart fires when actual interpolation begins.
+                // For repeats it fires once total at the very first cycle.
+                // Re-reading spec: "onStart fires AFTER the delay (when actual interpolation begins)".
+                // We'll keep it as one-shot across the full lifecycle; don't reset _startFired.
+                this._startFired = true;
+                // Apply progress for any overflow.
+                if (overflow > 0) {
+                    this._applyProgress();
+                }
+            }
+            else {
+                // All cycles done.
+                this._complete();
+            }
+        }
+    }
+    _captureStartValues() {
+        const snap = {};
+        const keys = Object.keys(this._properties);
+        for (const key of keys) {
+            const val = this._target[key];
+            if (typeof val !== 'number') {
+                console.warn(`Tween: property "${String(key)}" is not a number on target ` +
+                    `(got ${typeof val}). It will be skipped.`);
+                continue;
+            }
+            snap[String(key)] = val;
+        }
+        this._startValues = snap;
+    }
+    _applyProgress() {
+        if (this._startValues === null)
+            return;
+        const rawT = this._duration === 0 ? 1 : Math.min(this._elapsed / this._duration, 1);
+        const t = this._direction === 1 ? rawT : 1 - rawT;
+        const easedT = this._easing(t);
+        const keys = Object.keys(this._startValues);
+        for (const key of keys) {
+            const start = this._startValues[key];
+            const end = this._properties[key];
+            this._target[key] = start + (end - start) * easedT;
+        }
+        this._onUpdate?.(easedT);
+    }
+    _complete() {
+        // Ensure the target is at its final interpolated position.
+        this._elapsed = this._duration;
+        this._applyProgress();
+        this._state = TweenState.Complete;
+        this._manager?.remove(this);
+        this._onComplete?.();
+        // Fire chained tween, if any.
+        this._chained?.start();
+    }
+}
+
+class TweenManager {
+    _tweens = [];
+    _destroyed = false;
+    /**
+     * Create a new Tween targeting `target`, register it with this manager, and
+     * return it. Call .to(...).start() on the result to begin animating.
+     */
+    create(target) {
+        const tween = new Tween(target);
+        tween._attachManager(this);
+        this._tweens.push(tween);
+        return tween;
+    }
+    /**
+     * Explicitly add a stand-alone Tween (created via `new Tween(target)`)
+     * to this manager so it participates in the update loop.
+     */
+    add(tween) {
+        tween._attachManager(this);
+        if (!this._tweens.includes(tween)) {
+            this._tweens.push(tween);
+        }
+        return this;
+    }
+    /** Remove a tween from the manager. Called automatically on stop/complete. */
+    remove(tween) {
+        const index = this._tweens.indexOf(tween);
+        if (index !== -1) {
+            this._tweens.splice(index, 1);
+        }
+        return this;
+    }
+    /**
+     * Advance all active tweens by deltaSeconds. Called once per frame by
+     * Application.update(). Uses a snapshot of the list so that callbacks that
+     * add or remove tweens do not corrupt mid-iteration.
+     */
+    update(deltaSeconds) {
+        if (this._destroyed)
+            return this;
+        const snapshot = this._tweens.slice();
+        for (const tween of snapshot) {
+            tween.update(deltaSeconds);
+        }
+        return this;
+    }
+    /**
+     * Remove all tweens immediately. No callbacks (onComplete etc.) fire.
+     * The tweens' states are left as-is; they are simply evicted from the list.
+     */
+    clear() {
+        this._tweens = [];
+        return this;
+    }
+    /** Tear down the manager. Clears tweens and makes subsequent updates no-ops. */
+    destroy() {
+        this.clear();
+        this._destroyed = true;
+    }
+}
+
 let temp$9 = null;
 class Size {
     _width;
@@ -14578,6 +15023,7 @@ class Application {
     loader;
     inputManager;
     sceneManager;
+    tweens = new TweenManager();
     onResize = new Signal();
     _updateHandler;
     _startupClock = new Clock();
@@ -14669,6 +15115,7 @@ class Application {
             const frameStart = performance.now();
             this.backend.resetStats();
             this.inputManager.update();
+            this.tweens.update(frameDelta.seconds);
             const runtimeView = this.backend.view;
             if (runtimeView && typeof runtimeView.update === 'function') {
                 runtimeView.update(frameDelta.milliseconds);
@@ -14704,6 +15151,7 @@ class Application {
         this.stop();
         this.loader.destroy();
         this.inputManager.destroy();
+        this.tweens.destroy();
         this._backend.destroy();
         this.sceneManager.destroy();
         this._startupClock.destroy();
@@ -18289,5 +18737,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, 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, 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, Ease, 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, Tween, TweenManager, TweenState, 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, stopEvent, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, tau, trimRotation, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
 //# sourceMappingURL=exo.esm.js.map