@tushar-br/desktop 1.0.173 → 1.0.174

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/worker.min.js

@@ -0,0 +1,5 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+import{g as e}from"./_commonjsHelpers-CDmClQiF.js";import{c as r}from"./compress-DY-CSunh.js";var n,t,o,s={exports:{}};function a(){if(n)return s.exports;function e(e){return!!e&&("object"==typeof e||"function"==typeof e)&&"function"==typeof e.then}return n=1,s.exports=e,s.exports.default=e,s.exports}var f=function(){if(o)return t;o=1;var e=a();return t=function(r){function n(e,r,n,t){function o(r,n){"function"!=typeof self.postMessage?e.ports[0].postMessage(r,n):self.postMessage(r,n)}n?("undefined"!=typeof console&&"error"in console&&console.error("Worker caught an error:",n),o([r,{message:n.message}])):t instanceof s?o([r,null,t.message],t.transferList):o([r,null,t])}function t(e,r){return new s(e,r)}function o(r,o,s,a){var f=function(e,r){try{return{res:e(r,t)}}catch(e){return{err:e}}}(o,a);f.err?n(r,s,f.err):e(f.res)?f.res.then(function(e){n(r,s,null,e)},function(e){n(r,s,e)}):n(r,s,null,f.res)}function s(e,r){this.message=e,this.transferList=r}self.addEventListener("message",function(e){var t=e.data;if(Array.isArray(t)&&2===t.length){var s=t[0],a=t[1];"function"!=typeof r?n(e,s,new Error("Please pass a function into register().")):o(e,r,s,a)}})}}();e(f)(async(e,n)=>{if("compress"===e.type)return(async(e,n)=>{const t=await r(e.payload);return n({...t,source:e.payload.source instanceof ImageData?e.payload.source.data:new Uint8ClampedArray(e.payload.source)},[t.data.buffer,e.payload.source instanceof ImageData?e.payload.source.data.buffer:e.payload.source.buffer])})(e,n)});

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/worker.umd.cjs

