@tushar-br/desktop 1.0.173 → 1.0.174

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/props-to-body.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="cannon-es" />
+export function propsToBody(options: {
+    uuid: string;
+    props: BodyProps;
+    type: BodyShapeType;
+    createMaterial?: ((materialOptions: MaterialOptions) => Material) | undefined;
+}): Body;
+export type MaterialOptions = import('cannon-es').MaterialOptions;
+import { Material } from "material/Material";
+import { Body } from "objects/Body";

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/types.d.ts

@@ -0,0 +1,352 @@
+import type { ContactMaterialOptions, MaterialOptions, RayOptions as RayOptionsImpl, Shape } from 'cannon-es';
+import type { Object3D } from 'three';
+import type { AtomicProps, BodyShapeType } from './body';
+export type { ContactMaterialOptions };
+export declare type Triplet = [x: number, y: number, z: number];
+export declare type Quad = [x: number, y: number, z: number, w: number];
+export declare type Broadphase = 'Naive' | 'SAP';
+export declare type Solver = 'GS' | 'Split';
+export declare type Buffers = {
+    positions: Float32Array;
+    quaternions: Float32Array;
+};
+export declare type Refs = {
+    [uuid: string]: Object3D;
+};
+export declare type ConstraintTypes = 'PointToPoint' | 'ConeTwist' | 'Distance' | 'Lock';
+export interface ConstraintOptns {
+    collideConnected?: boolean;
+    maxForce?: number;
+    maxMultiplier?: number;
+    wakeUpBodies?: boolean;
+}
+export interface PointToPointConstraintOpts extends ConstraintOptns {
+    pivotA: Triplet;
+    pivotB: Triplet;
+}
+export interface ConeTwistConstraintOpts extends ConstraintOptns {
+    angle?: number;
+    axisA?: Triplet;
+    axisB?: Triplet;
+    pivotA?: Triplet;
+    pivotB?: Triplet;
+    twistAngle?: number;
+}
+export interface DistanceConstraintOpts extends ConstraintOptns {
+    distance?: number;
+}
+export interface HingeConstraintOpts extends ConstraintOptns {
+    axisA?: Triplet;
+    axisB?: Triplet;
+    pivotA?: Triplet;
+    pivotB?: Triplet;
+}
+export declare type LockConstraintOpts = ConstraintOptns;
+export interface SpringOptns {
+    damping?: number;
+    localAnchorA?: Triplet;
+    localAnchorB?: Triplet;
+    restLength?: number;
+    stiffness?: number;
+    worldAnchorA?: Triplet;
+    worldAnchorB?: Triplet;
+}
+export interface WheelInfoOptions {
+    axleLocal?: Triplet;
+    chassisConnectionPointLocal?: Triplet;
+    customSlidingRotationalSpeed?: number;
+    dampingCompression?: number;
+    dampingRelaxation?: number;
+    directionLocal?: Triplet;
+    frictionSlip?: number;
+    isFrontWheel?: boolean;
+    maxSuspensionForce?: number;
+    maxSuspensionTravel?: number;
+    radius?: number;
+    rollInfluence?: number;
+    sideAcceleration?: number;
+    suspensionRestLength?: number;
+    suspensionStiffness?: number;
+    useCustomSlidingRotationalSpeed?: boolean;
+}
+declare type WorkerContact = WorkerCollideEvent['data']['contact'];
+export declare type CollideEvent = Omit<WorkerCollideEvent['data'], 'body' | 'target' | 'contact'> & {
+    body: Object3D;
+    contact: Omit<WorkerContact, 'bi' | 'bj'> & {
+        bi: Object3D;
+        bj: Object3D;
+    };
+    target: Object3D;
+};
+export declare type CollideBeginEvent = {
+    body: Object3D;
+    op: 'event';
+    target: Object3D;
+    type: 'collideBegin';
+};
+export declare type CollideEndEvent = {
+    body: Object3D;
+    op: 'event';
+    target: Object3D;
+    type: 'collideEnd';
+};
+export declare type RayhitEvent = Omit<WorkerRayhitEvent['data'], 'body'> & {
+    body: Object3D | null;
+};
+export declare type PropValue<T extends SubscriptionName = SubscriptionName> = T extends AtomicName ? AtomicProps[T] : T extends VectorName ? Triplet : T extends 'quaternion' ? Quad : T extends 'sliding' ? boolean : never;
+export declare type Subscription = Partial<{
+    [K in SubscriptionName]: (value: PropValue<K>) => void;
+}>;
+export declare type Subscriptions = Partial<{
+    [id: number]: Subscription;
+}>;
+export declare type AtomicName = 'allowSleep' | 'angularDamping' | 'collisionFilterGroup' | 'collisionFilterMask' | 'collisionResponse' | 'fixedRotation' | 'isTrigger' | 'linearDamping' | 'mass' | 'material' | 'sleepSpeedLimit' | 'sleepTimeLimit' | 'userData';
+export declare type VectorName = 'angularFactor' | 'angularVelocity' | 'linearFactor' | 'position' | 'velocity';
+export declare type SubscriptionName = AtomicName | VectorName | 'quaternion' | 'sliding';
+export declare type SetOpName<T extends AtomicName | VectorName | WorldPropName | 'quaternion' | 'rotation'> = `set${Capitalize<T>}`;
+declare type Operation<T extends OpName, P> = {
+    op: T;
+} & (P extends symbol ? {} : {
+    props: P;
+});
+declare type WithUUID<T extends OpName, P = symbol> = Operation<T, P> & {
+    uuid: string;
+};
+declare type WithUUIDs<T extends OpName, P = symbol> = Operation<T, P> & {
+    uuid: string[];
+};
+declare type AddConstraintProps = [
+    uuidA: string,
+    uuidB: string,
+    options: {
+        angle?: number;
+        axisA?: Triplet;
+        axisB?: Triplet;
+        collideConnected?: boolean;
+        distance?: number;
+        maxForce?: number;
+        maxMultiplier?: number;
+        pivotA?: Triplet;
+        pivotB?: Triplet;
+        twistAngle?: number;
+        wakeUpBodies?: boolean;
+    }
+];
+export declare type AddContactMaterialProps = [
+    materialA: MaterialOptions,
+    materialB: MaterialOptions,
+    options: ContactMaterialOptions
+];
+export declare type RayMode = 'Closest' | 'Any' | 'All';
+declare type AddRayProps = {
+    from?: Triplet;
+    mode: RayMode;
+    to?: Triplet;
+} & Pick<RayOptionsImpl, 'checkCollisionResponse' | 'collisionFilterGroup' | 'collisionFilterMask' | 'skipBackfaces'>;
+export declare type RayOptions = Omit<AddRayProps, 'mode'>;
+declare type AtomicMessage<T extends AtomicName> = WithUUID<SetOpName<T>, AtomicProps[T]>;
+declare type VectorMessage = WithUUID<SetOpName<VectorName>, Triplet>;
+declare type SerializableBodyProps = {
+    onCollide: boolean;
+};
+export declare type SubscriptionTarget = 'bodies' | 'vehicles';
+declare type SubscribeMessageProps = {
+    id: number;
+    target: SubscriptionTarget;
+    type: SubscriptionName;
+};
+export declare type Observation = {
+    [K in AtomicName]: [id: number, value: PropValue<K>, type: K];
+}[AtomicName];
+export declare type WorkerFrameMessage = {
+    data: Buffers & {
+        active: boolean;
+        bodies?: string[];
+        observations: Observation[];
+        op: 'frame';
+    };
+};
+export declare type WorkerCollideEvent = {
+    data: {
+        body: string;
+        collisionFilters: {
+            bodyFilterGroup: number;
+            bodyFilterMask: number;
+            targetFilterGroup: number;
+            targetFilterMask: number;
+        };
+        contact: {
+            bi: string;
+            bj: string;
+            contactNormal: number[];
+            contactPoint: number[];
+            id: number;
+            impactVelocity: number;
+            ni: number[];
+            ri: number[];
+            rj: number[];
+        };
+        op: 'event';
+        target: string;
+        type: 'collide';
+    };
+};
+export declare type WorkerRayhitEvent = {
+    data: {
+        body: string | null;
+        distance: number;
+        hasHit: boolean;
+        hitFaceIndex: number;
+        hitNormalWorld: number[];
+        hitPointWorld: number[];
+        op: 'event';
+        ray: {
+            collisionFilterGroup: number;
+            collisionFilterMask: number;
+            direction: number[];
+            from?: Triplet;
+            to?: Triplet;
+            uuid: string;
+        };
+        rayFromWorld: Triplet;
+        rayToWorld: Triplet;
+        shape: (Omit<Shape, 'body' | 'updateBoundingSphereRadius' | 'volume' | 'calculateLocalInertia' | 'calculateWorldAABB'> & {
+            body: string;
+        }) | null;
+        shouldStop: boolean;
+        type: 'rayhit';
+    };
+};
+export declare type WorkerCollideBeginEvent = {
+    data: {
+        bodyA: string;
+        bodyB: string;
+        op: 'event';
+        type: 'collideBegin';
+    };
+};
+export declare type WorkerCollideEndEvent = {
+    data: {
+        bodyA: string;
+        bodyB: string;
+        op: 'event';
+        type: 'collideEnd';
+    };
+};
+export declare type WorkerEventMessage = WorkerCollideBeginEvent | WorkerCollideEndEvent | WorkerCollideEvent | WorkerRayhitEvent;
+export declare type IncomingWorkerMessage = WorkerEventMessage | WorkerFrameMessage;
+export declare type WorldPropName = 'axisIndex' | 'broadphase' | 'frictionGravity' | 'gravity' | 'iterations' | 'tolerance';
+export declare type StepProps = {
+    maxSubSteps?: number;
+    stepSize: number;
+    timeSinceLastCalled?: number;
+};
+export declare type WorldProps = {
+    allowSleep: boolean;
+    axisIndex: 0 | 1 | 2;
+    broadphase: Broadphase;
+    defaultContactMaterial: ContactMaterialOptions;
+    frictionGravity: Triplet | null;
+    gravity: Triplet;
+    iterations: number;
+    quatNormalizeFast: boolean;
+    quatNormalizeSkip: number;
+    solver: Solver;
+    tolerance: number;
+};
+declare type WorldMessage<T extends WorldPropName> = Operation<SetOpName<T>, WorldProps[T]>;
+export declare type CannonMessageMap = {
+    addBodies: WithUUIDs<'addBodies', SerializableBodyProps[]> & {
+        type: BodyShapeType;
+    };
+    addConstraint: WithUUID<'addConstraint', AddConstraintProps> & {
+        type: 'Hinge' | ConstraintTypes;
+    };
+    addContactMaterial: WithUUID<'addContactMaterial', AddContactMaterialProps>;
+    addRay: WithUUID<'addRay', AddRayProps>;
+    addRaycastVehicle: WithUUID<'addRaycastVehicle', [
+        chassisBodyUUID: string,
+        wheelUUIDs: string[],
+        wheelInfos: WheelInfoOptions[],
+        indexForwardAxis: number,
+        indexRightAxis: number,
+        indexUpAxis: number
+    ]>;
+    addSpring: WithUUID<'addSpring', [uuidA: string, uuidB: string, options: SpringOptns]>;
+    applyForce: WithUUID<'applyForce', [force: Triplet, worldPoint: Triplet]>;
+    applyImpulse: WithUUID<'applyImpulse', [impulse: Triplet, worldPoint: Triplet]>;
+    applyLocalForce: WithUUID<'applyLocalForce', [force: Triplet, localPoint: Triplet]>;
+    applyLocalImpulse: WithUUID<'applyLocalImpulse', [impulse: Triplet, localPoint: Triplet]>;
+    applyRaycastVehicleEngineForce: WithUUID<'applyRaycastVehicleEngineForce', [
+        value: number,
+        wheelIndex: number
+    ]>;
+    applyTorque: WithUUID<'applyTorque', [torque: Triplet]>;
+    disableConstraint: WithUUID<'disableConstraint'>;
+    disableConstraintMotor: WithUUID<'disableConstraintMotor'>;
+    enableConstraint: WithUUID<'enableConstraint'>;
+    enableConstraintMotor: WithUUID<'enableConstraintMotor'>;
+    init: Operation<'init', WorldProps>;
+    removeBodies: WithUUIDs<'removeBodies'>;
+    removeConstraint: WithUUID<'removeConstraint'>;
+    removeContactMaterial: WithUUID<'removeContactMaterial'>;
+    removeRay: WithUUID<'removeRay'>;
+    removeRaycastVehicle: WithUUID<'removeRaycastVehicle'>;
+    removeSpring: WithUUID<'removeSpring'>;
+    setAllowSleep: AtomicMessage<'allowSleep'>;
+    setAngularDamping: AtomicMessage<'angularDamping'>;
+    setAngularFactor: VectorMessage;
+    setAngularVelocity: VectorMessage;
+    setAxisIndex: WorldMessage<'axisIndex'>;
+    setBroadphase: WorldMessage<'broadphase'>;
+    setCollisionFilterGroup: AtomicMessage<'collisionFilterGroup'>;
+    setCollisionFilterMask: AtomicMessage<'collisionFilterMask'>;
+    setCollisionResponse: AtomicMessage<'collisionResponse'>;
+    setConstraintMotorMaxForce: WithUUID<'setConstraintMotorMaxForce', number>;
+    setConstraintMotorSpeed: WithUUID<'setConstraintMotorSpeed', number>;
+    setFixedRotation: AtomicMessage<'fixedRotation'>;
+    setFrictionGravity: WorldMessage<'frictionGravity'>;
+    setGravity: WorldMessage<'gravity'>;
+    setIsTrigger: AtomicMessage<'isTrigger'>;
+    setIterations: WorldMessage<'iterations'>;
+    setLinearDamping: AtomicMessage<'linearDamping'>;
+    setLinearFactor: VectorMessage;
+    setMass: AtomicMessage<'mass'>;
+    setMaterial: AtomicMessage<'material'>;
+    setPosition: VectorMessage;
+    setQuaternion: WithUUID<SetOpName<'quaternion'>, Quad>;
+    setRaycastVehicleBrake: WithUUID<'setRaycastVehicleBrake', [brake: number, wheelIndex: number]>;
+    setRaycastVehicleSteeringValue: WithUUID<'setRaycastVehicleSteeringValue', [
+        value: number,
+        wheelIndex: number
+    ]>;
+    setRotation: WithUUID<SetOpName<'rotation'>, Triplet>;
+    setSleepSpeedLimit: AtomicMessage<'sleepSpeedLimit'>;
+    setSleepTimeLimit: AtomicMessage<'sleepTimeLimit'>;
+    setSpringDamping: WithUUID<'setSpringDamping', number>;
+    setSpringRestLength: WithUUID<'setSpringRestLength', number>;
+    setSpringStiffness: WithUUID<'setSpringStiffness', number>;
+    setTolerance: WorldMessage<'tolerance'>;
+    setUserData: AtomicMessage<'userData'>;
+    setVelocity: VectorMessage;
+    sleep: WithUUID<'sleep'>;
+    step: Operation<'step', StepProps> & {
+        positions: Float32Array;
+        quaternions: Float32Array;
+    };
+    subscribe: WithUUID<'subscribe', SubscribeMessageProps>;
+    unsubscribe: Operation<'unsubscribe', number>;
+    wakeUp: WithUUID<'wakeUp'>;
+};
+declare type OpName = keyof CannonMessageMap;
+export declare type CannonMessageBody<T extends OpName> = Omit<CannonMessageMap[T], 'op'>;
+export declare type CannonMessageProps<T extends OpName> = CannonMessageMap[T] extends {
+    props: unknown;
+} ? CannonMessageMap[T]['props'] : never;
+export declare type CannonMessage = CannonMessageMap[OpName];
+export interface CannonWebWorker extends Worker {
+    onmessage: ((e: IncomingWorkerMessage) => void) | null;
+    postMessage(message: CannonMessage, transfer: Transferable[]): void;
+    postMessage(message: CannonMessage, options?: StructuredSerializeOptions): void;
+    terminate: () => void;
+}

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/contact-material.d.ts

