melonjs 20.12.0 → 20.14.0

package/build/loader/cache.d.ts

@@ -1,64 +1,92 @@
 
 /**
- * return the specified TMX/TSX object
- * @param {string} elt - name of the tmx/tsx element ("map1");
- * @returns {object} requested element or null if not found
+ * Get a loaded Tiled map or tileset (a `"tmx"` or `"tsx"` asset) as parsed
+ * data: the map's JSON structure, whether it was loaded from XML or JSON.
+ * Most code never needs it: `level.load(name)` builds the level from it.
+ * @param {string} elt - the asset name
+ * @returns {object} the parsed map or tileset, or `null` if none is loaded
+ * under that name
+ * @example
+ * const map = loader.getTMX("map1");
+ * console.log(map.width, map.height, map.layers.length);
  * @category Assets
  */
 export function getTMX(elt: string): object;
 /**
- * return the specified Binary object
- * @param {string} elt - name of the binary object ("ymTrack");
- * @returns {object} requested element or null if not found
+ * Get the content of a loaded `"binary"` asset, decoded as UTF-8 text: what
+ * a bitmap font's `.fnt` descriptor, for one, is loaded as.
+ * @param {string} elt - the asset name
+ * @returns {object} the file's content, as a string, or `null` if none is
+ * loaded under that name
+ * @example
+ * // a bitmap font: its image, and its descriptor as "binary"
+ * await loader.preload([
+ *     { name: "PressStart2P", type: "image",  src: "data/fnt/PressStart2P.png" },
+ *     { name: "PressStart2P", type: "binary", src: "data/fnt/PressStart2P.fnt" },
+ * ]);
+ * const fnt = loader.getBinary("PressStart2P");
  * @category Assets
  */
 export function getBinary(elt: string): object;
 /**
- * return the specified Image Object
- * @param {string} image - name of the Image element ("tileset-platformer");
- * @returns {HTMLImageElement|CompressedImage|null} requested element or null if not found
+ * Get a loaded image (an `"image"` asset, or the image of an `"aseprite"`
+ * one). Given a path, its directory and extension are ignored, so
+ * `getImage("data/img/player.png")` finds the image named `"player"`.
+ * Most engine classes take the name instead, and look it up themselves:
+ * `new Sprite(0, 0, { image: "player" })`.
+ * @param {string} image - the asset name
+ * @returns {HTMLImageElement|CompressedImage|null} the image, or `null` if
+ * none is loaded under that name
+ * @example
+ * const player = loader.getImage("player");
+ * console.log(player.width, player.height);
  * @category Assets
  */
 export function getImage(image: string): HTMLImageElement | CompressedImage | null;
 /**
- * return the specified JSON Object
- * @param {string} elt - name of the json file
- * @returns {JSON}
+ * Get a loaded JSON file (a `"json"` asset, or the descriptor of an
+ * `"aseprite"` one), parsed.
+ * @param {string} elt - the asset name
+ * @returns {JSON} the parsed content, or `null` if none is loaded under that
+ * name
+ * @example
+ * // a texture atlas: its image and its JSON descriptor share a name
+ * const atlas = new TextureAtlas(loader.getJSON("texture"), loader.getImage("texture"));
  * @category Assets
  */
 export function getJSON(elt: string): JSON;
 /**
- * return the specified OBJ model data
- * @param {string} elt - name of the OBJ file (as specified in the preload list)
- * @returns {object} parsed OBJ data with `vertices` (Float32Array), `uvs` (Float32Array), `indices` (Uint16Array), and `vertexCount` (number), or null if not found
+ * Get a loaded Wavefront OBJ model (an `"obj"` asset), parsed. Most code
+ * never needs it: a `Mesh` takes the model's name.
+ * @param {string} elt - the asset name
+ * @returns {object} the parsed model: `vertices` (Float32Array of x, y, z),
+ * `uvs` (Float32Array of u, v), `indices` (Uint16Array of triangle vertex
+ * indices), `vertexCount`, and `groups` (the `usemtl` material groups, as
+ * `{materialName, start, count}` index ranges); or `null` if none is loaded
+ * under that name
  * @category Assets
  * @example
  * // 1. preload the OBJ model and its texture
- * me.loader.preload([
- *     { name: "cube", type: "obj", src: "models/cube.obj" },
+ * await loader.preload([
+ *     { name: "cube", type: "obj",   src: "models/cube.obj" },
  *     { name: "cube", type: "image", src: "models/cube_texture.png" },
- * ], () => {
- *     // 2. create a Mesh using the preloaded model name
- *     const mesh = new me.Mesh(400, 300, {
- *         model: "cube",        // references the preloaded OBJ
- *         texture: "cube",      // references the preloaded image
- *         width: 200,
- *         height: 200,
- *     });
- *     me.game.world.addChild(mesh);
+ * ]);
  *
- *     // 3. or access the raw parsed data directly
- *     const data = me.loader.getOBJ("cube");
- *     // data.vertices — Float32Array of x,y,z positions
- *     // data.uvs — Float32Array of u,v texture coordinates
- *     // data.indices — Uint16Array of triangle vertex indices
- *     // data.vertexCount — number of unique vertices
- *     // data.groups — usemtl material groups ({materialName, start, count} index ranges)
+ * // 2. a Mesh takes the model and the texture by name
+ * const mesh = new Mesh(400, 300, {
+ *     model: "cube",
+ *     texture: "cube",
+ *     width: 200,
+ *     height: 200,
  * });
+ * app.world.addChild(mesh);
+ *
+ * // 3. or read the parsed data directly
+ * const { vertices, uvs, indices, vertexCount } = loader.getOBJ("cube");
  */
 export function getOBJ(elt: string): object;
 /**
- * return the parsed glTF/GLB scene descriptor for the given asset name.
+ * Get a loaded glTF/GLB scene (a `"gltf"` or `"glb"` asset), parsed.
  *
  * The descriptor is `{ nodes, cameras, lights, bounds, graph, animations }`:
  * - `nodes` — one entry per mesh primitive, each carrying its accumulated
@@ -74,32 +102,30 @@ export function getOBJ(elt: string): object;
  *   automatically (see {@link level.load} options).
  * - `bounds` — world-space `{ min, max }` (glTF units), handy for framing.
  *
- * Most code never needs this: a preloaded glTF/GLB auto-registers with the
+ * Most code never needs this: a loaded glTF/GLB registers with the
  * {@link level} director, so the whole scene loads into a container in one
- * call via `me.level.load(name)` — exactly like a Tiled map. Reach for
- * `getGLTF` only when you want to inspect the raw descriptor (e.g. to frame
- * a `Camera3d` from the embedded camera).
- * @param {string} elt - name of the glTF/GLB file (as specified in the preload list)
- * @returns {GLTFData|null} the parsed scene descriptor, or `null` if not found
+ * call, `level.load(name)`, exactly like a Tiled map. Reach for `getGLTF`
+ * only to inspect the raw descriptor (to frame a `Camera3d` from the
+ * embedded camera, say).
+ * @param {string} elt - the asset name
+ * @returns {GLTFData|null} the parsed scene descriptor, or `null` if none is
+ * loaded under that name
  * @category Assets
  * @example
- * me.loader.preload(
- *     [{ name: "diorama", type: "glb", src: "scenes/diorama.glb" }],
- *     () => {
- *         // load the whole scene into the world (view under a Camera3d)
- *         me.level.load("diorama", { scale: 32 });
+ * await loader.preload([
+ *     { name: "diorama", type: "glb", src: "scenes/diorama.glb" },
+ * ]);
+ *
+ * // load the whole scene into the world (view it under a Camera3d)
+ * level.load("diorama", { scale: 32 });
  *
- *         // ...or inspect the raw descriptor for custom framing
- *         const scene = me.loader.getGLTF("diorama");
- *         const { min, max } = scene.bounds;
- *     },
- * );
+ * // ...or inspect the raw descriptor for custom framing
+ * const { min, max } = loader.getGLTF("diorama").bounds;
  */
 export function getGLTF(elt: string): GLTFData | null;
 /**
- * Return the precompiled `ShaderEffect` for the given "shader" asset —
- * compiled once during preloading, ready to assign to a renderable or
- * camera `shader` property.
+ * Get the shader compiled from a loaded `"shader"` asset — compiled once,
+ * at load time, ready to add to a renderable or a camera as a post effect.
  *
  * **This returns a SHARED instance**: the *same* `ShaderEffect` object on
  * every call, owned by the loader (its `shared` flag is `true`). That means:
@@ -122,6 +148,11 @@ export function getGLTF(elt: string): GLTFData | null;
  * `renderer.customShader`, a custom batcher). Same shared-instance
  * semantics, and `GLShader.clone()` likewise yields a caller-owned copy.
  *
+ * Unloading the asset destroys the shared instance, under whatever still
+ * draws with it: with bundles, an effect that outlives a level (a HUD's, a
+ * camera's) belongs in a bundle that outlives that level, such as
+ * `"common"`. A `clone()` is the caller's own and is not destroyed with it.
+ *
  * Degradation is never fatal: a fragment-body asset without a body in the
  * active renderer's language (or on Canvas) is an inert `ShaderEffect`
  * stub, and a complete-program asset without a realization for the active
@@ -129,77 +160,95 @@ export function getGLTF(elt: string): GLTFData | null;
  * built-in rendering. Note that shader assets require an initialized
  * Application (`await app.init()`) — an inherent precondition of the
  * preload flow, since the loading screen itself needs the renderer.
- * @param {string} elt - name of the shader asset (as specified in the preload list)
- * @returns {ShaderEffect|GLShader|null} the shared, precompiled shader, or `null` if not found
+ * @param {string} elt - the asset name
+ * @returns {ShaderEffect|GLShader|null} the shared, precompiled shader, or
+ * `null` if none is loaded under that name
  * @category Assets
  * @example
- * me.loader.preload([
- *     // from a file (or data: URI)
+ * await loader.preload([
+ *     // from a file (or a data: URI)
  *     { name: "waterRipple", type: "shader", src: "shaders/waterRipple.frag" },
- *     // or inline GLSL via the `data` field
+ *     // or inline GLSL, through the `data` field
  *     { name: "flash", type: "shader", data: `
  *         uniform float uIntensity;
  *         vec4 apply(vec4 color, vec2 uv) { return mix(color, vec4(1.0), uIntensity); }
  *     ` },
- *     // or a complete program — a {vertex, fragment} GLSL pair and/or a
- *     // full WGSL module → one GLShader carrying both realizations; the
- *     // active renderer hosts the one it speaks
+ *     // or a complete program: a {vertex, fragment} GLSL pair and/or a full
+ *     // WGSL module, compiled into one GLShader; the active renderer hosts
+ *     // the one it speaks
  *     { name: "toonMesh", type: "shader", src: {
  *         vertex: "shaders/toon.vert",
  *         fragment: "shaders/toon.frag",
  *         wgsl: "shaders/toon.wgsl",
  *     } },
- * ], () => {
- *     // one shared program — same uniform state for every user
- *     mySprite.addPostEffect(me.loader.getShader("waterRipple"));
- *     // private copy with its own uniforms (caller-owned, shared = false)
- *     boss.addPostEffect(me.loader.getShader("flash").clone());
- *     // a complete program hosts on a mesh, replacing the built-in shading
- *     myMesh.addPostEffect(me.loader.getShader("toonMesh"));
- * });
+ * ]);
+ *
+ * // one shared program: the same uniform values for every user
+ * mySprite.addPostEffect(loader.getShader("waterRipple"));
+ * // a private copy with its own uniforms (caller-owned, shared = false)
+ * boss.addPostEffect(loader.getShader("flash").clone());
+ * // a complete program hosts on a mesh, replacing the built-in shading
+ * myMesh.addPostEffect(loader.getShader("toonMesh"));
  */
 export function getShader(elt: string): ShaderEffect | GLShader | null;
 /**
- * return the specified MTL material data
- * @param {string} elt - name of the MTL file (as specified in the preload list)
- * @returns {object} map of material names to properties (`Kd`, `d`, `map_Kd`), or null if not found
+ * Get a loaded Wavefront MTL material library (an `"mtl"` asset), parsed.
+ * Most code never needs it: a `Mesh` takes the library's name as its
+ * `material`.
+ * @param {string} elt - the asset name
+ * @returns {object} the materials by name, each with its properties (`Kd`,
+ * `d`, `Ke`, `map_Kd`...), or `null` if none is loaded under that name
  * @category Assets
  * @example
- * // 1. preload OBJ + MTL + texture
- * me.loader.preload([
- *     { name: "fox", type: "obj", src: "models/fox.obj" },
- *     { name: "fox", type: "mtl", src: "models/fox.mtl" },
+ * // 1. preload the model, its materials and their texture
+ * await loader.preload([
+ *     { name: "fox",      type: "obj",   src: "models/fox.obj" },
+ *     { name: "fox",      type: "mtl",   src: "models/fox.mtl" },
  *     { name: "colormap", type: "image", src: "models/colormap.png" },
- * ], () => {
- *     // 2. create a Mesh with material — texture, tint, opacity auto-applied
- *     const mesh = new me.Mesh(400, 300, {
- *         model: "fox",
- *         material: "fox",
- *         texture: "colormap",
- *         width: 200,
- *         height: 200,
- *     });
+ * ]);
  *
- *     // 3. or access the raw material data directly
- *     const materials = me.loader.getMTL("fox");
- *     // materials["colormap"].Kd — [r, g, b] diffuse color (0-1 range)
- *     // materials["colormap"].d — opacity (0-1)
- *     // materials["colormap"].Ke — [r, g, b] emissive color (glow, applied as Mesh.emissive)
- *     // materials["colormap"].map_Kd — resolved texture URL
+ * // 2. a Mesh with a material: texture, tint and opacity applied for you
+ * const mesh = new Mesh(400, 300, {
+ *     model: "fox",
+ *     material: "fox",
+ *     texture: "colormap",
+ *     width: 200,
+ *     height: 200,
  * });
+ *
+ * // 3. or read the materials directly
+ * const materials = loader.getMTL("fox");
+ * // materials["colormap"].Kd — [r, g, b] diffuse color (0-1 range)
+ * // materials["colormap"].d — opacity (0-1)
+ * // materials["colormap"].Ke — [r, g, b] emissive color (applied as Mesh.emissive)
+ * // materials["colormap"].map_Kd — resolved texture URL
  */
 export function getMTL(elt: string): object;
 /**
- * return the specified Video Object
- * @param {string} elt - name of the video file
- * @returns {HTMLVideoElement}
+ * Get a loaded video (a `"video"` asset): the `<video>` element the loader
+ * created for it.
+ * @param {string} elt - the asset name
+ * @returns {HTMLVideoElement} the video element, or `null` if none is loaded
+ * under that name
+ * @example
+ * await loader.preload([{ name: "intro", type: "video", src: "data/video/intro.mp4" }]);
+ * const intro = loader.getVideo("intro");
+ * intro.play();
  * @category Assets
  */
 export function getVideo(elt: string): HTMLVideoElement;
 /**
- * return the specified FontFace Object
- * @param {string} elt - name of the font file
- * @returns {FontFace}
+ * Get a loaded web font (a `"fontface"` asset): the `FontFace` the loader
+ * added to `document.fonts`. Text uses it by its name, as a CSS font family.
+ * @param {string} elt - the asset name
+ * @returns {FontFace} the font face, or `null` if none is loaded under that
+ * name
+ * @example
+ * await loader.preload([
+ *     { name: "kenpixel", type: "fontface", src: "data/font/kenvector_future.woff2" },
+ * ]);
+ * const label = new Text(10, 10, { font: "kenpixel", size: 16, text: "Score" });
+ * console.log(loader.getFont("kenpixel").status); // "loaded"
  * @category Assets
  */
 export function getFont(elt: string): FontFace;

