@codexo/exojs 0.6.7 → 0.6.8

package/CHANGELOG.md

@@ -4,6 +4,57 @@ All notable changes to ExoJS are documented in this file.
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.8] - 2026-05-02
+
+> **Heads-up — breaking change despite the patch number.** Removes
+> the optional Rapier physics integration in its entirety. Pre-1.0
+> SemVer permits breaking changes within the 0.x.y line; we kept
+> the minor digit unchanged because the integration was opt-in and
+> usage outside the engine is presumed minimal.
+
+### Removed
+
+- **`createRapierPhysicsWorld` factory and the `RapierPhysicsWorld`
+  / `RapierPhysicsBinding` classes.** Plus the entire associated
+  type surface (`PhysicsBodyOptions`, `PhysicsBodyType`,
+  `PhysicsBoxShape`, `PhysicsCircleShape`, `PhysicsColliderShape`,
+  `PhysicsCollisionFilter`, `PhysicsSyncMode`, `RapierModuleLoader`,
+  `RapierPhysicsDebugDrawOptions`, `RapierPhysicsEvent`,
+  `RapierPhysicsWorldOptions`).
+- **`@dimforge/rapier2d-compat` peerDependency.** Removed from
+  `package.json` along with the `peerDependenciesMeta` entry that
+  marked it optional.
+- **README's "Optional Rapier Physics" section** and the
+  feature-list bullets that mentioned it.
+- **`src/physics/`** and **`test/physics/`** directories deleted.
+
+### Migration
+
+Apps that depended on `createRapierPhysicsWorld` need to integrate
+Rapier (or any other physics library) directly in their own code
+without library involvement. The adapter was always intentionally
+narrow — it bound Rapier bodies to scene nodes from the outside,
+no rendering / application / core scene code referenced physics.
+Removing it is therefore mechanical for downstream consumers:
+
+```ts
+// Before (≤ 0.6.7)
+import { createRapierPhysicsWorld } from '@codexo/exojs';
+const physics = await createRapierPhysicsWorld({ gravityY: 9.81 });
+
+// After (0.6.8+) — pull Rapier directly:
+import RAPIER from '@dimforge/rapier2d-compat';
+await RAPIER.init();
+const physics = new RAPIER.World({ x: 0, y: 9.81 });
+// Sync bodies to your scene-node positions in your app's update loop.
+```
+
+The motivation: ExoJS doesn't want to be a thin wrapper around
+Rapier's API, and keeping the integration around tied the library
+to a specific physics library forever. Removing it cleans the
+boundary — ExoJS is rendering + scene + input; physics is the
+user's choice.
+
 ## [0.6.7] - 2026-05-02
 
 Touch / multi-touch / pointer support, fully unified — no separate

package/README.md

@@ -14,7 +14,6 @@ ExoJS is **pre-1.0**. The public API is still under active design — scene grap
 - Practical visuals: filters, masks, render passes, cache-as-bitmap
 - Gameplay tools: animated sprites, scene stacking, camera helpers, audio sprites
 - Performance visibility with built-in render stats and benchmark harness
-- Optional Rapier physics integration without forcing physics on every app
 
 ## What Is Shipped Today
 
@@ -25,7 +24,6 @@ ExoJS is **pre-1.0**. The public API is still under active design — scene grap
 - View/camera helpers (`follow`, bounds clamp, shake, zoom)
 - Rendering composition primitives (`RenderTexture`, `RenderTargetPass`, filter chains, visual masks, cache-as-bitmap)
 - Render stats (`submittedNodes`, `culledNodes`, `drawCalls`, `batches`, `renderPasses`, ...)
-- Optional Rapier adapter (`createRapierPhysicsWorld`)
 
 ## Installation
 
