melonjs 20.3.0 → 20.5.0

package/build/loader/parsers/audio.d.ts

@@ -1,31 +1,2 @@
-/**
- * parse/preload an Audio file
- *
- * Unlike the other parsers this one delegates rather than doing the work
- * itself: audio assets are owned by the audio module, which decodes them
- * through its own backend and tracks them for playback. Keeping that
- * delegation here means every asset type is registered the same way — from a
- * parser of the same shape in this directory — and the loader never reaches
- * into the audio module directly, so replacing the audio backend cannot ripple
- * into the loader.
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadAudio(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
-/**
- * unload the given audio asset
- * @param {string} name - asset name
- * @returns {boolean} true if unloaded
- * @ignore
- */
-export function unloadAudio(name: string): boolean;
-/**
- * unload all audio assets
- * @ignore
- */
-export function unloadAllAudio(): void;
+
 //# sourceMappingURL=audio.d.ts.map

package/build/loader/parsers/audio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/audio.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,mCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;GAKG;AACH,kCAJW,MAAM,GACJ,OAAO,CAKnB;AAED;;;GAGG;AACH,uCAEC"}
+{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/audio.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,mCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;GAMG;AACH,kCALW,MAAM,GACJ,OAAO,CAMnB;AAED;;;;GAIG;AACH,uCAEC"}

package/build/loader/parsers/binary.d.ts

@@ -1,11 +1,2 @@
-/**
- * parse/preload a Binary file
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the asset is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadBinary(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=binary.d.ts.map

package/build/loader/parsers/binary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/binary.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,oCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAsBlB"}
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/binary.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,oCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAuBlB"}

package/build/loader/parsers/compressed_textures/compressed_image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compressed_image.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/compressed_image.js"],"names":[],"mappings":"AAmEA,yEAgDC;;;;;UA1Ga,UAAU;;;;WACV,MAAM;;;;YACN,MAAM;;;;;;;;;aAMN,sBAAsB,EAAE;;;;WACxB,MAAM;;;;YACN,MAAM;;;;YACN,MAAM;;;;gBACN,OAAO;;;;oBACP,OAAO"}
+{"version":3,"file":"compressed_image.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/compressed_image.js"],"names":[],"mappings":"AAwEA,yEAgDC;;;;;UA/Ga,UAAU;;;;WACV,MAAM;;;;YACN,MAAM;;;;;;;;;aAMN,sBAAsB,EAAE;;;;WACxB,MAAM;;;;YACN,MAAM;;;;YACN,MAAM;;;;gBACN,OAAO;;;;oBACP,OAAO"}

package/build/loader/parsers/compressed_textures/parseDDS.d.ts

@@ -1,8 +1,2 @@
-/**
- * Parse a DDS compressed texture file.
- * @param {ArrayBuffer} data - the DDS file data
- * @returns {CompressedImage} a compressed texture object with mipmaps, width, height, format
- * @ignore
- */
-export function parseDDS(data: ArrayBuffer): CompressedImage;
+
 //# sourceMappingURL=parseDDS.d.ts.map

package/build/loader/parsers/compressed_textures/parseDDS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseDDS.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseDDS.js"],"names":[],"mappings":"AAsCA;;;;;GAKG;AACH,+BAJW,WAAW,GACT,eAAe,CAoE3B"}
+{"version":3,"file":"parseDDS.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseDDS.js"],"names":[],"mappings":"AAsCA;;;;;;GAMG;AACH,+BALW,WAAW,GACT,eAAe,CAqE3B"}

package/build/loader/parsers/compressed_textures/parseKTX.d.ts

@@ -1,8 +1,2 @@
-/**
- * Parse a KTX v1 compressed texture file.
- * @param {ArrayBuffer} data - the KTX file data
- * @returns {CompressedImage} a compressed texture object with mipmaps, width, height, format
- * @ignore
- */
-export function parseKTX(data: ArrayBuffer): CompressedImage;
+
 //# sourceMappingURL=parseKTX.d.ts.map