@@ -0,0 +1,5 @@
+import type { CannonMessageBody } from '../types';
+import type { CreateMaterial } from './material';
+import type { State } from './state';
+export declare const addContactMaterial: (world: State['world'], createMaterial: CreateMaterial, [materialA, materialB, options]: CannonMessageBody<'addContactMaterial'>['props'], uuid: string) => void;
+export declare const removeContactMaterial: (world: State['world'], cmUUID: string) => void;

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference no-default-lib="true"/>
+/// <reference lib="esnext" />
+/// <reference lib="webworker" />
+export {};

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/material.d.ts

@@ -0,0 +1,9 @@
+import { Material } from 'cannon-es';
+declare type MaterialOptions = {
+    friction?: number;
+    name?: string | symbol;
+    restitution?: number;
+};
+export declare type CreateMaterial = (nameOrOptions?: MaterialOptions | string) => Material;
+export declare const createMaterialFactory: (materials: Record<string | symbol, Material>) => CreateMaterial;
+export {};

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/operations/add-bodies.d.ts

@@ -0,0 +1,4 @@
+import type { CannonMessageMap } from '../../types';
+import type { CreateMaterial } from '../material';
+import type { State } from '../state';
+export declare const addBodies: (state: State, createMaterial: CreateMaterial, { props, type, uuid }: CannonMessageMap['addBodies']) => void;

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/operations/add-constraint.d.ts

