@tushar-br/desktop 1.0.173 → 1.0.174

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/QuadRenderer-Bj1xl_EK.js

@@ -0,0 +1,310 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+
+import { ClampToEdgeWrapping, LinearFilter, Scene, OrthographicCamera, HalfFloatType, FloatType, Mesh, PlaneGeometry, WebGLRenderTarget, RGBAFormat, UVMapping, WebGLRenderer, DataTexture, LinearSRGBColorSpace, ShaderMaterial, Texture, MeshBasicMaterial, IntType, ShortType, ByteType, UnsignedIntType, UnsignedByteType } from 'three';
+
+const getBufferForType = (type, width, height) => {
+    let out;
+    switch (type) {
+        case UnsignedByteType:
+            out = new Uint8ClampedArray(width * height * 4);
+            break;
+        case HalfFloatType:
+            out = new Uint16Array(width * height * 4);
+            break;
+        case UnsignedIntType:
+            out = new Uint32Array(width * height * 4);
+            break;
+        case ByteType:
+            out = new Int8Array(width * height * 4);
+            break;
+        case ShortType:
+            out = new Int16Array(width * height * 4);
+            break;
+        case IntType:
+            out = new Int32Array(width * height * 4);
+            break;
+        case FloatType:
+            out = new Float32Array(width * height * 4);
+            break;
+        default:
+            throw new Error('Unsupported data type');
+    }
+    return out;
+};
+let _canReadPixelsResult;
+/**
+ * Test if this browser implementation can correctly read pixels from the specified
+ * Render target type.
+ *
+ * Runs only once
+ *
+ * @param type
+ * @param renderer
+ * @param camera
+ * @param renderTargetOptions
+ * @returns
+ */
+const canReadPixels = (type, renderer, camera, renderTargetOptions) => {
+    if (_canReadPixelsResult !== undefined)
+        return _canReadPixelsResult;
+    const testRT = new WebGLRenderTarget(1, 1, renderTargetOptions);
+    renderer.setRenderTarget(testRT);
+    const mesh = new Mesh(new PlaneGeometry(), new MeshBasicMaterial({ color: 0xffffff }));
+    renderer.render(mesh, camera);
+    renderer.setRenderTarget(null);
+    const out = getBufferForType(type, testRT.width, testRT.height);
+    renderer.readRenderTargetPixels(testRT, 0, 0, testRT.width, testRT.height, out);
+    testRT.dispose();
+    mesh.geometry.dispose();
+    mesh.material.dispose();
+    _canReadPixelsResult = out[0] !== 0;
+    return _canReadPixelsResult;
+};
+/**
+ * Utility class used for rendering a texture with a material
+ *
+ * @category Core
+ * @group Core
+ */
+class QuadRenderer {
+    _renderer;
+    _rendererIsDisposable = false;
+    _material;
+    _scene;
+    _camera;
+    _quad;
+    _renderTarget;
+    _width;
+    _height;
+    _type;
+    _colorSpace;
+    _supportsReadPixels = true;
+    /**
+     * Constructs a new QuadRenderer
+     *
+     * @param options Parameters for this QuadRenderer
+     */
+    constructor(options) {
+        this._width = options.width;
+        this._height = options.height;
+        this._type = options.type;
+        this._colorSpace = options.colorSpace;
+        const rtOptions = {
+            // fixed options
+            format: RGBAFormat,
+            depthBuffer: false,
+            stencilBuffer: false,
+            // user options
+            type: this._type, // set in class property
+            colorSpace: this._colorSpace, // set in class property
+            anisotropy: options.renderTargetOptions?.anisotropy !== undefined ? options.renderTargetOptions?.anisotropy : 1,
+            generateMipmaps: options.renderTargetOptions?.generateMipmaps !== undefined ? options.renderTargetOptions?.generateMipmaps : false,
+            magFilter: options.renderTargetOptions?.magFilter !== undefined ? options.renderTargetOptions?.magFilter : LinearFilter,
+            minFilter: options.renderTargetOptions?.minFilter !== undefined ? options.renderTargetOptions?.minFilter : LinearFilter,
+            samples: options.renderTargetOptions?.samples !== undefined ? options.renderTargetOptions?.samples : undefined,
+            wrapS: options.renderTargetOptions?.wrapS !== undefined ? options.renderTargetOptions?.wrapS : ClampToEdgeWrapping,
+            wrapT: options.renderTargetOptions?.wrapT !== undefined ? options.renderTargetOptions?.wrapT : ClampToEdgeWrapping
+        };
+        this._material = options.material;
+        if (options.renderer) {
+            this._renderer = options.renderer;
+        }
+        else {
+            this._renderer = QuadRenderer.instantiateRenderer();
+            this._rendererIsDisposable = true;
+        }
+        this._scene = new Scene();
+        this._camera = new OrthographicCamera();
+        this._camera.position.set(0, 0, 10);
+        this._camera.left = -0.5;
+        this._camera.right = 0.5;
+        this._camera.top = 0.5;
+        this._camera.bottom = -0.5;
+        this._camera.updateProjectionMatrix();
+        if (!canReadPixels(this._type, this._renderer, this._camera, rtOptions)) {
+            let alternativeType;
+            switch (this._type) {
+                case HalfFloatType:
+                    alternativeType = this._renderer.extensions.has('EXT_color_buffer_float') ? FloatType : undefined;
+                    break;
+            }
+            if (alternativeType !== undefined) {
+                console.warn(`This browser does not support reading pixels from ${this._type} RenderTargets, switching to ${FloatType}`);
+                this._type = alternativeType;
+            }
+            else {
+                this._supportsReadPixels = false;
+                console.warn('This browser dos not support toArray or toDataTexture, calls to those methods will result in an error thrown');
+            }
+        }
+        this._quad = new Mesh(new PlaneGeometry(), this._material);
+        this._quad.geometry.computeBoundingBox();
+        this._scene.add(this._quad);
+        this._renderTarget = new WebGLRenderTarget(this.width, this.height, rtOptions);
+        this._renderTarget.texture.mapping = options.renderTargetOptions?.mapping !== undefined ? options.renderTargetOptions?.mapping : UVMapping;
+    }
+    /**
+     * Instantiates a temporary renderer
+     *
+     * @returns
+     */
+    static instantiateRenderer() {
+        const renderer = new WebGLRenderer();
+        renderer.setSize(128, 128);
+        // renderer.outputColorSpace = SRGBColorSpace
+        // renderer.toneMapping = LinearToneMapping
+        // renderer.debug.checkShaderErrors = false
+        // this._rendererIsDisposable = true
+        return renderer;
+    }
+    /**
+     * Renders the input texture using the specified material
+     */
+    render = () => {
+        this._renderer.setRenderTarget(this._renderTarget);
+        try {
+            this._renderer.render(this._scene, this._camera);
+        }
+        catch (e) {
+            this._renderer.setRenderTarget(null);
+            throw e;
+        }
+        this._renderer.setRenderTarget(null);
+    };
+    /**
+     * Obtains a Buffer containing the rendered texture.
+     *
+     * @throws Error if the browser cannot read pixels from this RenderTarget type.
+     * @returns a TypedArray containing RGBA values from this renderer
+     */
+    toArray() {
+        if (!this._supportsReadPixels)
+            throw new Error('Can\'t read pixels in this browser');
+        const out = getBufferForType(this._type, this._width, this._height);
+        this._renderer.readRenderTargetPixels(this._renderTarget, 0, 0, this._width, this._height, out);
+        return out;
+    }
+    /**
+     * Performs a readPixel operation in the renderTarget
+     * and returns a DataTexture containing the read data
+     *
+     * @param options options
+     * @returns
+     */
+    toDataTexture(options) {
+        const returnValue = new DataTexture(
+        // fixed values
+        this.toArray(), this.width, this.height, RGBAFormat, this._type, 
+        // user values
+        options?.mapping || UVMapping, options?.wrapS || ClampToEdgeWrapping, options?.wrapT || ClampToEdgeWrapping, options?.magFilter || LinearFilter, options?.minFilter || LinearFilter, options?.anisotropy || 1, 
+        // fixed value
+        LinearSRGBColorSpace);
+        // set this afterwards, we can't set it in constructor
+        returnValue.generateMipmaps = options?.generateMipmaps !== undefined ? options?.generateMipmaps : false;
+        return returnValue;
+    }
+    /**
+     * If using a disposable renderer, it will dispose it.
+     */
+    disposeOnDemandRenderer() {
+        this._renderer.setRenderTarget(null);
+        if (this._rendererIsDisposable) {
+            this._renderer.dispose();
+            this._renderer.forceContextLoss();
+        }
+    }
+    /**
+     * Will dispose of **all** assets used by this renderer.
+     *
+     *
+     * @param disposeRenderTarget will dispose of the renderTarget which will not be usable later
+     * set this to true if you passed the `renderTarget.texture` to a `PMREMGenerator`
+     * or are otherwise done with it.
+     *
+     * @example
+     * ```js
+     * const loader = new HDRJPGLoader(renderer)
+     * const result = await loader.loadAsync('gainmap.jpeg')
+     * const mesh = new Mesh(geometry, new MeshBasicMaterial({ map: result.renderTarget.texture }) )
+     * // DO NOT dispose the renderTarget here,
+     * // it is used directly in the material
+     * result.dispose()
+     * ```
+     *
+     * @example
+     * ```js
+     * const loader = new HDRJPGLoader(renderer)
+     * const pmremGenerator = new PMREMGenerator( renderer );
+     * const result = await loader.loadAsync('gainmap.jpeg')
+     * const envMap = pmremGenerator.fromEquirectangular(result.renderTarget.texture)
+     * const mesh = new Mesh(geometry, new MeshStandardMaterial({ envMap }) )
+     * // renderTarget can be disposed here
+     * // because it was used to generate a PMREM texture
+     * result.dispose(true)
+     * ```
+     */
+    dispose(disposeRenderTarget) {
+        this.disposeOnDemandRenderer();
+        if (disposeRenderTarget) {
+            this.renderTarget.dispose();
+        }
+        // dispose shader material texture uniforms
+        if (this.material instanceof ShaderMaterial) {
+            Object.values(this.material.uniforms).forEach(v => {
+                if (v.value instanceof Texture)
+                    v.value.dispose();
+            });
+        }
+        // dispose other material properties
+        Object.values(this.material).forEach(value => {
+            if (value instanceof Texture)
+                value.dispose();
+        });
+        this.material.dispose();
+        this._quad.geometry.dispose();
+    }
+    /**
+     * Width of the texture
+     */
+    get width() { return this._width; }
+    set width(value) {
+        this._width = value;
+        this._renderTarget.setSize(this._width, this._height);
+    }
+    /**
+     * Height of the texture
+     */
+    get height() { return this._height; }
+    set height(value) {
+        this._height = value;
+        this._renderTarget.setSize(this._width, this._height);
+    }
+    /**
+     * The renderer used
+     */
+    get renderer() { return this._renderer; }
+    /**
+     * The `WebGLRenderTarget` used.
+     */
+    get renderTarget() { return this._renderTarget; }
+    set renderTarget(value) {
+        this._renderTarget = value;
+        this._width = value.width;
+        this._height = value.height;
+        // this._type = value.texture.type
+    }
+    /**
+     * The `Material` used.
+     */
+    get material() { return this._material; }
+    /**
+     *
+     */
+    get type() { return this._type; }
+    get colorSpace() { return this._colorSpace; }
+}
+
+export { QuadRenderer as Q };

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/QuadRenderer-BoQMkXLf.js