package/build/loader/parsers/compressed_textures/parseKTX.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseKTX.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseKTX.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,+BAJW,WAAW,GACT,eAAe,CA+E3B"}
+{"version":3,"file":"parseKTX.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseKTX.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,+BALW,WAAW,GACT,eAAe,CAgF3B"}

package/build/loader/parsers/compressed_textures/parseKTX2.d.ts

@@ -1,8 +1,2 @@
-/**
- * Parse a KTX v2 compressed texture file.
- * @param {ArrayBuffer} data - the KTX2 file data
- * @returns {CompressedImage} a compressed texture object with mipmaps, width, height, format
- * @ignore
- */
-export function parseKTX2(data: ArrayBuffer): CompressedImage;
+
 //# sourceMappingURL=parseKTX2.d.ts.map

package/build/loader/parsers/compressed_textures/parseKTX2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseKTX2.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseKTX2.js"],"names":[],"mappings":"AAsEA;;;;;GAKG;AACH,gCAJW,WAAW,GACT,eAAe,CA0E3B"}
+{"version":3,"file":"parseKTX2.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parseKTX2.js"],"names":[],"mappings":"AAsEA;;;;;;GAMG;AACH,gCALW,WAAW,GACT,eAAe,CA2E3B"}

package/build/loader/parsers/compressed_textures/parsePKM.d.ts

@@ -1,8 +1,2 @@
-/**
- * Parse a PKM compressed texture file.
- * @param {ArrayBuffer} data - the raw PKM file data
- * @returns {CompressedImage} a compressed texture object
- * @ignore
- */
-export function parsePKM(data: ArrayBuffer): CompressedImage;
+
 //# sourceMappingURL=parsePKM.d.ts.map

package/build/loader/parsers/compressed_textures/parsePKM.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parsePKM.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parsePKM.js"],"names":[],"mappings":"AA0CA;;;;;GAKG;AACH,+BAJW,WAAW,GACT,eAAe,CAiD3B"}
+{"version":3,"file":"parsePKM.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parsePKM.js"],"names":[],"mappings":"AA0CA;;;;;;GAMG;AACH,+BALW,WAAW,GACT,eAAe,CAkD3B"}

package/build/loader/parsers/compressed_textures/parsePVR.d.ts

@@ -1,8 +1,2 @@
-/**
- * parse a PVR v3 compressed texture file
- * @param {ArrayBuffer} data - the PVR file data
- * @returns {CompressedImage} a compressed texture object with mipmaps, width, height, format
- * @ignore
- */
-export function parsePVR(data: ArrayBuffer): CompressedImage;
+
 //# sourceMappingURL=parsePVR.d.ts.map

package/build/loader/parsers/compressed_textures/parsePVR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parsePVR.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parsePVR.js"],"names":[],"mappings":"AAmEA;;;;;GAKG;AACH,+BAJW,WAAW,GACT,eAAe,CAqD3B"}
+{"version":3,"file":"parsePVR.d.ts","sourceRoot":"","sources":["../../../../src/loader/parsers/compressed_textures/parsePVR.js"],"names":[],"mappings":"AAmEA;;;;;;GAMG;AACH,+BALW,WAAW,GACT,eAAe,CAsD3B"}

package/build/loader/parsers/fontface.d.ts

@@ -1,14 +1,2 @@
-/**
- * parse/preload a font face
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the asset is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- * @example
- * preloadFontFace([
- *     { name: "'kenpixel'", type: "fontface", src: "data/font/kenvector_future.woff2" }
- * ]);
- */
-export function preloadFontFace(data: loader.Asset, onload?: Function, onerror?: Function): number;
+
 //# sourceMappingURL=fontface.d.ts.map