@@ -0,0 +1,3 @@
+import type { CannonMessageMap } from '../../types';
+import type { State } from '../state';
+export declare const addConstraint: (state: State, { props: [bodyA, bodyB, { angle, axisA, axisB, collideConnected, distance, maxForce, maxMultiplier, pivotA, pivotB, twistAngle, wakeUpBodies, },], type, uuid, }: CannonMessageMap['addConstraint']) => void;

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/operations/add-ray.d.ts

@@ -0,0 +1,3 @@
+import type { CannonMessageMap } from '../../types';
+import type { State } from '../state';
+export declare const addRay: (state: State, { props: { from, mode, to, ...rayOptions }, uuid }: CannonMessageMap['addRay']) => void;

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/operations/add-raycast-vehicle.d.ts

@@ -0,0 +1,3 @@
+import type { CannonMessageMap } from '../../types';
+import type { State } from '../state';
+export declare const addRaycastVehicle: (state: State, data: CannonMessageMap['addRaycastVehicle']) => void;

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/operations/add-spring.d.ts

@@ -0,0 +1,3 @@
+import type { CannonMessageMap } from '../../types';
+import type { State } from '../state';
+export declare const addSpring: (state: State, { props: [bodyA, bodyB, { damping, localAnchorA, localAnchorB, restLength, stiffness, worldAnchorA, worldAnchorB },], uuid, }: CannonMessageMap['addSpring']) => void;

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/operations/index.d.ts