@@ -0,0 +1,5 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+import{ClampToEdgeWrapping as e,LinearFilter as r,Scene as t,OrthographicCamera as i,HalfFloatType as s,FloatType as a,Mesh as n,PlaneGeometry as h,WebGLRenderTarget as o,RGBAFormat as d,UVMapping as p,WebGLRenderer as _,DataTexture as g,LinearSRGBColorSpace as l,ShaderMaterial as c,Texture as w,MeshBasicMaterial as m,IntType as T,ShortType as u,ByteType as y,UnsignedIntType as f,UnsignedByteType as O}from"three";const b=(e,r,t)=>{let i;switch(e){case O:i=new Uint8ClampedArray(r*t*4);break;case s:i=new Uint16Array(r*t*4);break;case f:i=new Uint32Array(r*t*4);break;case y:i=new Int8Array(r*t*4);break;case u:i=new Int16Array(r*t*4);break;case T:i=new Int32Array(r*t*4);break;case a:i=new Float32Array(r*t*4);break;default:throw new Error("Unsupported data type")}return i};let v;class R{_renderer;_rendererIsDisposable=!1;_material;_scene;_camera;_quad;_renderTarget;_width;_height;_type;_colorSpace;_supportsReadPixels=!0;constructor(_){this._width=_.width,this._height=_.height,this._type=_.type,this._colorSpace=_.colorSpace;const g={format:d,depthBuffer:!1,stencilBuffer:!1,type:this._type,colorSpace:this._colorSpace,anisotropy:void 0!==_.renderTargetOptions?.anisotropy?_.renderTargetOptions?.anisotropy:1,generateMipmaps:void 0!==_.renderTargetOptions?.generateMipmaps&&_.renderTargetOptions?.generateMipmaps,magFilter:void 0!==_.renderTargetOptions?.magFilter?_.renderTargetOptions?.magFilter:r,minFilter:void 0!==_.renderTargetOptions?.minFilter?_.renderTargetOptions?.minFilter:r,samples:void 0!==_.renderTargetOptions?.samples?_.renderTargetOptions?.samples:void 0,wrapS:void 0!==_.renderTargetOptions?.wrapS?_.renderTargetOptions?.wrapS:e,wrapT:void 0!==_.renderTargetOptions?.wrapT?_.renderTargetOptions?.wrapT:e};if(this._material=_.material,_.renderer?this._renderer=_.renderer:(this._renderer=R.instantiateRenderer(),this._rendererIsDisposable=!0),this._scene=new t,this._camera=new i,this._camera.position.set(0,0,10),this._camera.left=-.5,this._camera.right=.5,this._camera.top=.5,this._camera.bottom=-.5,this._camera.updateProjectionMatrix(),!((e,r,t,i)=>{if(void 0!==v)return v;const s=new o(1,1,i);r.setRenderTarget(s);const a=new n(new h,new m({color:16777215}));r.render(a,t),r.setRenderTarget(null);const d=b(e,s.width,s.height);return r.readRenderTargetPixels(s,0,0,s.width,s.height,d),s.dispose(),a.geometry.dispose(),a.material.dispose(),v=0!==d[0],v})(this._type,this._renderer,this._camera,g)){let e;if(this._type===s)e=this._renderer.extensions.has("EXT_color_buffer_float")?a:void 0;void 0!==e?(console.warn(`This browser does not support reading pixels from ${this._type} RenderTargets, switching to ${a}`),this._type=e):(this._supportsReadPixels=!1,console.warn("This browser dos not support toArray or toDataTexture, calls to those methods will result in an error thrown"))}this._quad=new n(new h,this._material),this._quad.geometry.computeBoundingBox(),this._scene.add(this._quad),this._renderTarget=new o(this.width,this.height,g),this._renderTarget.texture.mapping=void 0!==_.renderTargetOptions?.mapping?_.renderTargetOptions?.mapping:p}static instantiateRenderer(){const e=new _;return e.setSize(128,128),e}render=()=>{this._renderer.setRenderTarget(this._renderTarget);try{this._renderer.render(this._scene,this._camera)}catch(e){throw this._renderer.setRenderTarget(null),e}this._renderer.setRenderTarget(null)};toArray(){if(!this._supportsReadPixels)throw new Error("Can't read pixels in this browser");const e=b(this._type,this._width,this._height);return this._renderer.readRenderTargetPixels(this._renderTarget,0,0,this._width,this._height,e),e}toDataTexture(t){const i=new g(this.toArray(),this.width,this.height,d,this._type,t?.mapping||p,t?.wrapS||e,t?.wrapT||e,t?.magFilter||r,t?.minFilter||r,t?.anisotropy||1,l);return i.generateMipmaps=void 0!==t?.generateMipmaps&&t?.generateMipmaps,i}disposeOnDemandRenderer(){this._renderer.setRenderTarget(null),this._rendererIsDisposable&&(this._renderer.dispose(),this._renderer.forceContextLoss())}dispose(e){this.disposeOnDemandRenderer(),e&&this.renderTarget.dispose(),this.material instanceof c&&Object.values(this.material.uniforms).forEach(e=>{e.value instanceof w&&e.value.dispose()}),Object.values(this.material).forEach(e=>{e instanceof w&&e.dispose()}),this.material.dispose(),this._quad.geometry.dispose()}get width(){return this._width}set width(e){this._width=e,this._renderTarget.setSize(this._width,this._height)}get height(){return this._height}set height(e){this._height=e,this._renderTarget.setSize(this._width,this._height)}get renderer(){return this._renderer}get renderTarget(){return this._renderTarget}set renderTarget(e){this._renderTarget=e,this._width=e.width,this._height=e.height}get material(){return this._material}get type(){return this._type}get colorSpace(){return this._colorSpace}}export{R as Q};

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/_commonjsHelpers-CDmClQiF.js