package/build/loader/parsers/fontface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fontface.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/fontface.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,sCAVW,MAAM,CAAC,KAAK,0CAGV,MAAM,CA+DlB"}
+{"version":3,"file":"fontface.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/fontface.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,sCAXW,MAAM,CAAC,KAAK,0CAGV,MAAM,CAgElB"}

package/build/loader/parsers/gltf.d.ts

@@ -1,71 +1,2 @@
-/**
- * Split a GLB binary container into its JSON description and binary buffer.
- * @param {ArrayBuffer} arrayBuffer
- * @returns {{ json: object, bin: Uint8Array | null }}
- * @ignore
- */
-export function parseGLB(arrayBuffer: ArrayBuffer): {
-    json: object;
-    bin: Uint8Array | null;
-};
-/**
- * Read an accessor into a flat TypedArray (stride-aware, non-interleaved
- * fast-path covered as a subset).
- * @ignore
- */
-export function readAccessor(json: any, buffers: any, accessorIndex: any): any;
-/**
- * Compose a column-major 4x4 local matrix from translation / rotation
- * (quaternion) / scale arrays — the glTF TRS convention — writing into `out`.
- * In-place so the per-frame animation pose path allocates nothing.
- * @param {number[]} out - 16-element destination (returned)
- * @param {number[]} translation - [tx, ty, tz]
- * @param {number[]} rotation - quaternion [qx, qy, qz, qw]
- * @param {number[]} scale - [sx, sy, sz]
- * @returns {number[]} `out`
- * @ignore
- */
-export function composeTRSInto(out: number[], translation: number[], rotation: number[], scale: number[]): number[];
-/**
- * Allocating form of {@link composeTRSInto} — returns a fresh 16-element array.
- * @param {number[]} translation - [tx, ty, tz]
- * @param {number[]} rotation - quaternion [qx, qy, qz, qw]
- * @param {number[]} scale - [sx, sy, sz]
- * @returns {number[]} 16-element column-major matrix
- * @ignore
- */
-export function composeTRS(translation: number[], rotation: number[], scale: number[]): number[];
-/** Compose a node's local matrix from its `matrix` or TRS fields. @ignore */
-export function nodeLocalMatrix(node: any): any;
-/**
- * Column-major 4x4 multiply `a * b`, writing into `out`. `out` must NOT alias
- * `a` or `b` (results are written as they're computed). In-place so the
- * per-frame pose path allocates nothing.
- * @ignore
- */
-export function multiplyMatrixInto(out: any, a: any, b: any): any;
-/** Allocating form of {@link multiplyMatrixInto}: `a * b` → fresh array. @ignore */
-export function multiplyMatrix(a: any, b: any): any;
-/**
- * Parse a glTF/GLB ArrayBuffer into a flat, instantiable scene descriptor.
- * @param {ArrayBuffer} arrayBuffer - the .glb / .gltf bytes
- * @param {string} [baseURI] - the asset's own URL, used to resolve external
- * `.bin` buffers and image files referenced by relative `uri`. Omit for a fully
- * self-contained GLB (embedded buffers + data-URI / bufferView images).
- * @param {object} [settings] - loader settings forwarded to `fetchData` for
- * external resources (crossOrigin / withCredentials / nocache).
- * @returns {Promise<object>} `{ nodes, cameras, lights, bounds, graph, animations }`
- * @ignore
- */
-export function parseGLTF(arrayBuffer: ArrayBuffer, baseURI?: string, settings?: object): Promise<object>;
-/**
- * parse/preload a glTF/GLB file
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadGLTF(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=gltf.d.ts.map

package/build/loader/parsers/gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/gltf.js"],"names":[],"mappings":"AA0CA;;;;;GAKG;AACH,sCAJW,WAAW,GACT;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE,CAkCpD;AAmED;;;;GAIG;AACH,+EAgCC;AA0KD;;;;;;;;;;GAUG;AACH,oCAPW,MAAM,EAAE,eACR,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAoCpB;AAED;;;;;;;GAOG;AACH,wCANW,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAKpB;AAED,6EAA6E;AAC7E,gDASC;AAiED;;;;;GAKG;AACH,kEAWC;AAED,oFAAoF;AACpF,oDAEC;AA8HD;;;;;;;;;;GAUG;AACH,uCATW,WAAW,YACX,MAAM,aAGN,MAAM,GAEJ,OAAO,CAAC,MAAM,CAAC,CAqa3B;AAED;;;;;;;;GAQG;AACH,kCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA6BlB"}
+{"version":3,"file":"gltf.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/gltf.js"],"names":[],"mappings":"AA2CA;;;;;;GAMG;AACH,sCALW,WAAW,GACT;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE,CAmCpD;AAsED;;;;;GAKG;AACH,+EAgCC;AA8KD;;;;;;;;;;;GAWG;AACH,oCARW,MAAM,EAAE,eACR,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAqCpB;AAED;;;;;;;;GAQG;AACH,wCAPW,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAMpB;AAED;;;;GAIG;AACH,gDASC;AAsED;;;;;;GAMG;AACH,kEAWC;AAED;;;;GAIG;AACH,oDAEC;AAmID;;;;;;;;;;;GAWG;AACH,uCAVW,WAAW,YACX,MAAM,aAGN,MAAM,GAEJ,OAAO,CAAC,MAAM,CAAC,CAsa3B;AAED;;;;;;;;;GASG;AACH,kCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA8BlB"}

package/build/loader/parsers/image.d.ts

@@ -1,23 +1,2 @@
-/**
- * parse/preload an image
- * @param {loader.Asset} img
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- * @example
- * preloadImages([
- *     { name : 'image1', src : 'images/image1.png'},
- *     { name : 'image2', src : 'images/image2.png'},
- *     { name : 'image3', src : 'images/image3.png'},
- *     // compressed texture with fallback chain
- *     { name : 'image4', src : [
- *         'images/image4.astc.ktx',  // try ASTC first
- *         'images/image4.dds',       // then S3TC via DDS
- *         'images/image4.png'        // fallback to PNG
- *     ]}
- * ]);
- */
-export function preloadImage(img: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=image.d.ts.map

package/build/loader/parsers/image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/image.js"],"names":[],"mappings":"AAuDA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,kCAnBW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA4ClB"}
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/image.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,kCApBW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA6ClB"}

package/build/loader/parsers/json.d.ts

@@ -1,11 +1,2 @@
-/**
- * parse/preload a JSON files
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadJSON(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=json.d.ts.map

package/build/loader/parsers/json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/json.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,kCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAwBlB"}
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/json.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,kCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAyBlB"}

package/build/loader/parsers/mtl.d.ts

@@ -1,29 +1,2 @@
-/**
- * Parse a Wavefront MTL file into material data.
- * Supports: `newmtl`, `Kd` (diffuse color), `Ke` (emissive color), `Ks`/`Ns`
- * (specular color and exponent), `Pr`/`Pm` (the PBR roughness/metalness
- * extension, approximated onto the specular terms when `Ks`/`Ns` are absent),
- * `map_Kd` (diffuse texture), `map_d` (alpha map), `d`/`Tr`
- * (opacity/transparency).
- *
- * Limitations:
- * - Ambient (`Ka`), optical density (`Ni`) and illumination model (`illum`) are parsed but ignored
- * - Normal maps (`map_bump`, `bump`), specular maps (`map_Ks`), and other texture maps are not supported
- *
- * @param {string} text - raw MTL file contents
- * @param {string} basePath - base URL path for resolving texture references
- * @returns {object} map of material names to their properties
- * @ignore
- */
-export function parseMTL(text: string, basePath: string): object;
-/**
- * Parse/preload a Wavefront MTL material file.
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadMTL(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=mtl.d.ts.map

package/build/loader/parsers/mtl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mtl.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/mtl.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;GAgBG;AACH,+BALW,MAAM,YACN,MAAM,GACJ,MAAM,CAkJlB;AAED;;;;;;;;GAQG;AACH,iCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAwElB"}
+{"version":3,"file":"mtl.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/mtl.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;;GAiBG;AACH,+BANW,MAAM,YACN,MAAM,GACJ,MAAM,CAmJlB;AAED;;;;;;;;;GASG;AACH,iCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAyElB"}

package/build/loader/parsers/obj.d.ts

@@ -1,60 +1,2 @@
-/**
- * Parse a Wavefront OBJ file into geometry data.
- * Supports: `v` (vertex positions), `vt` (texture coordinates),
- * `f` (faces in `v`, `v/vt`, `v/vt/vn`, or `v//vn` format),
- * `mtllib` (material library reference),
- * `usemtl` (material group boundaries — emitted as `groups[]`).
- *
- * Features:
- * - Quad and n-gon triangulation (fan from first vertex)
- * - Automatic CW → CCW winding correction via signed volume test
- * - V texture coordinate flipped for OpenGL convention (OBJ has origin at bottom-left)
- * - Single-pass parsing with direct vertex unification (no intermediate arrays)
- * - Material grouping: each `usemtl` switch emits a new `groups[]` entry
- *   pointing to a slice of the unified `indices` buffer, so callers
- *   (e.g. `Mesh`) can render each group with its own material without
- *   touching the geometry. A model with no `usemtl` directives produces
- *   a single group with `materialName: null`.
- *
- * `vn` (vertex normals) are consumed: a face referencing them
- * (`v//vn` or `v/vt/vn`) produces unified vertices carrying the authored
- * normal, so an OBJ model lights under `Light3d` exactly as the same model
- * imported from glTF does. Every vertex WITHOUT a usable authored normal
- * gets one GENERATED from face geometry — angle-weighted, accumulated per
- * source position and normalized, i.e. smooth across UV and material seams
- * — after the winding correction below, so the result follows the final
- * triangle orientation rather than the authored one. That rule is
- * per-vertex, so a file mixing normalled and un-normalled faces, or one
- * carrying an out-of-range `vn`, still comes out fully normalled.
- *
- * Parsed but ignored: `g` (groups), `s` (smooth shading — generated normals
- * are smooth across the whole mesh, so a model relying on hard edges from
- * smoothing groups will read softer than authored),
- * `o` (object name).
- *
- * @param {string} text - raw OBJ file contents
- * @returns {object} parsed geometry with `vertices` (Float32Array),
- *   `uvs` (Float32Array), `normals` (Float32Array), `indices`
- *   (Uint16Array, widening to Uint32Array past 65 536 vertices),
- *   `vertexCount` (number),
- *   `mtllib` (string|null), and `groups`
- *   (Array<{materialName: string|null, start: number, count: number}>).
- *   `groups` follows the glTF convention — each entry is a
- *   contiguous slice of the shared `indices` buffer that draws as one
- *   submesh against a single material. Single-material models still
- *   produce a `groups` array of length 1, so consumers don't need a
- *   special case.
- * @ignore
- */
-export function parseOBJ(text: string): object;
-/**
- * parse/preload a Wavefront OBJ file
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadOBJ(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=obj.d.ts.map

package/build/loader/parsers/obj.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"obj.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/obj.js"],"names":[],"mappings":"AAqEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,+BAdW,MAAM,GACJ,MAAM,CAkZlB;AAED;;;;;;;;GAQG;AACH,iCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAuBlB"}
+{"version":3,"file":"obj.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/obj.js"],"names":[],"mappings":"AAuEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,+BAfW,MAAM,GACJ,MAAM,CAqZlB;AAED;;;;;;;;;GASG;AACH,iCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAwBlB"}

package/build/loader/parsers/pbr.d.ts

@@ -1,63 +1,2 @@
-/**
- * Mapping authored metallic/roughness onto the lit mesh path's Blinn-Phong
- * terms (#1575).
- *
- * Two formats describe the same material concept — glTF's
- * `pbrMetallicRoughness` and MTL's `Pr` / `Pm` extension, both of which
- * Blender writes by default — and both land here so the two cannot drift
- * apart. What they land ON is a stylized half-Lambert shading model, not a
- * microfacet BRDF, so this is deliberately an APPROXIMATION: the point is to
- * recover the "is this surface glossy, and what colour does it glint"
- * information the asset already carries, rather than to be energy-correct.
- *
- * An explicitly authored specular (`Ks` + `Ns`) always wins over this — it
- * says exactly what the artist wanted, where metallic/roughness only implies
- * it.
- * @ignore
- */
-/**
- * The exponent a mirror-smooth surface is clamped to. The Blinn-Phong
- * exponent runs away as roughness approaches 0, and a highlight narrower
- * than a pixel only aliases.
- * @ignore
- */
-export declare const MAX_SHININESS = 256;
-/**
- * The specular reflectance of a non-metal, the standard value used by every
- * metallic/roughness workflow. Metals reflect their own base colour instead.
- * @ignore
- */
-export declare const DIELECTRIC_F0 = 0.04;
-/**
- * The result of the mapping: a specular colour and exponent ready to hand to
- * a {@link Mesh}, or `undefined` / `0` when the material implies no
- * highlight at all.
- * @ignore
- */
-export interface SpecularTerms {
-    /** specular colour `[r, g, b]`, or `undefined` for none */
-    specular: number[] | undefined;
-    /** specular exponent; `0` disables the term outright */
-    shininess: number;
-}
-/**
- * Map a metallic/roughness pair onto a Blinn-Phong specular colour and
- * exponent.
- *
- * - **roughness → exponent** through the usual Blinn-Phong/GGX bridge,
- *   `2 / a^4 - 2` for `a = roughness^2`. A roughness of 1 — which is the
- *   glTF default, and what a matte material declares — lands on exactly 0,
- *   so a material that says nothing gets no highlight and shades exactly as
- *   it did before this existed.
- * - **metallic → tint**, interpolating from the dielectric reflectance to
- *   the material's own base colour. Chrome glints in its own hue while
- *   plaster gets a faint neutral sheen, which is the visible half of the
- *   metal/non-metal distinction.
- * @param roughness - authored roughness (0..1); absent or malformed reads as 1
- * @param metallic - authored metalness (0..1); absent or malformed reads as 1
- * @param baseColor - the material's base colour, `[r, g, b, a?]`
- * @returns the specular terms, inert when the material implies no highlight
- * @ignore
- */
-export declare function specularFromMetallicRoughness(roughness: unknown, metallic: unknown, baseColor?: number[]): SpecularTerms;
+
 //# sourceMappingURL=pbr.d.ts.map

package/build/loader/parsers/pbr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pbr.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/pbr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,MAAM,CAAC;AAEjC;;;;GAIG;AACH,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC7B,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC/B,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;CAClB;AAgBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAC5C,SAAS,EAAE,OAAO,EAClB,QAAQ,EAAE,OAAO,EACjB,SAAS,GAAE,MAAM,EAAiB,GAChC,aAAa,CAaf"}
+{"version":3,"file":"pbr.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/pbr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG"}

package/build/loader/parsers/script.d.ts

@@ -1,11 +1,2 @@
-/**
- * parse/preload a Javascript files
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadJavascript(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=script.d.ts.map

package/build/loader/parsers/script.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"script.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/script.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA8BlB"}
+{"version":3,"file":"script.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/script.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA+BlB"}

package/build/loader/parsers/shader.d.ts

@@ -1,55 +1,4 @@
-/**
- * compile a shader asset's source into its shared, loader-owned instance:
- * a fragment body (the `apply()` convention) compiles into a
- * {@link ShaderEffect}; a complete program — a `{vertex, fragment}` GLSL
- * pair and/or a `wgsl` full module, either omittable — compiles into a
- * {@link GLShader} carrying whichever realizations were declared, for the
- * hosted paths that take one (a `Mesh` custom shader,
- * `renderer.customShader`, a custom batcher). The active renderer hosts
- * the realization it speaks; a shader without one for this backend is
- * inert — assigning it degrades to built-in shading, never fails.
- * @param {string|object} source - the fragment body (or `{glsl, wgsl}`
- * bodies), or a complete program: `{vertex, fragment, wgsl?, precision?}`
- * @returns {ShaderEffect|GLShader} the compiled asset, flagged `shared`
- * @throws if called before any `app.init()` resolved (no renderer to compile against)
- * @ignore
- */
-export function compileShaderAsset(source: string | object): ShaderEffect | GLShader;
-/**
- * parse/preload a shader asset, from a `src` URL (or data: URI) or inline
- * source via the `data` field. Three source shapes are accepted:
- *
- * - a GLSL **fragment body** following the ShaderEffect convention (uniform
- *   declarations + `vec4 apply(vec4, vec2)`) → compiles into a shared
- *   {@link ShaderEffect};
- * - a **dual-language body** — `src: {glsl: url, wgsl: url}` or
- *   `data: {glsl: source, wgsl: source}`, either language omittable — →
- *   a shared {@link ShaderEffect} carrying one body per shading language;
- *   the renderer compiles the matching one, and when none matches the
- *   preload still succeeds with an inert (`enabled === false`) effect;
- * - a complete **program** — `src: {vertex: url, fragment: url}` (GLSL
- *   pair), `src: {wgsl: url}` where the WGSL declares its own `@vertex`
- *   entry point (a complete module), or both together for a dual-backend
- *   asset — → compiles into a shared raw {@link GLShader} carrying the
- *   declared realizations (`isWebGL` / `isWebGPU`), for the hosted paths
- *   that take one (a `Mesh` custom shader, `renderer.customShader`, a
- *   custom batcher); the active renderer hosts the realization it speaks
- *   and a missing one degrades to built-in shading.
- *
- * Always compiled AT LOAD TIME, so the GLSL compile cost lands in the
- * loading screen and compile errors carry the asset name. An initialized
- * Application (`await app.init()`) is an inherent precondition of the
- * preload flow (the loading screen itself needs the renderer, and a failed
- * init rejects and halts) — loading a shader without it fails with a clear
- * error.
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadShader(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 import ShaderEffect from "../../video/effects/shadereffect.js";
 import GLShader from "../../video/webgl/glshader.js";
 //# sourceMappingURL=shader.d.ts.map

package/build/loader/parsers/shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/shader.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;GAeG;AACH,2CANW,MAAM,GAAC,MAAM,GAEX,YAAY,GAAC,QAAQ,CAqDjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAgHlB;yBA7OwB,qCAAqC;qBACzC,+BAA+B"}
+{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/shader.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAPW,MAAM,GAAC,MAAM,GAEX,YAAY,GAAC,QAAQ,CAsDjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,oCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAiHlB;yBAnPwB,qCAAqC;qBACzC,+BAA+B"}

package/build/loader/parsers/tmx.d.ts

@@ -1,11 +1,2 @@
-/**
- * parse/preload a TMX file
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the asset is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadTMX(tmxData: any, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=tmx.d.ts.map

package/build/loader/parsers/tmx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tmx.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/tmx.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,2FAJW,MAAM,GACJ,MAAM,CAkFlB"}
+{"version":3,"file":"tmx.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/tmx.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,2FALW,MAAM,GACJ,MAAM,CAoFlB"}

package/build/loader/parsers/video.d.ts

@@ -1,11 +1,2 @@
-/**
- * parse/preload a Video file
- * @param {loader.Asset} data - asset data
- * @param {Function} [onload] - function to be called when the resource is loaded
- * @param {Function} [onerror] - function to be called in case of error
- * @param {Object} [settings] - Additional settings to be passed when loading the asset
- * @returns {number} the amount of corresponding resource parsed/preloaded
- * @ignore
- */
-export function preloadVideo(data: loader.Asset, onload?: Function, onerror?: Function, settings?: Object): number;
+
 //# sourceMappingURL=video.d.ts.map

package/build/loader/parsers/video.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/video.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,mCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAkGlB"}
+{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/video.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,mCARW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAmGlB"}

package/build/math/color.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/math/color.ts"],"names":[],"mappings":"AA+MA;;;GAGG;AACH,qBAAa,KAAK;IACjB,OAAO,CAAC,cAAc,CAAe;IAErC;;;;;;OAMG;gBACS,CAAC,GAAE,KAAK,GAAG,MAAM,GAAG,MAAU,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,KAAK,SAAM;IAcrE;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,KAAK,WAER;IAED;;;OAGG;IACH,IAAI,KAAK,CAAC,KAAK,QAAA,EAEd;IAED;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,KAAK,SAAM;IASjE;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,SAAM;IASrD;;;;;;OAMG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IA8CtC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAmBtC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAY5C;;;OAGG;IACH,KAAK;IAIL;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAS1B;;;;OAIG;IACH,GAAG,CAAC,KAAK,EAAE,KAAK;IAsBhB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IASpB;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM;IAYhC;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM;IAqBrB;;;;;OAKG;IACH,MAAM,CAAC,GAAG,SAAI,EAAE,GAAG,SAAM;IAgBzB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK;IASnB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAQzB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAazB;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,IAAI,MAAM,EAAE,EAAE,IAAI,UAAQ;IAmD7C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,SAAM;IAUpB;;;OAGG;IACH,OAAO;IAIP;;;OAGG;IACH,KAAK;IAKL;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAyB;IAKrC;;;OAGG;IACH,KAAK;IAIL;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAa;CAGzB;AAED,eAAO,MAAM,SAAS,gKAwBpB,CAAC"}
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/math/color.ts"],"names":[],"mappings":"AA+MA;;;GAGG;AACH,qBAAa,KAAK;IACjB,OAAO,CAAC,cAAc,CAAe;IAErC;;;;;;OAMG;gBACS,CAAC,GAAE,KAAK,GAAG,MAAM,GAAG,MAAU,EAAE,CAAC,SAAI,EAAE,CAAC,SAAI,EAAE,KAAK,SAAM;IAcrE;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,CAAC,KAAK,QAAA,EAEV;IAED;;;OAGG;IACH,IAAI,KAAK,WAER;IAED;;;OAGG;IACH,IAAI,KAAK,CAAC,KAAK,QAAA,EAEd;IAED;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,KAAK,SAAM;IASjE;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,SAAM;IASrD;;;;;;OAMG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IA8CtC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAmBtC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAY5C;;;OAGG;IACH,KAAK;IAIL;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAS1B;;;;OAIG;IACH,GAAG,CAAC,KAAK,EAAE,KAAK;IAsBhB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IASpB;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM;IAYhC;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM;IAqBrB;;;;;OAKG;IACH,MAAM,CAAC,GAAG,SAAI,EAAE,GAAG,SAAM;IAgBzB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK;IASnB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAQzB;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAazB;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,IAAI,MAAM,EAAE,EAAE,IAAI,UAAQ;IAmD7C;;;;OAIG;IACH,QAAQ,CAAC,KAAK,SAAM;IAgBpB;;;OAGG;IACH,OAAO;IAIP;;;OAGG;IACH,KAAK;IAKL;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAyB;IAKrC;;;OAGG;IACH,KAAK;IAIL;;;;OAIG;IACH,MAAM,CAAC,KAAK,SAAa;CAGzB;AAED,eAAO,MAAM,SAAS,gKAwBpB,CAAC"}