@@ -0,0 +1,7 @@
+export { addBodies } from './add-bodies';
+export { addConstraint } from './add-constraint';
+export { addRay } from './add-ray';
+export { addRaycastVehicle } from './add-raycast-vehicle';
+export { addSpring } from './add-spring';
+export { init } from './init';
+export { step } from './step';

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/operations/init.d.ts

@@ -0,0 +1,3 @@
+import type { CannonMessageProps } from '../../types';
+import type { DecoratedWorld } from '../state';
+export declare const init: (world: DecoratedWorld, { allowSleep, axisIndex, broadphase, defaultContactMaterial, frictionGravity, gravity, iterations, quatNormalizeFast, quatNormalizeSkip, solver, tolerance, }: CannonMessageProps<'init'>) => void;

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/operations/step.d.ts

@@ -0,0 +1,3 @@
+import type { CannonMessageMap } from '../../types';
+import type { State } from '../state';
+export declare const step: (state: State, { positions, props: { maxSubSteps, stepSize, timeSinceLastCalled }, quaternions }: CannonMessageMap['step']) => void;

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/state.d.ts

@@ -0,0 +1,42 @@
+import type { Body, Constraint, ContactMaterial, Material, RaycastVehicle, Spring } from 'cannon-es';
+import { World } from 'cannon-es';
+import type { SubscriptionName, SubscriptionTarget } from '../types';
+import type { WithUUID } from './types';
+export interface DecoratedWorld extends World {
+    bodies: WithUUID<Body>[];
+    constraints: WithUUID<Constraint>[];
+    contactmaterials: WithUUID<ContactMaterial>[];
+}
+export interface State {
+    bodies: {
+        [uuid: string]: Body;
+    };
+    bodiesNeedSyncing: boolean;
+    constraints: {
+        [uuid: string]: () => void;
+    };
+    materials: {
+        [uuid: string]: Material;
+    };
+    rays: {
+        [uuid: string]: () => void;
+    };
+    springInstances: {
+        [uuid: string]: Spring;
+    };
+    springs: {
+        [uuid: string]: () => void;
+    };
+    subscriptions: {
+        [id: string]: [uuid: string, type: SubscriptionName, target: SubscriptionTarget];
+    };
+    vehicles: {
+        [uuid: string]: {
+            postStep: () => void;
+            preStep: () => void;
+            vehicle: RaycastVehicle;
+        };
+    };
+    world: DecoratedWorld;
+}
+export declare const state: State;

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/triplet-to-vec3.d.ts