@@ -0,0 +1,5 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+var e="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};function o(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}export{e as c,o as g};

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/_commonjsHelpers-v3qvwW2J.js

@@ -0,0 +1,12 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { commonjsGlobal as c, getDefaultExportFromCjs as g };

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/compress-C-X439Jm.js

@@ -0,0 +1,92 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+
+/**
+ * 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 || 0.9 });
+    }
+    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 || 0.9);
+        });
+    }
+    /* 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
+    };
+};
+
+export { compress as c };

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/compress-DY-CSunh.js

@@ -0,0 +1,5 @@
+/**
+ * @monogrid/gainmap-js v3.4.0
+ * With ❤️, by MONOGRID <gainmap@monogrid.com>
+ */
+const e=async e=>{if("undefined"==typeof createImageBitmap)throw new Error("createImageBitmap() not supported.");const{source:t,mimeType:a,quality:n,flipY:r}=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 i=await createImageBitmap(o),s=i.width,c=i.height;let f;"undefined"!=typeof OffscreenCanvas?f=new OffscreenCanvas(s,c):(f=document.createElement("canvas"),f.width=s,f.height=c);const m=f.getContext("2d");if(!m)throw new Error("Failed to create canvas Context");!0===r&&(m.translate(0,c),m.scale(1,-1)),m.drawImage(i,0,0,s,c);const w=await(async(e,t,a)=>{if("undefined"!=typeof OffscreenCanvas&&e instanceof OffscreenCanvas)return e.convertToBlob({type:t,quality:a||.9});if(e instanceof HTMLCanvasElement)return new Promise((n,r)=>{e.toBlob(e=>{e?n(e):r(new Error("Failed to convert canvas to blob"))},t,a||.9)});throw new Error("Unsupported canvas element")})(f,a,n||.9);return{data:new Uint8Array(await w.arrayBuffer()),mimeType:a,width:s,height:c}};export{e as c};

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/core/QuadRenderer.d.ts