package/build/loader/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/loader/cache.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;GAUG;AACH,+BANW,MAAM,QACN,MAAM,GACJ,OAAO,CAOnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kCANW,MAAM,QACN,MAAM,GACJ,OAAO,CAWnB;AAED;;;;;;;;;GASG;AACH,iCALW,MAAM,GACJ,MAAM,EAAE,CAOpB;AAeD;;;;;GAKG;AACH,4BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;GAKG;AACH,+BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;GAKG;AACH,gCAJW,MAAM,GACJ,gBAAgB,GAAC,eAAe,GAAC,IAAI,CAWjD;AAED;;;;;GAKG;AACH,6BAJW,MAAM,GACJ,IAAI,CAUhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA3BW,MAAM,GACJ,MAAM,CAiClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,6BAhBW,MAAM,GACJ,QAAQ,GAAC,IAAI,CAqBzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,+BA7BW,MAAM,GACJ,YAAY,GAAC,QAAQ,GAAC,IAAI,CAkCtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA3BW,MAAM,GACJ,MAAM,CAgClB;AAED;;;;;GAKG;AACH,8BAJW,MAAM,GACJ,gBAAgB,CAU5B;AAED;;;;;GAKG;AACH,6BAJW,MAAM,GACJ,QAAQ,CAUpB;AAlbD;;;;;;;;;;GAUG;AAEH;;GAEG;AAGH,yBAA0B;AAG1B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAG3B,2BAA4B;AAG5B,0BAA2B;AAG3B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAK3B,4BAA6B;AAyB7B;;;;;;;;;;GAUG;AACH,2BAJU,SAAS,MAAM,EAAE,CAIyC;qCA5ElC,mDAAmD;8BAC1D,mBAAmB;8BAEjB,kCAAkC;0BADtC,4BAA4B"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/loader/cache.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;GAUG;AACH,+BANW,MAAM,QACN,MAAM,GACJ,OAAO,CAOnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kCANW,MAAM,QACN,MAAM,GACJ,OAAO,CAWnB;AAED;;;;;;;;;GASG;AACH,iCALW,MAAM,GACJ,MAAM,EAAE,CAOpB;AAeD;;;;;;;;;;;GAWG;AACH,4BARW,MAAM,GACJ,MAAM,CAclB;AAED;;;;;;;;;;;;;;GAcG;AACH,+BAZW,MAAM,GACJ,MAAM,CAkBlB;AAED;;;;;;;;;;;;;GAaG;AACH,gCARW,MAAM,GACJ,gBAAgB,GAAC,eAAe,GAAC,IAAI,CAejD;AAED;;;;;;;;;;GAUG;AACH,6BARW,MAAM,GACJ,IAAI,CAchB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA1BW,MAAM,GACJ,MAAM,CAgClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,6BAfW,MAAM,GACJ,QAAQ,GAAC,IAAI,CAoBzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,+BA9BW,MAAM,GACJ,YAAY,GAAC,QAAQ,GAAC,IAAI,CAmCtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,4BA5BW,MAAM,GACJ,MAAM,CAiClB;AAED;;;;;;;;;;;GAWG;AACH,8BATW,MAAM,GACJ,gBAAgB,CAe5B;AAED;;;;;;;;;;;;;GAaG;AACH,6BAXW,MAAM,GACJ,QAAQ,CAiBpB;AAneD;;;;;;;;;;GAUG;AAEH;;GAEG;AAGH,yBAA0B;AAG1B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAG3B,2BAA4B;AAG5B,0BAA2B;AAG3B,yBAA0B;AAG1B,yBAA0B;AAG1B,0BAA2B;AAK3B,4BAA6B;AAyB7B;;;;;;;;;;GAUG;AACH,2BAJU,SAAS,MAAM,EAAE,CAIyC;qCA5ElC,mDAAmD;8BAC1D,mBAAmB;8BAEjB,kCAAkC;0BADtC,4BAA4B"}