@@ -0,0 +1,3 @@
+import { Vec3 } from 'cannon-es';
+import type { Triplet } from '../types';
+export declare const tripletToVec3: (t?: Triplet | undefined) => Vec3 | undefined;

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/dist/worker/types.d.ts

@@ -0,0 +1,15 @@
+import type { Body, ContactEquation } from 'cannon-es';
+import type { IncomingWorkerMessage } from '../types';
+export declare type WithUUID<C> = C & {
+    uuid?: string;
+};
+export interface CannonWorkerGlobalScope extends ServiceWorkerGlobalScope {
+    postMessage(message: IncomingWorkerMessage['data'], transfer: Transferable[]): void;
+    postMessage(message: IncomingWorkerMessage['data'], options?: StructuredSerializeOptions): void;
+}
+export interface CannonCollideEvent {
+    body: WithUUID<Body>;
+    contact: ContactEquation;
+    target: WithUUID<Body>;
+    type: 'collide';
+}

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@pmndrs/cannon-worker-api",
+  "version": "2.4.0",
+  "description": "An API to use cannon-es in a web worker",
+  "keywords": [
+    "cannon",
+    "three",
+    "worker",
+    "physics"
+  ],
+  "author": "Paul Henschel",
+  "contributors": [
+    "Cody Persinger <codypersinger@gmail.com> (https://github.com/codynova)",
+    "Bjorn Stromberg <bjorn@bjornstar.com> (https://github.com/bjornstar)"
+  ],
+  "homepage": "https://github.com/pmndrs/use-cannon/tree/master/packages/cannon-worker-api#readme",
+  "repository": "github:pmndrs/use-cannon",
+  "license": "MIT",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc && rollup -c",
+    "clean": "rm -rf dist/*",
+    "test": "echo tests are missing",
+    "eslint": "eslint .",
+    "eslint-fix": "eslint --fix .",
+    "prettier": "prettier --list-different .",
+    "prettier-fix": "prettier --write ."
+  },
+  "devDependencies": {
+    "@babel/core": "^7.17.8",
+    "@babel/plugin-transform-runtime": "^7.17.0",
+    "@babel/preset-env": "^7.16.11",
+    "@babel/preset-typescript": "^7.16.7",
+    "@rollup/plugin-babel": "^5.3.1",
+    "@rollup/plugin-commonjs": "^21.0.3",
+    "@rollup/plugin-node-resolve": "^13.1.3",
+    "@types/events": "^3.0.0",
+    "@types/three": "^0.155.0",
+    "@typescript-eslint/eslint-plugin": "^5.17.0",
+    "@typescript-eslint/parser": "^5.17.0",
+    "cannon-es": "^0.20.0",
+    "eslint": "^8.12.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-es": "^4.1.0",
+    "eslint-plugin-simple-import-sort": "^7.0.0",
+    "eslint-plugin-typescript-enum": "^2.1.0",
+    "events": "^3.3.0",
+    "prettier": "^2.6.1",
+    "rollup": "^2.70.1",
+    "rollup-plugin-web-worker-loader": "^1.6.1",
+    "typescript": "^4.6.3"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx}": "eslint --cache --fix",
+    "*.{js,jsx,ts,tsx,md}": "prettier --write"
+  },
+  "peerDependencies": {
+    "three": ">=0.139"
+  }
+}