@@ -0,0 +1,236 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+
+(function (factory) {
+	typeof define === 'function' && define.amd ? define(factory) :
+	factory();
+})((function () { 'use strict';
+
+	function getDefaultExportFromCjs (x) {
+		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	}
+
+	var isPromise = {exports: {}};
+
+	var hasRequiredIsPromise;
+
+	function requireIsPromise () {
+		if (hasRequiredIsPromise) return isPromise.exports;
+		hasRequiredIsPromise = 1;
+		isPromise.exports = isPromise$1;
+		isPromise.exports.default = isPromise$1;
+
+		function isPromise$1(obj) {
+		  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+		}
+		return isPromise.exports;
+	}
+
+	var register;
+	var hasRequiredRegister;
+
+	function requireRegister () {
+		if (hasRequiredRegister) return register;
+		hasRequiredRegister = 1;
+
+		var isPromise = requireIsPromise();
+
+		function registerPromiseWorker(callback) {
+
+		  function postOutgoingMessage(e, messageId, error, result) {
+		    function postMessage(msg, transferList) {
+		      /* istanbul ignore if */
+		      if (typeof self.postMessage !== 'function') { // service worker
+		        e.ports[0].postMessage(msg, transferList);
+		      } else { // web worker
+		        self.postMessage(msg, transferList);
+		      }
+		    }
+		    if (error) {
+		      /* istanbul ignore else */
+		      if (typeof console !== 'undefined' && 'error' in console) {
+		        // This is to make errors easier to debug. I think it's important
+		        // enough to just leave here without giving the user an option
+		        // to silence it.
+		        console.error('Worker caught an error:', error);
+		      }
+		      postMessage([messageId, {
+		        message: error.message
+		      }]);
+		    } else {
+		      if (result instanceof MessageWithTransferList) {
+		        postMessage([messageId, null, result.message], result.transferList);
+		      } else {
+		        postMessage([messageId, null, result]);
+		      }
+		    }
+		  }
+
+		  function tryCatchFunc(callback, message) {
+		    try {
+		      return {res: callback(message, withTransferList)};
+		    } catch (e) {
+		      return {err: e};
+		    }
+		  }
+
+		  function withTransferList(resMessage, transferList) {
+		    return new MessageWithTransferList(resMessage, transferList);
+		  } 
+
+		  function handleIncomingMessage(e, callback, messageId, message) {
+
+		    var result = tryCatchFunc(callback, message);
+
+		    if (result.err) {
+		      postOutgoingMessage(e, messageId, result.err);
+		    } else if (!isPromise(result.res)) {
+		        postOutgoingMessage(e, messageId, null, result.res);
+		    } else {
+		      result.res.then(function (finalResult) {
+		        postOutgoingMessage(e, messageId, null, finalResult);
+		      }, function (finalError) {
+		        postOutgoingMessage(e, messageId, finalError);
+		      });
+		    }
+		  }
+
+		  function onIncomingMessage(e) {
+		    var payload = e.data;
+		    if (!Array.isArray(payload) || payload.length !== 2) {
+		      // message doens't match communication format; ignore
+		      return;
+		    }
+		    var messageId = payload[0];
+		    var message = payload[1];
+
+		    if (typeof callback !== 'function') {
+		      postOutgoingMessage(e, messageId, new Error(
+		        'Please pass a function into register().'));
+		    } else {
+		      handleIncomingMessage(e, callback, messageId, message);
+		    }
+		  }
+
+		  function MessageWithTransferList(message, transferList) {
+		    this.message = message;
+		    this.transferList = transferList;
+		  }
+
+		  self.addEventListener('message', onIncomingMessage);
+		}
+
+		register = registerPromiseWorker;
+		return register;
+	}
+
+	var registerExports = requireRegister();
+	var registerPromiseWorker = /*@__PURE__*/getDefaultExportFromCjs(registerExports);
+
+	/**
+	 * Used internally
+	 *
+	 * @internal
+	 * @param canvas
+	 * @param mimeType
+	 * @param quality
+	 * @returns
+	 */
+	const canvasToBlob = async (canvas, mimeType, quality) => {
+	    if (typeof OffscreenCanvas !== 'undefined' && canvas instanceof OffscreenCanvas) {
+	        return canvas.convertToBlob({ type: mimeType, quality: quality });
+	    }
+	    else if (canvas instanceof HTMLCanvasElement) {
+	        return new Promise((resolve, reject) => {
+	            canvas.toBlob((res) => {
+	                if (res)
+	                    resolve(res);
+	                else
+	                    reject(new Error('Failed to convert canvas to blob'));
+	            }, mimeType, quality);
+	        });
+	    }
+	    /* istanbul ignore next
+	      as long as this function is not exported this is only here
+	      to satisfy TS strict mode internally
+	    */
+	    throw new Error('Unsupported canvas element');
+	};
+	/**
+	 * Converts a RAW RGBA image buffer into the provided `mimeType` using the provided `quality`
+	 *
+	 * @category Compression
+	 * @group Compression
+	 * @param params
+	 * @throws {Error} if the browser does not support [createImageBitmap](https://caniuse.com/createimagebitmap)
+	 * @throws {Error} if the provided source image cannot be decoded
+	 * @throws {Error} if the function fails to create a canvas context
+	 */
+	const compress = async (params) => {
+	    if (typeof createImageBitmap === 'undefined')
+	        throw new Error('createImageBitmap() not supported.');
+	    const { source, mimeType, quality, flipY } = params;
+	    let imageBitmapSource;
+	    if ((source instanceof Uint8Array || source instanceof Uint8ClampedArray) && 'sourceMimeType' in params) {
+	        imageBitmapSource = new Blob([source], { type: params.sourceMimeType });
+	    }
+	    else if (source instanceof ImageData) {
+	        imageBitmapSource = source;
+	    }
+	    else {
+	        throw new Error('Invalid source image');
+	    }
+	    const img = await createImageBitmap(imageBitmapSource);
+	    const width = img.width;
+	    const height = img.height;
+	    let canvas;
+	    if (typeof OffscreenCanvas !== 'undefined') {
+	        canvas = new OffscreenCanvas(width, height);
+	    }
+	    else {
+	        canvas = document.createElement('canvas');
+	        canvas.width = width;
+	        canvas.height = height;
+	    }
+	    // apparently we do need to assert the type here for npx tsc to be happy
+	    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+	    const ctx = canvas.getContext('2d');
+	    if (!ctx)
+	        throw new Error('Failed to create canvas Context');
+	    // flip Y
+	    if (flipY === true) {
+	        ctx.translate(0, height);
+	        ctx.scale(1, -1);
+	    }
+	    ctx.drawImage(img, 0, 0, width, height);
+	    const blob = await canvasToBlob(canvas, mimeType, quality || 0.9);
+	    const data = new Uint8Array(await blob.arrayBuffer());
+	    return {
+	        data,
+	        mimeType,
+	        width,
+	        height
+	    };
+	};
+
+	// @ts-expect-error untyped lib
+	const _compress = async (message, withTransferList) => {
+	    const result = await compress(message.payload);
+	    return withTransferList({
+	        ...result,
+	        source: message.payload.source instanceof ImageData ? message.payload.source.data : new Uint8ClampedArray(message.payload.source)
+	    }, [result.data.buffer, message.payload.source instanceof ImageData ? message.payload.source.data.buffer : message.payload.source.buffer]);
+	};
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-call
+	registerPromiseWorker(async (message, withTransferList) => {
+	    switch (message.type) {
+	        // case 'encode-gainmap-buffers':
+	        //   return encodeGainmapBuffers(message, withTransferList)
+	        case 'compress':
+	            return _compress(message, withTransferList);
+	    }
+	});
+
+}));

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/worker.umd.min.cjs