package/build/loader/internal-types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The progress `loader.preload` reports through `LOADER_PROGRESS`: the
+ * assets asked for and how many of them have loaded.
+ *
+ * One tally for every preload in flight, so that a second preload started
+ * before the first has settled joins it and the one progress bar keeps
+ * counting, rather than two calls taking turns to move it back and forth. Once
+ * every asset in it has settled (loaded or failed), the next preload starts a
+ * fresh tally from zero. These counters used to live for the whole session, so
+ * a second preload of two assets reported `0.75, 1` instead of `0.5, 1`, and
+ * after one failed asset no later preload reached `1` at all.
+ */
+export interface PreloadTally {
+    /** assets asked for */
+    total: number;
+    /** assets that loaded */
+    loaded: number;
+    /** assets that loaded or failed */
+    settled: number;
+}
+/**
+ * A bundle declared with `loader.setBundle`: a named list of assets with a
+ * lifetime of its own, over the same caches as every other asset.
+ *
+ * `state` is what `setBundle` checks: a bundle is `"loading"` from a
+ * `load(id)` / `preload([id])` until every asset of that call has settled,
+ * `"loaded"` after that (even when one failed: it keeps the ones that did
+ * load), and `"unloaded"` again after `unload(id)` or `unloadAll()`.
+ * `epoch` changes on every unload, so a load still in flight from before
+ * cannot hand its assets to a bundle that has since been released.
+ */
+export interface Bundle {
+    /** the bundle's asset descriptors */
+    assets: Asset[];
+    /** see above */
+    state: "unloaded" | "loading" | "loaded";
+    /** bumped on every unload of the bundle */
+    epoch: number;
+    /** calls loading it that have not settled yet */
+    loads: number;
+}
+/**
+ * A registered parser, normalized by `loader.setParser`.
+ *
+ * Every type gets the same shape whether or not it needs the src hooks, so
+ * `load()` can treat all of them alike. The alternative — a bare function that
+ * some types decorate with extra properties — puts the knowledge of which
+ * types are special back into the caller, which is what moving it out was for.
+ */
+export interface AssetParser {
+    /**
+     * preloads the asset and returns how many resources it will load (0 when
+     * already cached)
+     */
+    parse: (asset: Asset, onload?: (...args: unknown[]) => void, onerror?: (...args: unknown[]) => void, settings?: object) => number;
+    /**
+     * turns a type-specific descriptor into a bare path, before any base URL
+     * is applied. Identity unless the type overrides it
+     */
+    normalizeSrc: (src: string) => string;
+    /**
+     * whether the normalized src is relative to this type's base URL. Declares
+     * only this type's own exceptions, such as a `local()` font naming an
+     * installed family — data URIs are excluded for every type before this is
+     * consulted
+     */
+    needsBaseURL: (src: string) => boolean;
+}
+//# sourceMappingURL=internal-types.d.ts.map

package/build/loader/internal-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-types.d.ts","sourceRoot":"","sources":["../../src/loader/internal-types.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,YAAY;IAC5B,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,yBAAyB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,MAAM;IACtB,qCAAqC;IACrC,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,gBAAgB;IAChB,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IACzC,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC3B;;;OAGG;IACH,KAAK,EAAE,CACN,KAAK,EAAE,KAAK,EACZ,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,EACrC,OAAO,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,EACtC,QAAQ,CAAC,EAAE,MAAM,KACb,MAAM,CAAC;IACZ;;;OAGG;IACH,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;IACtC;;;;;OAKG;IACH,YAAY,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACvC"}