@@ -0,0 +1,153 @@
+import { ByteType, ColorSpace, DataTexture, FloatType, HalfFloatType, IntType, Material, ShortType, Texture, TextureDataType, UnsignedByteType, UnsignedInt248Type, UnsignedInt5999Type, UnsignedInt101111Type, UnsignedIntType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedShortType, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { QuadRendererTextureOptions, TextureImageFormat } from './types';
+/**
+ * Utility Type that translates `three` texture types to their TypedArray counterparts.
+ *
+ * @category Utility
+ * @group Utility
+ */
+export type TextureDataTypeToBufferType<TType extends TextureDataType> = TType extends typeof UnsignedByteType ? Uint8ClampedArray<ArrayBuffer> : TType extends typeof ByteType ? Int8Array<ArrayBuffer> : TType extends typeof ShortType ? Int16Array<ArrayBuffer> : TType extends typeof UnsignedShortType ? Uint16Array<ArrayBuffer> : TType extends typeof IntType ? Int32Array<ArrayBuffer> : TType extends typeof UnsignedIntType ? Uint32Array<ArrayBuffer> : TType extends typeof FloatType ? Float32Array<ArrayBuffer> : TType extends typeof HalfFloatType ? Uint16Array<ArrayBuffer> : TType extends typeof UnsignedShort4444Type ? Uint16Array<ArrayBuffer> : TType extends typeof UnsignedShort5551Type ? Uint16Array<ArrayBuffer> : TType extends typeof UnsignedInt248Type ? Uint32Array<ArrayBuffer> : TType extends typeof UnsignedInt5999Type ? Uint32Array<ArrayBuffer> : TType extends typeof UnsignedInt101111Type ? Uint32Array<ArrayBuffer> : never;
+export type QuadRendererOptions<TType extends TextureDataType, TMaterial extends Material> = {
+    /**
+     * Width of the render target
+     */
+    width: number;
+    /**
+     * height of the renderTarget
+     */
+    height: number;
+    /**
+     * TextureDataType of the renderTarget
+     */
+    type: TType;
+    /**
+     * ColorSpace of the renderTarget
+     */
+    colorSpace: ColorSpace;
+    /**
+     * material to use for rendering
+     */
+    material: TMaterial;
+    /**
+     * Renderer instance to use
+     */
+    renderer?: WebGLRenderer;
+    /**
+     * Additional renderTarget options
+     */
+    renderTargetOptions?: QuadRendererTextureOptions;
+};
+/**
+ * Utility class used for rendering a texture with a material
+ *
+ * @category Core
+ * @group Core
+ */
+export declare class QuadRenderer<TType extends TextureDataType, TMaterial extends Material> {
+    private _renderer;
+    private _rendererIsDisposable;
+    private _material;
+    private _scene;
+    private _camera;
+    private _quad;
+    private _renderTarget;
+    private _width;
+    private _height;
+    private _type;
+    private _colorSpace;
+    private _supportsReadPixels;
+    /**
+     * Constructs a new QuadRenderer
+     *
+     * @param options Parameters for this QuadRenderer
+     */
+    constructor(options: QuadRendererOptions<TType, TMaterial>);
+    /**
+     * Instantiates a temporary renderer
+     *
+     * @returns
+     */
+    static instantiateRenderer(): WebGLRenderer;
+    /**
+     * Renders the input texture using the specified material
+     */
+    render: () => void;
+    /**
+     * Obtains a Buffer containing the rendered texture.
+     *
+     * @throws Error if the browser cannot read pixels from this RenderTarget type.
+     * @returns a TypedArray containing RGBA values from this renderer
+     */
+    toArray(): TextureDataTypeToBufferType<TType>;
+    /**
+     * Performs a readPixel operation in the renderTarget
+     * and returns a DataTexture containing the read data
+     *
+     * @param options options
+     * @returns
+     */
+    toDataTexture(options?: QuadRendererTextureOptions): DataTexture;
+    /**
+     * If using a disposable renderer, it will dispose it.
+     */
+    disposeOnDemandRenderer(): void;
+    /**
+     * Will dispose of **all** assets used by this renderer.
+     *
+     *
+     * @param disposeRenderTarget will dispose of the renderTarget which will not be usable later
+     * set this to true if you passed the `renderTarget.texture` to a `PMREMGenerator`
+     * or are otherwise done with it.
+     *
+     * @example
+     * ```js
+     * const loader = new HDRJPGLoader(renderer)
+     * const result = await loader.loadAsync('gainmap.jpeg')
+     * const mesh = new Mesh(geometry, new MeshBasicMaterial({ map: result.renderTarget.texture }) )
+     * // DO NOT dispose the renderTarget here,
+     * // it is used directly in the material
+     * result.dispose()
+     * ```
+     *
+     * @example
+     * ```js
+     * const loader = new HDRJPGLoader(renderer)
+     * const pmremGenerator = new PMREMGenerator( renderer );
+     * const result = await loader.loadAsync('gainmap.jpeg')
+     * const envMap = pmremGenerator.fromEquirectangular(result.renderTarget.texture)
+     * const mesh = new Mesh(geometry, new MeshStandardMaterial({ envMap }) )
+     * // renderTarget can be disposed here
+     * // because it was used to generate a PMREM texture
+     * result.dispose(true)
+     * ```
+     */
+    dispose(disposeRenderTarget?: boolean): void;
+    /**
+     * Width of the texture
+     */
+    get width(): number;
+    set width(value: number);
+    /**
+     * Height of the texture
+     */
+    get height(): number;
+    set height(value: number);
+    /**
+     * The renderer used
+     */
+    get renderer(): WebGLRenderer;
+    /**
+     * The `WebGLRenderTarget` used.
+     */
+    get renderTarget(): WebGLRenderTarget<Texture<TextureImageFormat>>;
+    set renderTarget(value: WebGLRenderTarget<Texture<TextureImageFormat>>);
+    /**
+     * The `Material` used.
+     */
+    get material(): TMaterial;
+    /**
+     *
+     */
+    get type(): TType;
+    get colorSpace(): ColorSpace;
+}

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/core/get-data-texture.d.ts

@@ -0,0 +1,14 @@
+import { DataTexture } from 'three';
+import { EXR } from 'three/examples/jsm/loaders/EXRLoader.js';
+import { HDR } from 'three/examples/jsm/loaders/HDRLoader.js';
+import { RGBE } from 'three/examples/jsm/loaders/RGBELoader.js';
+/**
+ * Utility function to obtain a `DataTexture` from various input formats
+ *
+ * @category Utility
+ * @group Utility
+ *
+ * @param image
+ * @returns
+ */
+export declare const getDataTexture: (image: EXR | RGBE | HDR | DataTexture) => DataTexture;

package/staging_area/desktop/car gaem/node_modules/@monogrid/gainmap-js/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './get-data-texture';
+export * from './QuadRenderer';
+export * from './types';