@@ -0,0 +1,5 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+!function(e){"function"==typeof define&&define.amd?define(e):e()}(function(){"use strict";function e(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var t,n,r,a={exports:{}};function o(){if(t)return a.exports;function e(e){return!!e&&("object"==typeof e||"function"==typeof e)&&"function"==typeof e.then}return t=1,a.exports=e,a.exports.default=e,a.exports}var s=function(){if(r)return n;r=1;var e=o();return n=function(t){function n(e,t,n,r){function a(t,n){"function"!=typeof self.postMessage?e.ports[0].postMessage(t,n):self.postMessage(t,n)}n?("undefined"!=typeof console&&"error"in console&&console.error("Worker caught an error:",n),a([t,{message:n.message}])):r instanceof o?a([t,null,r.message],r.transferList):a([t,null,r])}function r(e,t){return new o(e,t)}function a(t,a,o,s){var i=function(e,t){try{return{res:e(t,r)}}catch(e){return{err:e}}}(a,s);i.err?n(t,o,i.err):e(i.res)?i.res.then(function(e){n(t,o,null,e)},function(e){n(t,o,e)}):n(t,o,null,i.res)}function o(e,t){this.message=e,this.transferList=t}self.addEventListener("message",function(e){var r=e.data;if(Array.isArray(r)&&2===r.length){var o=r[0],s=r[1];"function"!=typeof t?n(e,o,new Error("Please pass a function into register().")):a(e,t,o,s)}})}}();const i=async e=>{if("undefined"==typeof createImageBitmap)throw new Error("createImageBitmap() not supported.");const{source:t,mimeType:n,quality:r,flipY:a}=e;let o;if((t instanceof Uint8Array||t instanceof Uint8ClampedArray)&&"sourceMimeType"in e)o=new Blob([t],{type:e.sourceMimeType});else{if(!(t instanceof ImageData))throw new Error("Invalid source image");o=t}const s=await createImageBitmap(o),i=s.width,f=s.height;let c;"undefined"!=typeof OffscreenCanvas?c=new OffscreenCanvas(i,f):(c=document.createElement("canvas"),c.width=i,c.height=f);const u=c.getContext("2d");if(!u)throw new Error("Failed to create canvas Context");!0===a&&(u.translate(0,f),u.scale(1,-1)),u.drawImage(s,0,0,i,f);const l=await(async(e,t,n)=>{if("undefined"!=typeof OffscreenCanvas&&e instanceof OffscreenCanvas)return e.convertToBlob({type:t,quality:n});if(e instanceof HTMLCanvasElement)return new Promise((r,a)=>{e.toBlob(e=>{e?r(e):a(new Error("Failed to convert canvas to blob"))},t,n)});throw new Error("Unsupported canvas element")})(c,n,r||.9);return{data:new Uint8Array(await l.arrayBuffer()),mimeType:n,width:i,height:f}};e(s)(async(e,t)=>{if("compress"===e.type)return(async(e,t)=>{const n=await i(e.payload);return t({...n,source:e.payload.source instanceof ImageData?e.payload.source.data:new Uint8ClampedArray(e.payload.source)},[n.data.buffer,e.payload.source instanceof ImageData?e.payload.source.data.buffer:e.payload.source.buffer])})(e,t)})});

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/package.json

@@ -0,0 +1,167 @@
+{
+  "name": "@monogrid/gainmap-js",
+  "version": "3.4.0",
+  "description": "A Javascript (TypeScript) Port of Adobe Gainmap Technology for storing HDR Images using an SDR Image + a gain map",
+  "keywords": [
+    "hdr",
+    "gain map",
+    "gainmap",
+    "three",
+    "threejs"
+  ],
+  "homepage": "https://github.com/MONOGRID/gainmap-js#readme",
+  "bugs": {
+    "url": "https://github.com/MONOGRID/gainmap-js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/MONOGRID/gainmap-js.git"
+  },
+  "license": "MIT",
+  "author": "MONOGRID <gainmap@monogrid.com>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/decode.d.ts",
+      "import": "./dist/decode.js",
+      "default": "./dist/decode.umd.cjs"
+    },
+    "./webgpu": {
+      "types": "./dist/decode/webgpu/index.d.ts",
+      "import": "./dist/decode.webgpu.js",
+      "default": "./dist/decode.webgpu.umd.cjs"
+    },
+    "./encode": {
+      "types": "./dist/encode.d.ts",
+      "import": "./dist/encode.js",
+      "default": "./dist/encode.umd.cjs"
+    },
+    "./libultrahdr": {
+      "types": "./dist/libultrahdr.d.ts",
+      "import": "./dist/libultrahdr.js",
+      "default": "./dist/libultrahdr.umd.cjs"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js",
+      "default": "./dist/worker.umd.cjs"
+    },
+    "./worker-interface": {
+      "types": "./dist/worker-interface.d.ts",
+      "import": "./dist/worker-interface.js",
+      "default": "./dist/worker-interface.umd.cjs"
+    }
+  },
+  "main": "dist/decode.umd.cjs",
+  "module": "dist/decode.js",
+  "types": "dist/decode.d.ts",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/decode.d.ts"
+      ],
+      "decode/webgpu": [
+        "./dist/decode/webgpu/index.d.ts"
+      ],
+      "decode/webgl": [
+        "./dist/decode/webgl/index.d.ts"
+      ],
+      "encode": [
+        "./dist/encode.d.ts"
+      ],
+      "libultrahdr": [
+        "./dist/libultrahdr.d.ts"
+      ],
+      "worker": [
+        "./dist/worker.d.ts"
+      ],
+      "worker-interface": [
+        "./dist/worker-interface.d.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "check": "concurrently -c auto npm:check:*",
+    "check:eslint-examples": "eslint \"examples/**/*.{ts,html}\"",
+    "check:eslint-src": "eslint \"src/**/*.ts\"",
+    "check:eslint-tests": "eslint \"tests/**/*.ts\"",
+    "check:typecheck-examples": "tsc -p examples",
+    "check:typecheck-src": "tsc -p src",
+    "check:typecheck-tests": "tsc -p tests",
+    "ci:check": "concurrently npm:ci:check:*",
+    "ci:check:eslint-examples": "eslint --format json --output-file reports/eslint-examples.json \"examples/**/*.{ts,html}\"",
+    "ci:check:eslint-src": "eslint --format json --output-file reports/eslint-src.json \"src/**/*.ts\"",
+    "ci:check:eslint-tests": "eslint --format json --output-file reports/eslint-tests.json \"tests/**/*.ts\"",
+    "ci:check:typecheck-examples": "tsc --pretty false -p examples > reports/typecheck-examples.log",
+    "ci:check:typecheck-src": "tsc --pretty false -p src > reports/typecheck.log",
+    "ci:check:typecheck-tests": "tsc --pretty false -p tests > reports/typecheck-tests.log",
+    "dev": "concurrently -n rollup,servez -c magenta,green \"rollup -c -w\" \"servez\"",
+    "prepack": "npm run build",
+    "start": "concurrently -n rollup,servez -c magenta,green \"rollup -c -w\" \"servez\"",
+    "test": "nyc --reporter=text --reporter=lcov playwright test",
+    "test:codegen": "playwright codegen http://localhost:8080",
+    "test:docker": "docker run --rm --network host -v $(pwd):/work -w /work -it -u $(id -u ${USER}):$(id -g ${USER}) mcr.microsoft.com/playwright:v1.56.1-jammy /bin/bash",
+    "test:startserver": "rollup -c && servez"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  },
+  "browserslist": [
+    "> 1%, not dead, not ie 11, not op_mini all"
+  ],
+  "dependencies": {
+    "promise-worker-transferable": "^1.0.4"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@playwright/test": "^1.56.1",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "github:semantic-release/git",
+    "@semantic-release/github": "^12.0.0",
+    "@semantic-release/npm": "^13.1.1",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "@types/node": "^22.18.12",
+    "@types/three": "^0.181.0",
+    "concurrently": "^9.2.1",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "cz-conventional-changelog": "^3.3.0",
+    "eslint": "^9.38.0",
+    "eslint-config-mdcs": "^5.0.0",
+    "eslint-plugin-html": "^8.1.3",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-unused-imports": "^4.3.0",
+    "globals": "^16.4.0",
+    "neostandard": "^0.12.2",
+    "nyc": "^17.1.0",
+    "rollup": "^4.52.5",
+    "rollup-plugin-copy": "^3.5.0",
+    "rollup-plugin-delete": "^3.0.1",
+    "rollup-plugin-istanbul": "^5.0.0",
+    "rollup-plugin-license": "^3.6.0",
+    "semantic-release": "^25.0.1",
+    "servez": "^2.3.2",
+    "sharp": "^0.34.4",
+    "three": "^0.181.1",
+    "typedoc": "^0.28.14",
+    "typedoc-github-wiki-theme": "^2.1.0",
+    "typedoc-plugin-markdown": "^4.9.0",
+    "typescript": "~5.9.0"
+  },
+  "peerDependencies": {
+    "three": ">= 0.159.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

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

@@ -0,0 +1,56 @@
+# @pmndrs/cannon-worker-api Changelog
+
+## 2.4.0
+
+### Minor Changes
+
+- 800a687: feat(props-to-body): support both quaternion and rotation props, prefer quaternion if both provided (@Soham1803)
+- 22d49ef: chore: update @types/three dev dependency
+
+## v2.3.2 - 2023-01-05
+
+- [`README.md`] Improve links to related packages (@bjornstar)
+
+## v2.3.1 - 2022-11-11
+
+- Make sure to include dist in npm package (@bjornstar)
+
+## v2.3.0 - 2022-11-03
+
+- Remove subscriptions when removing bodies and vehicles (@alex-shortt)
+
+## v2.2.0 - 2022-08-18
+
+- Add support for `frictionGravity` on WorldProps (@chnicoloso)
+
+## v2.1.0 - 2022-04-02
+
+- New private method `postMessage` that queues the messages if there is no worker
+- New public method: `connect`, we instantiate the worker, add the onmessage handler and flush the messageQueue
+- New public method: `disconnect`, removes the onmessage handler (probably unnecessary)
+- `init` now takes `world` instead of `state`
+
+## v2.0.0 - 2022-04-01
+
+- `three.js` is now a `peerDependency` and requires r139 or higher
+- Updated many `devDependencies`
+
+## v1.1.0 - 2022-03-19
+
+- [WorkerRayHitEvent] from & to are optional (@bjornstar)
+- [WorkerRayHitEvent] Omit methods from shape type (@bjornstar)
+- [`src/worker`] self.postMessage should be typed to ensure we match API types (@bjornstar)
+- [`src/worker`] Stop using non-null assertions (@bjornstar)
+- [`addBodies`] If the body or target does not have a uuid, don't process the event (@bjornstar)
+- [`addRay`] If the body does not have a uuid, don't process the event (@bjornstar)
+- [`package.json`] Has one dependency: `three` (@bjornstar)
+- [`.eslintrc.json`] Clean up (@bjornstar)
+- [`.eslintrc.json`] Disallow non-null assertions (@bjornstar)
+
+## v1.0.1 - 2022-03-14
+
+- Specify targetPlatform: 'browser' (@isaac-mason)
+
+## v1.0.0 - 2022-03-13
+
+- Initial Release

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

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Paul Henschel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,3 @@
+# @pmndrs/cannon-worker-api
+
+Web worker API for [cannon-es](https://npmjs.com/package/cannon-es). Primarily used in [@react-three/cannon](https://npmjs.com/package/@react-three/cannon).

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

@@ -0,0 +1,66 @@
+import type { MaterialOptions } from 'cannon-es';
+import type { Vector3 } from 'three';
+import type { CollideBeginEvent, CollideEndEvent, CollideEvent, Quad, Triplet, VectorName } from './types';
+export declare 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 declare type VectorProps = Record<VectorName, Triplet>;
+declare type VectorTypes = Vector3 | Triplet;
+export declare 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?: Quad;
+    rotation?: Triplet;
+    type?: 'Dynamic' | 'Static' | 'Kinematic';
+};
+export declare type BodyPropsArgsRequired<T extends any[] = unknown[]> = BodyProps<T> & {
+    args: T;
+};
+export declare type ShapeType = 'Box' | 'ConvexPolyhedron' | 'Cylinder' | 'Heightfield' | 'Particle' | 'Plane' | 'Sphere' | 'Trimesh';
+export declare type BodyShapeType = ShapeType | 'Compound';
+export declare type CylinderArgs = [radiusTop?: number, radiusBottom?: number, height?: number, numSegments?: number];
+export declare type SphereArgs = [radius: number];
+export declare type TrimeshArgs = [vertices: ArrayLike<number>, indices: ArrayLike<number>];
+export declare type HeightfieldArgs = [
+    data: number[][],
+    options: {
+        elementSize?: number;
+        maxValue?: number;
+        minValue?: number;
+    }
+];
+export declare type ConvexPolyhedronArgs<V extends VectorTypes = VectorTypes> = [
+    vertices?: V[],
+    faces?: number[][],
+    normals?: V[],
+    axes?: V[],
+    boundingSphereRadius?: number
+];
+export declare type PlaneProps = BodyProps;
+export declare type BoxProps = BodyProps<Triplet>;
+export declare type CylinderProps = BodyProps<CylinderArgs>;
+export declare type ParticleProps = BodyProps;
+export declare type SphereProps = BodyProps<SphereArgs>;
+export declare type TrimeshProps = BodyPropsArgsRequired<TrimeshArgs>;
+export declare type HeightfieldProps = BodyPropsArgsRequired<HeightfieldArgs>;
+export declare type ConvexPolyhedronProps = BodyProps<ConvexPolyhedronArgs>;
+export interface CompoundBodyProps extends BodyProps {
+    shapes: BodyProps & {
+        type: ShapeType;
+    }[];
+}
+export {};

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

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import type { Broadphase, CannonMessageBody, StepProps, Triplet, WorldProps } from './types';
+export declare type CannonWorkerProps = Partial<WorldProps> & {
+    size?: number;
+};
+export declare class CannonWorkerAPI extends EventEmitter {
+    get axisIndex(): 0 | 1 | 2;
+    set axisIndex(value: 0 | 1 | 2);
+    get broadphase(): Broadphase;
+    set broadphase(value: Broadphase);
+    get frictionGravity(): Triplet | null;
+    set frictionGravity(value: Triplet | null);
+    get gravity(): Triplet;
+    set gravity(value: Triplet);
+    get iterations(): number;
+    set iterations(value: number);
+    get tolerance(): number;
+    set tolerance(value: number);
+    private buffers;
+    private config;
+    private messageQueue;
+    private worker;
+    constructor({ allowSleep, axisIndex, broadphase, defaultContactMaterial, frictionGravity, gravity, iterations, quatNormalizeFast, quatNormalizeSkip, size, solver, tolerance, }: CannonWorkerProps);
+    addBodies({ props, type, uuid }: CannonMessageBody<'addBodies'>): void;
+    addConstraint({ props: [refA, refB, optns], type, uuid }: CannonMessageBody<'addConstraint'>): void;
+    addContactMaterial({ props, uuid }: CannonMessageBody<'addContactMaterial'>): void;
+    addRay({ props, uuid }: CannonMessageBody<'addRay'>): void;
+    addRaycastVehicle({ props: [chassisBodyUUID, wheelUUIDs, wheelInfos, indexForwardAxis, indexRightAxis, indexUpAxis], uuid, }: CannonMessageBody<'addRaycastVehicle'>): void;
+    addSpring({ props: [refA, refB, optns], uuid }: CannonMessageBody<'addSpring'>): void;
+    applyForce({ props, uuid }: CannonMessageBody<'applyForce'>): void;
+    applyImpulse({ props, uuid }: CannonMessageBody<'applyImpulse'>): void;
+    applyLocalForce({ props, uuid }: CannonMessageBody<'applyLocalForce'>): void;
+    applyLocalImpulse({ props, uuid }: CannonMessageBody<'applyLocalImpulse'>): void;
+    applyRaycastVehicleEngineForce({ props, uuid }: CannonMessageBody<'applyRaycastVehicleEngineForce'>): void;
+    applyTorque({ props, uuid }: CannonMessageBody<'applyTorque'>): void;
+    connect(): void;
+    disableConstraint({ uuid }: CannonMessageBody<'disableConstraint'>): void;
+    disableConstraintMotor({ uuid }: CannonMessageBody<'disableConstraintMotor'>): void;
+    disconnect(): void;
+    enableConstraint({ uuid }: CannonMessageBody<'enableConstraint'>): void;
+    enableConstraintMotor({ uuid }: CannonMessageBody<'enableConstraintMotor'>): void;
+    init(): void;
+    removeBodies({ uuid }: CannonMessageBody<'removeBodies'>): void;
+    removeConstraint({ uuid }: CannonMessageBody<'removeConstraint'>): void;
+    removeContactMaterial({ uuid }: CannonMessageBody<'removeContactMaterial'>): void;
+    removeRay({ uuid }: CannonMessageBody<'removeRay'>): void;
+    removeRaycastVehicle({ uuid }: CannonMessageBody<'removeRaycastVehicle'>): void;
+    removeSpring({ uuid }: CannonMessageBody<'removeSpring'>): void;
+    setAllowSleep({ props, uuid }: CannonMessageBody<'setAllowSleep'>): void;
+    setAngularDamping({ props, uuid }: CannonMessageBody<'setAngularDamping'>): void;
+    setAngularFactor({ props, uuid }: CannonMessageBody<'setAngularFactor'>): void;
+    setAngularVelocity({ props, uuid }: CannonMessageBody<'setAngularVelocity'>): void;
+    setCollisionFilterGroup({ props, uuid }: CannonMessageBody<'setCollisionFilterGroup'>): void;
+    setCollisionFilterMask({ props, uuid }: CannonMessageBody<'setCollisionFilterMask'>): void;
+    setCollisionResponse({ props, uuid }: CannonMessageBody<'setCollisionResponse'>): void;
+    setConstraintMotorMaxForce({ props, uuid }: CannonMessageBody<'setConstraintMotorMaxForce'>): void;
+    setConstraintMotorSpeed({ props, uuid }: CannonMessageBody<'setConstraintMotorSpeed'>): void;
+    setFixedRotation({ props, uuid }: CannonMessageBody<'setFixedRotation'>): void;
+    setIsTrigger({ props, uuid }: CannonMessageBody<'setIsTrigger'>): void;
+    setLinearDamping({ props, uuid }: CannonMessageBody<'setLinearDamping'>): void;
+    setLinearFactor({ props, uuid }: CannonMessageBody<'setLinearFactor'>): void;
+    setMass({ props, uuid }: CannonMessageBody<'setMass'>): void;
+    setMaterial({ props, uuid }: CannonMessageBody<'setMaterial'>): void;
+    setPosition({ props, uuid }: CannonMessageBody<'setPosition'>): void;
+    setQuaternion({ props: [x, y, z, w], uuid }: CannonMessageBody<'setQuaternion'>): void;
+    setRaycastVehicleBrake({ props, uuid }: CannonMessageBody<'setRaycastVehicleBrake'>): void;
+    setRaycastVehicleSteeringValue({ props, uuid }: CannonMessageBody<'setRaycastVehicleSteeringValue'>): void;
+    setRotation({ props, uuid }: CannonMessageBody<'setRotation'>): void;
+    setSleepSpeedLimit({ props, uuid }: CannonMessageBody<'setSleepSpeedLimit'>): void;
+    setSleepTimeLimit({ props, uuid }: CannonMessageBody<'setSleepTimeLimit'>): void;
+    setSpringDamping({ props, uuid }: CannonMessageBody<'setSpringDamping'>): void;
+    setSpringRestLength({ props, uuid }: CannonMessageBody<'setSpringRestLength'>): void;
+    setSpringStiffness({ props, uuid }: CannonMessageBody<'setSpringStiffness'>): void;
+    setUserData({ props, uuid }: CannonMessageBody<'setUserData'>): void;
+    setVelocity({ props, uuid }: CannonMessageBody<'setVelocity'>): void;
+    sleep({ uuid }: CannonMessageBody<'sleep'>): void;
+    step(props: StepProps): void;
+    subscribe({ props: { id, target, type }, uuid }: CannonMessageBody<'subscribe'>): void;
+    terminate(): void;
+    unsubscribe({ props }: CannonMessageBody<'unsubscribe'>): void;
+    wakeUp({ uuid }: CannonMessageBody<'wakeUp'>): void;
+    private postMessage;
+}