@@ -98,40 +96,6 @@ new Application({ backend: { type: 'webgl2' } });
 new Application({ backend: { type: 'auto' } });
 ```
 
-## Optional Rapier Physics
-
-Rapier integration is opt-in and loaded only when you use it.
-
-```ts
-import { createRapierPhysicsWorld } from '@codexo/exojs';
-
-const physics = await createRapierPhysicsWorld({ gravityY: 9.81 });
-```
-
-If Rapier is unavailable, creation fails with a clear setup error.
-
-### Physics scope policy
-
-ExoJS ships **one** physics adapter: Rapier. The integration is intentionally
-narrow:
-
-- Physics is **optional**. `@dimforge/rapier2d-compat` is a peer dependency
-  marked `optional`. Apps that do not call `createRapierPhysicsWorld` never
-  load it and never pay for it at runtime.
-- Rendering, application, and core scene code **do not** depend on physics.
-  The adapter binds Rapier bodies to scene nodes from the outside; the core
-  has no knowledge of physics.
-- ExoJS is **not** a physics-engine abstraction layer. There is no
-  `PhysicsWorld` interface that spans multiple backends, and no plan to
-  add one. If you need a different physics library, integrate it directly
-  in your app code without library involvement.
-- A second physics adapter (Box2D, Matter.js, Planck, etc.) is **not** on
-  the 1.0 roadmap and will not be accepted as a contribution. The honesty
-  rule that applies to rendering backends applies here too: one chosen
-  physics, not a fake-universal physics layer.
-
-For full integration details see [docs/physics/rapier-integration.md](docs/physics/rapier-integration.md).
-
 ## Examples
 
 The runnable live site (Astro + Lit + Monaco preview) lives in [`examples/`](examples/README.md) and is deployed as the repository's GitHub Pages site at <https://exoridus.github.io/ExoJS/>.

package/dist/esm/index.d.ts

@@ -5,4 +5,3 @@ export * from './math/index';
 export * from './particles/index';
 export * from './rendering/index';
 export * from './resources/index';
-export * from './physics/index';

package/dist/esm/index.js

@@ -129,5 +129,4 @@ export { VideoFactory } from './resources/factories/VideoFactory.js';
 export { BinaryFactory } from './resources/factories/BinaryFactory.js';
 export { VttFactory } from './resources/factories/VttFactory.js';
 export { WasmFactory } from './resources/factories/WasmFactory.js';
-export { RapierPhysicsBinding, RapierPhysicsWorld, createRapierPhysicsWorld } from './physics/RapierPhysicsWorld.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/exo.esm.js

@@ -18519,474 +18519,5 @@ class IndexedDbStore {
     }
 }
 
-const rapierModuleName = '@dimforge/rapier2d-compat';
-const maxCollisionGroup = 15;
-const fullGroupMask = 0xFFFF;
-const defaultDeltaSeconds = 1 / 60;
-const defaultDebugDrawOptions = {
-    lineWidth: 1,
-    solidLineColor: new Color(64, 196, 255, 1),
-    solidFillColor: new Color(64, 196, 255, 0.12),
-    triggerLineColor: new Color(255, 180, 48, 1),
-    triggerFillColor: new Color(255, 180, 48, 0.08),
-};
-const resolveRapierModule = (module) => {
-    const rapier = module;
-    const vector2 = rapier.Vector2;
-    const worldConstructor = rapier.World;
-    const eventQueueConstructor = rapier.EventQueue;
-    const rigidBodyDescFactory = rapier.RigidBodyDesc;
-    const colliderDescFactory = rapier.ColliderDesc;
-    if (typeof vector2 !== 'function' || typeof worldConstructor !== 'function' || typeof eventQueueConstructor !== 'function') {
-        throw new Error('Invalid Rapier module loader result. Expected Vector2, World, and EventQueue exports.');
-    }
-    if (typeof rigidBodyDescFactory !== 'object'
-        || rigidBodyDescFactory === null
-        || typeof colliderDescFactory !== 'object'
-        || colliderDescFactory === null) {
-        throw new Error('Invalid Rapier module loader result. Expected RigidBodyDesc and ColliderDesc exports.');
-    }
-    const activeEvents = rapier.ActiveEvents;
-    const activeCollisionEvents = typeof activeEvents?.COLLISION_EVENTS === 'number'
-        ? activeEvents.COLLISION_EVENTS
-        : undefined;
-    return {
-        init: typeof rapier.init === 'function'
-            ? rapier.init
-            : undefined,
-        vector2: vector2,
-        worldConstructor: worldConstructor,
-        eventQueueConstructor: eventQueueConstructor,
-        rigidBodyDescFactory: rigidBodyDescFactory,
-        colliderDescFactory: colliderDescFactory,
-        activeCollisionEvents,
-    };
-};
-const defaultRapierModuleLoader = async () => {
-    return await import(rapierModuleName);
-};
-const assertFiniteNumber = (value, label) => {
-    if (!Number.isFinite(value)) {
-        throw new Error(`${label} must be a finite number.`);
-    }
-};
-const assertPositiveNumber = (value, label) => {
-    assertFiniteNumber(value, label);
-    if (value <= 0) {
-        throw new Error(`${label} must be greater than zero.`);
-    }
-};
-const assertGroup = (group, label) => {
-    if (!Number.isInteger(group) || group < 0 || group > maxCollisionGroup) {
-        throw new Error(`${label} must be an integer between 0 and ${maxCollisionGroup}.`);
-    }
-};
-const toGroupMask = (groups, fallback) => {
-    if (groups === undefined) {
-        return fallback;
-    }
-    if (typeof groups === 'number') {
-        assertGroup(groups, 'collision group');
-        return 1 << groups;
-    }
-    if (groups.length === 0) {
-        return 0;
-    }
-    return groups.reduce((mask, group, index) => {
-        assertGroup(group, `collision groups[${index}]`);
-        return mask | (1 << group);
-    }, 0);
-};
-const toPackedCollisionGroups = (filter) => {
-    const membershipMask = toGroupMask(filter?.membership, 1 << 0);
-    const collisionMask = toGroupMask(filter?.collidesWith, fullGroupMask);
-    return ((membershipMask & fullGroupMask) << 16) | (collisionMask & fullGroupMask);
-};
-const getOffset = (shape) => ({
-    x: shape.offsetX ?? 0,
-    y: shape.offsetY ?? 0,
-});
-const rotatePoint = (x, y, rotation) => {
-    const cos = Math.cos(rotation);
-    const sin = Math.sin(rotation);
-    return {
-        x: (x * cos) - (y * sin),
-        y: (x * sin) + (y * cos),
-    };
-};
-const assertShape = (shape) => {
-    if (shape.type === 'box') {
-        assertPositiveNumber(shape.width, 'Box width');
-        assertPositiveNumber(shape.height, 'Box height');
-        assertFiniteNumber(shape.offsetX ?? 0, 'Box offsetX');
-        assertFiniteNumber(shape.offsetY ?? 0, 'Box offsetY');
-        assertFiniteNumber(shape.offsetRotation ?? 0, 'Box offsetRotation');
-        return;
-    }
-    assertPositiveNumber(shape.radius, 'Circle radius');
-    assertFiniteNumber(shape.offsetX ?? 0, 'Circle offsetX');
-    assertFiniteNumber(shape.offsetY ?? 0, 'Circle offsetY');
-};
-const assertBodyOptions = (options) => {
-    assertShape(options.shape);
-    assertFiniteNumber(options.friction ?? 0, 'friction');
-    assertFiniteNumber(options.restitution ?? 0, 'restitution');
-    assertFiniteNumber(options.density ?? 0, 'density');
-    assertFiniteNumber(options.gravityScale ?? 1, 'gravityScale');
-    assertFiniteNumber(options.linearDamping ?? 0, 'linearDamping');
-    assertFiniteNumber(options.angularDamping ?? 0, 'angularDamping');
-    toPackedCollisionGroups(options.collisionFilter);
-};
-class RapierPhysicsBinding {
-    _world;
-    _body;
-    _collider;
-    _syncMode;
-    node;
-    bodyType;
-    shape;
-    trigger;
-    constructor(world, node, body, collider, options) {
-        this._world = world;
-        this.node = node;
-        this._body = body;
-        this._collider = collider;
-        this.bodyType = options.type ?? 'dynamic';
-        this.shape = options.shape;
-        this.trigger = options.trigger ?? false;
-        this._syncMode = options.syncMode ?? 'physicsToNode';
-    }
-    get bodyHandle() {
-        return this._body.handle;
-    }
-    get colliderHandle() {
-        return this._collider.handle;
-    }
-    getBody() {
-        return this._body;
-    }
-    get syncMode() {
-        return this._syncMode;
-    }
-    set syncMode(syncMode) {
-        this._syncMode = syncMode;
-    }
-    get x() {
-        return this._body.translation().x;
-    }
-    get y() {
-        return this._body.translation().y;
-    }
-    get rotation() {
-        return this._body.rotation();
-    }
-    setSyncMode(syncMode) {
-        this._syncMode = syncMode;
-        return this;
-    }
-    teleport(x, y, rotation = this.node.rotation) {
-        this._world.writeBodyTransform(this._body, x, y, rotation, true);
-        this.node.setPosition(x, y);
-        this.node.setRotation(rotation);
-        return this;
-    }
-    syncBodyFromNode(wakeUp = true) {
-        this._world.writeBodyTransform(this._body, this.node.x, this.node.y, this.node.rotation, wakeUp);
-        return this;
-    }
-    syncNodeFromBody() {
-        const translation = this._body.translation();
-        this.node.setPosition(translation.x, translation.y);
-        this.node.setRotation(this._body.rotation());
-        return this;
-    }
-    setCollisionFilter(filter) {
-        const groups = toPackedCollisionGroups(filter);
-        this._collider.setCollisionGroups(groups);
-        this._collider.setSolverGroups(groups);
-        return this;
-    }
-    destroy() {
-        this._world.removeBinding(this);
-    }
-}
-class RapierPhysicsWorld {
-    onCollisionEnter = new Signal();
-    onCollisionExit = new Signal();
-    onTriggerEnter = new Signal();
-    onTriggerExit = new Signal();
-    _rapier;
-    _world;
-    _eventQueue;
-    _bindings = new Set();
-    _nodeBindings = new Map();
-    _colliderBindings = new Map();
-    constructor(rapier, world, eventQueue) {
-        this._rapier = rapier;
-        this._world = world;
-        this._eventQueue = eventQueue;
-    }
-    static async create(options = {}) {
-        const moduleLoader = options.moduleLoader ?? defaultRapierModuleLoader;
-        let loadedModule = null;
-        try {
-            loadedModule = await moduleLoader();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Rapier physics module is unavailable. Install "${rapierModuleName}" or provide a custom module loader. Original error: ${message}`, { cause: error });
-        }
-        const rapier = resolveRapierModule(loadedModule);
-        if (typeof rapier.init === 'function') {
-            await rapier.init();
-        }
-        const gravityX = options.gravityX ?? 0;
-        const gravityY = options.gravityY ?? 9.81;
-        assertFiniteNumber(gravityX, 'gravityX');
-        assertFiniteNumber(gravityY, 'gravityY');
-        const world = new rapier.worldConstructor(new rapier.vector2(gravityX, gravityY));
-        const eventQueue = new rapier.eventQueueConstructor(true);
-        return new RapierPhysicsWorld(rapier, world, eventQueue);
-    }
-    get gravity() {
-        return {
-            x: this._world.gravity.x,
-            y: this._world.gravity.y,
-        };
-    }
-    setGravity(x, y) {
-        assertFiniteNumber(x, 'gravityX');
-        assertFiniteNumber(y, 'gravityY');
-        this._world.gravity.x = x;
-        this._world.gravity.y = y;
-        return this;
-    }
-    hasNode(node) {
-        return this._nodeBindings.has(node);
-    }
-    getBinding(node) {
-        return this._nodeBindings.get(node) ?? null;
-    }
-    attachNode(node, options) {
-        if (this._nodeBindings.has(node)) {
-            throw new Error('This SceneNode is already attached to a physics body.');
-        }
-        assertBodyOptions(options);
-        const bodyDescriptor = this.createBodyDescriptor(node, options);
-        const body = this._world.createRigidBody(bodyDescriptor);
-        const colliderDescriptor = this.createColliderDescriptor(options);
-        const collider = this._world.createCollider(colliderDescriptor, body);
-        const binding = new RapierPhysicsBinding(this, node, body, collider, options);
-        this._bindings.add(binding);
-        this._nodeBindings.set(node, binding);
-        this._colliderBindings.set(collider.handle, binding);
-        return binding;
-    }
-    detachNode(node) {
-        const binding = this._nodeBindings.get(node);
-        if (binding) {
-            this.removeBinding(binding);
-        }
-        return this;
-    }
-    step(deltaSeconds = defaultDeltaSeconds) {
-        assertFiniteNumber(deltaSeconds, 'deltaSeconds');
-        if (deltaSeconds < 0) {
-            throw new Error('deltaSeconds must be zero or greater.');
-        }
-        this.applyStepDelta(deltaSeconds);
-        this._world.step(this._eventQueue);
-        this.drainCollisionEvents();
-        this.syncNodeTransforms();
-        return this;
-    }
-    syncNodeTransforms() {
-        for (const binding of this._bindings) {
-            if (binding.syncMode === 'physicsToNode') {
-                binding.syncNodeFromBody();
-            }
-        }
-        return this;
-    }
-    createDebugGraphics(options = {}) {
-        const graphics = new Graphics();
-        graphics.setCullable(false);
-        this.updateDebugGraphics(graphics, options);
-        return graphics;
-    }
-    updateDebugGraphics(graphics, options = {}) {
-        const lineWidth = options.lineWidth ?? defaultDebugDrawOptions.lineWidth;
-        const solidLineColor = options.solidLineColor ?? defaultDebugDrawOptions.solidLineColor;
-        const solidFillColor = options.solidFillColor ?? defaultDebugDrawOptions.solidFillColor;
-        const triggerLineColor = options.triggerLineColor ?? defaultDebugDrawOptions.triggerLineColor;
-        const triggerFillColor = options.triggerFillColor ?? defaultDebugDrawOptions.triggerFillColor;
-        graphics.clear();
-        graphics.lineWidth = lineWidth;
-        for (const binding of this._bindings) {
-            const bodyTranslation = {
-                x: binding.x,
-                y: binding.y,
-            };
-            const rotation = binding.rotation;
-            const lineColor = binding.trigger ? triggerLineColor : solidLineColor;
-            const fillColor = binding.trigger ? triggerFillColor : solidFillColor;
-            graphics.lineColor = lineColor;
-            graphics.fillColor = fillColor;
-            if (binding.shape.type === 'box') {
-                const path = this.buildBoxPath(binding.shape, bodyTranslation.x, bodyTranslation.y, rotation);
-                graphics.drawPolygon(path);
-            }
-            else {
-                const offset = getOffset(binding.shape);
-                const rotatedOffset = rotatePoint(offset.x, offset.y, rotation);
-                graphics.drawCircle(bodyTranslation.x + rotatedOffset.x, bodyTranslation.y + rotatedOffset.y, binding.shape.radius);
-            }
-        }
-        return graphics;
-    }
-    destroy() {
-        for (const binding of Array.from(this._bindings)) {
-            this.removeBinding(binding);
-        }
-        this.onCollisionEnter.destroy();
-        this.onCollisionExit.destroy();
-        this.onTriggerEnter.destroy();
-        this.onTriggerExit.destroy();
-    }
-    writeBodyTransform(body, x, y, rotation, wakeUp) {
-        body.setTranslation(new this._rapier.vector2(x, y), wakeUp);
-        body.setRotation(rotation, wakeUp);
-    }
-    removeBinding(binding) {
-        if (!this._bindings.has(binding)) {
-            return;
-        }
-        this._bindings.delete(binding);
-        this._nodeBindings.delete(binding.node);
-        this._colliderBindings.delete(binding.colliderHandle);
-        this._world.removeRigidBody(binding.getBody());
-    }
-    createBodyDescriptor(node, options) {
-        const type = options.type ?? 'dynamic';
-        let descriptor = this._rapier.rigidBodyDescFactory.dynamic();
-        switch (type) {
-            case 'static':
-                descriptor = this._rapier.rigidBodyDescFactory.fixed();
-                break;
-            case 'kinematic':
-                if (typeof this._rapier.rigidBodyDescFactory.kinematicPositionBased === 'function') {
-                    descriptor = this._rapier.rigidBodyDescFactory.kinematicPositionBased();
-                }
-                else if (typeof this._rapier.rigidBodyDescFactory.kinematicVelocityBased === 'function') {
-                    descriptor = this._rapier.rigidBodyDescFactory.kinematicVelocityBased();
-                }
-                else {
-                    throw new Error('Rapier module does not expose a kinematic rigid-body descriptor.');
-                }
-                break;
-            default:
-                descriptor = this._rapier.rigidBodyDescFactory.dynamic();
-                break;
-        }
-        descriptor
-            .setTranslation(node.x, node.y)
-            .setRotation(node.rotation)
-            .setLinearDamping(options.linearDamping ?? 0)
-            .setAngularDamping(options.angularDamping ?? 0)
-            .setGravityScale(options.gravityScale ?? 1)
-            .lockRotations(options.lockRotation ?? false);
-        return descriptor;
-    }
-    createColliderDescriptor(options) {
-        const shape = options.shape;
-        const descriptor = shape.type === 'box'
-            ? this._rapier.colliderDescFactory.cuboid(shape.width / 2, shape.height / 2)
-            : this._rapier.colliderDescFactory.ball(shape.radius);
-        const offset = getOffset(shape);
-        const groups = toPackedCollisionGroups(options.collisionFilter);
-        descriptor
-            .setTranslation(offset.x, offset.y)
-            .setRotation(shape.type === 'box' ? (shape.offsetRotation ?? 0) : 0)
-            .setSensor(options.trigger ?? false)
-            .setFriction(options.friction ?? 0.5)
-            .setRestitution(options.restitution ?? 0)
-            .setDensity(options.density ?? 1)
-            .setCollisionGroups(groups)
-            .setSolverGroups(groups);
-        const collisionEvents = this._rapier.activeCollisionEvents;
-        if (typeof collisionEvents === 'number') {
-            descriptor.setActiveEvents(collisionEvents);
-        }
-        return descriptor;
-    }
-    applyStepDelta(deltaSeconds) {
-        const worldWithTimestep = this._world;
-        if (typeof worldWithTimestep.timestep === 'number') {
-            worldWithTimestep.timestep = deltaSeconds;
-        }
-        if (worldWithTimestep.integrationParameters
-            && typeof worldWithTimestep.integrationParameters.dt === 'number') {
-            worldWithTimestep.integrationParameters.dt = deltaSeconds;
-        }
-    }
-    drainCollisionEvents() {
-        this._eventQueue.drainCollisionEvents((handleA, handleB, started) => {
-            const first = this._colliderBindings.get(handleA);
-            const second = this._colliderBindings.get(handleB);
-            if (!first || !second) {
-                return;
-            }
-            const trigger = first.trigger || second.trigger;
-            const event = {
-                started,
-                trigger,
-                first,
-                second,
-            };
-            if (trigger) {
-                if (started) {
-                    this.onTriggerEnter.dispatch(event);
-                }
-                else {
-                    this.onTriggerExit.dispatch(event);
-                }
-                return;
-            }
-            if (started) {
-                this.onCollisionEnter.dispatch(event);
-            }
-            else {
-                this.onCollisionExit.dispatch(event);
-            }
-        });
-    }
-    buildBoxPath(shape, bodyX, bodyY, bodyRotation) {
-        const halfWidth = shape.width / 2;
-        const halfHeight = shape.height / 2;
-        const corners = [
-            { x: -halfWidth, y: -halfHeight },
-            { x: halfWidth, y: -halfHeight },
-            { x: halfWidth, y: halfHeight },
-            { x: -halfWidth, y: halfHeight },
-        ];
-        const offset = getOffset(shape);
-        const offsetRotation = shape.offsetRotation ?? 0;
-        const path = [];
-        for (const corner of corners) {
-            const local = rotatePoint(corner.x, corner.y, offsetRotation);
-            const withOffset = {
-                x: local.x + offset.x,
-                y: local.y + offset.y,
-            };
-            const worldPoint = rotatePoint(withOffset.x, withOffset.y, bodyRotation);
-            path.push(bodyX + worldPoint.x, bodyY + worldPoint.y);
-        }
-        return path;
-    }
-}
-const createRapierPhysicsWorld = async (options = {}) => {
-    return await RapierPhysicsWorld.create(options);
-};
-
-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, RapierPhysicsBinding, RapierPhysicsWorld, 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, createRapierPhysicsWorld, 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, 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 };
 //# sourceMappingURL=exo.esm.js.map