package/staging_area/desktop/car gaem/node_modules/@pmndrs/cannon-worker-api/src/body.ts

@@ -0,0 +1,79 @@
+import type { MaterialOptions } from 'cannon-es'
+import type { Vector3 } from 'three'
+
+import type { CollideBeginEvent, CollideEndEvent, CollideEvent, Quad, Triplet, VectorName } from './types'
+
+export type AtomicProps = {
+  allowSleep: boolean
+  angularDamping: number
+  collisionFilterGroup: number
+  collisionFilterMask: number
+  collisionResponse: boolean
+  fixedRotation: boolean
+  isTrigger: boolean
+  linearDamping: number
+  mass: number
+  material: MaterialOptions
+  sleepSpeedLimit: number
+  sleepTimeLimit: number
+  userData: Record<PropertyKey, any>
+}
+
+export type VectorProps = Record<VectorName, Triplet>
+type VectorTypes = Vector3 | Triplet
+
+export type BodyProps<T extends any[] = unknown[]> = Partial<AtomicProps> &
+  Partial<VectorProps> & {
+    args?: T
+    onCollide?: (e: CollideEvent) => void
+    onCollideBegin?: (e: CollideBeginEvent) => void
+    onCollideEnd?: (e: CollideEndEvent) => void
+    /**
+     * Quaternion is preferred over rotation if both are provided
+     */
+    quaternion?: Quad
+    rotation?: Triplet
+    type?: 'Dynamic' | 'Static' | 'Kinematic'
+  }
+
+export type BodyPropsArgsRequired<T extends any[] = unknown[]> = BodyProps<T> & {
+  args: T
+}
+
+export type ShapeType =
+  | 'Box'
+  | 'ConvexPolyhedron'
+  | 'Cylinder'
+  | 'Heightfield'
+  | 'Particle'
+  | 'Plane'
+  | 'Sphere'
+  | 'Trimesh'
+export type BodyShapeType = ShapeType | 'Compound'
+
+export type CylinderArgs = [radiusTop?: number, radiusBottom?: number, height?: number, numSegments?: number]
+export type SphereArgs = [radius: number]
+export type TrimeshArgs = [vertices: ArrayLike<number>, indices: ArrayLike<number>]
+export type HeightfieldArgs = [
+  data: number[][],
+  options: { elementSize?: number; maxValue?: number; minValue?: number },
+]
+export type ConvexPolyhedronArgs<V extends VectorTypes = VectorTypes> = [
+  vertices?: V[],
+  faces?: number[][],
+  normals?: V[],
+  axes?: V[],
+  boundingSphereRadius?: number,
+]
+
+export type PlaneProps = BodyProps
+export type BoxProps = BodyProps<Triplet>
+export type CylinderProps = BodyProps<CylinderArgs>
+export type ParticleProps = BodyProps
+export type SphereProps = BodyProps<SphereArgs>
+export type TrimeshProps = BodyPropsArgsRequired<TrimeshArgs>
+export type HeightfieldProps = BodyPropsArgsRequired<HeightfieldArgs>
+export type ConvexPolyhedronProps = BodyProps<ConvexPolyhedronArgs>
+export interface CompoundBodyProps extends BodyProps {
+  shapes: BodyProps & { type: ShapeType }[]
+}