@woosh/meep-engine 3.14.1 → 3.14.3

package/src/shade/renderer/geometry/bvh/BLAS_REFIT_TARGET_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BLAS_REFIT_TARGET_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/BLAS_REFIT_TARGET_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,uCAFU,YAAY,CA4BA;6BA1CO,mCAAmC"}

package/src/shade/renderer/geometry/bvh/BLAS_REFIT_TARGET_STRUCT.js

@@ -0,0 +1,44 @@
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * One tree in a batched refit: where it lives, and where its arrival counters live.
+ *
+ * The first four fields are what {@link GPUGeometryBVHManager#get_refit_target} answers, copied
+ * out at the frame the batch's tables are built. The other two are the batch's own: a tree's
+ * counters sit at `counters_offset` in one buffer that holds the counters of every tree in the
+ * batch — a prefix sum of node counts — and `geometry_index` is the row whose meshlets the leaf
+ * payloads index, which for a skinned clone is the clone's own row, the one skinning deformed.
+ *
+ * Read by {@link shader_blas_refit_batch} once per workgroup, through the workgroup lookup;
+ * written by {@link GPUBLASRefitBatch} when the set of trees or their residency changes.
+ *
+ * @type {WebGPUStruct}
+ */
+export const BLAS_REFIT_TARGET_STRUCT = WebGPUStruct.from({
+    /**
+     * u32 word this tree's node 0 starts at in the node arena.
+     */
+    node_word_offset: u32,
+    /**
+     * Where this tree's parents start in the parents arena.
+     */
+    parents_offset: u32,
+    /**
+     * Where this tree's leaf list starts in the leaf-node arena.
+     */
+    leaf_nodes_offset: u32,
+    /**
+     * Leaves in this tree — one triangle each, so also its triangle count.
+     */
+    leaf_count: u32,
+    /**
+     * Where this tree's arrival counters start in the batch's counters buffer, one word per node
+     * slot of the tree.
+     */
+    counters_offset: u32,
+    /**
+     * Row in the geometry table whose meshlets the leaf payloads index into.
+     */
+    geometry_index: u32,
+}, "BlasRefitTarget");

package/src/shade/renderer/geometry/bvh/GPUBLASRefitBatch.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Refit a set of BLAS trees every frame, as one batch: a fixed number of commands whatever the
+ * number of trees, and no per-tree host work while the set and its residency hold still.
+ *
+ * The seam is the one the per-tree recorder had: an entry is an `owner` — the identity a tree
+ * was registered under, per {@link GPUGeometryBVHManager#obtain} — and a `geometry_index`, the row
+ * whose vertices the bounds come from. Nothing here knows what a clone is, or that skinning is why
+ * the vertices moved; anything that deforms vertices in place can list its trees here.
+ *
+ * Two tables live on the GPU between frames. The target rows ({@link BLAS_REFIT_TARGET_STRUCT})
+ * say where each tree sits in the manager's arenas and where its arrival counters sit in the
+ * batch's own; the lookup says, for every workgroup of the dispatch, which tree it serves and
+ * which run of that tree's leaves. Both are rebuilt from {@link GPUGeometryBVHManager#get_refit_target}
+ * when the entries change or the manager's {@link GPUGeometryBVHManager#residency_version} moves,
+ * and not otherwise. Entries whose tree is not resident yet are simply absent from the tables; the
+ * version moving is what brings them in.
+ *
+ * Every frame is then: one transient counters buffer, one clear of it, and one dispatch of
+ * {@link shader_blas_refit_batch} per page of workgroups under the device's per-dimension cap —
+ * one page for well over a hundred characters of the playground's size.
+ *
+ * `record` belongs inside {@link GPUMeshSkinningContext#update}, or somewhere with the same
+ * guarantee: it binds the manager's arena buffers as they are at that moment, and those buffers are
+ * replaced — the old ones destroyed — when an arena grows in {@link GPUGeometryBVHManager#update}.
+ * That runs before the frame's command context exists, so a refit recorded inside the frame is safe
+ * by call order. A refit recorded across one of those updates would submit a destroyed buffer, and
+ * the software device cannot catch it, since it executes nothing at submit.
+ */
+export class GPUBLASRefitBatch {
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device: GPUDevice);
+    /**
+     * The set of trees to refit from now on. Replaces the previous set; the tables are rebuilt on the
+     * next {@link record}.
+     *
+     * An owner may appear once: two rows for one tree would be two climbs racing on its nodes.
+     *
+     * @param {{owner: object, geometry_index: number}[]} entries
+     */
+    set_entries(entries: {
+        owner: object;
+        geometry_index: number;
+    }[]): void;
+    /**
+     * Record this frame's refit of every listed tree that is resident.
+     *
+     * @param {ShadeGPUCommandContext} cmd
+     * @param {GPUGeometryBVHManager} blas tree residency — arenas for nodes, parents and leaf lists
+     * @param {GPUGeometryManager} geometries geometry metadata table the leaf boxes read vertices through
+     * @returns {boolean} whether anything was recorded
+     */
+    record(cmd: ShadeGPUCommandContext, { blas, geometries }: GPUGeometryBVHManager): boolean;
+    destroy(): void;
+    #private;
+}
+//# sourceMappingURL=GPUBLASRefitBatch.d.ts.map

package/src/shade/renderer/geometry/bvh/GPUBLASRefitBatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUBLASRefitBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUBLASRefitBatch.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IA4DI;;OAEG;IACH,+BAIC;IAED;;;;;;;OAOG;IACH,qBAFW;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC,EAAE,QAkBnD;IAED;;;;;;;OAOG;IACH,kFAFa,OAAO,CAqDnB;IA8ID,gBAgBC;;CACJ"}

package/src/shade/renderer/geometry/bvh/GPUBLASRefitBatch.js

@@ -0,0 +1,362 @@
+import { assert } from "../../../../core/assert.js";
+import { write_gpu_typed_buffer } from "../../shader/type/serde/write_gpu_typed_buffer.js";
+import { BLAS_REFIT_TARGET_STRUCT } from "./BLAS_REFIT_TARGET_STRUCT.js";
+import { BLAS_REFIT_BATCH_WORKGROUP_SIZE, shader_blas_refit_batch } from "./shader_blas_refit_batch.js";
+
+/**
+ * Initial capacity of the target table, in rows. Doubles as needed.
+ */
+const TARGETS_INITIAL_CAPACITY = 16;
+
+/**
+ * Initial capacity of the workgroup lookup, in `(target_index, leaf_base)` pairs. Doubles as needed.
+ */
+const LOOKUP_INITIAL_CAPACITY = 256;
+
+/**
+ * Words per lookup pair.
+ */
+const LOOKUP_PAIR_WORDS = 2;
+
+/**
+ * Refit a set of BLAS trees every frame, as one batch: a fixed number of commands whatever the
+ * number of trees, and no per-tree host work while the set and its residency hold still.
+ *
+ * The seam is the one the per-tree recorder had: an entry is an `owner` — the identity a tree
+ * was registered under, per {@link GPUGeometryBVHManager#obtain} — and a `geometry_index`, the row
+ * whose vertices the bounds come from. Nothing here knows what a clone is, or that skinning is why
+ * the vertices moved; anything that deforms vertices in place can list its trees here.
+ *
+ * Two tables live on the GPU between frames. The target rows ({@link BLAS_REFIT_TARGET_STRUCT})
+ * say where each tree sits in the manager's arenas and where its arrival counters sit in the
+ * batch's own; the lookup says, for every workgroup of the dispatch, which tree it serves and
+ * which run of that tree's leaves. Both are rebuilt from {@link GPUGeometryBVHManager#get_refit_target}
+ * when the entries change or the manager's {@link GPUGeometryBVHManager#residency_version} moves,
+ * and not otherwise. Entries whose tree is not resident yet are simply absent from the tables; the
+ * version moving is what brings them in.
+ *
+ * Every frame is then: one transient counters buffer, one clear of it, and one dispatch of
+ * {@link shader_blas_refit_batch} per page of workgroups under the device's per-dimension cap —
+ * one page for well over a hundred characters of the playground's size.
+ *
+ * `record` belongs inside {@link GPUMeshSkinningContext#update}, or somewhere with the same
+ * guarantee: it binds the manager's arena buffers as they are at that moment, and those buffers are
+ * replaced — the old ones destroyed — when an arena grows in {@link GPUGeometryBVHManager#update}.
+ * That runs before the frame's command context exists, so a refit recorded inside the frame is safe
+ * by call order. A refit recorded across one of those updates would submit a destroyed buffer, and
+ * the software device cannot catch it, since it executes nothing at submit.
+ */
+export class GPUBLASRefitBatch {
+
+    /** @type {GPUDevice} */
+    #device;
+
+    /**
+     * What the caller asked to have refitted, verbatim.
+     *
+     * @type {{owner: object, geometry_index: number}[]}
+     */
+    #entries = [];
+
+    /**
+     * Set by {@link set_entries}; cleared when the tables are rebuilt.
+     *
+     * @type {boolean}
+     */
+    #entries_dirty = false;
+
+    /**
+     * The manager's residency version the tables were built against. Any other value means the
+     * answers the rows were copied from may have changed.
+     *
+     * @type {number}
+     */
+    #resolved_version = -1;
+
+    /** @type {GPUBuffer|null} */
+    #targets_buffer = null;
+
+    /**
+     * Capacity of {@link #targets_buffer}, in rows.
+     * @type {number}
+     */
+    #targets_capacity = 0;
+
+    /** @type {GPUBuffer|null} */
+    #lookup_buffer = null;
+
+    /**
+     * Capacity of {@link #lookup_buffer}, in pairs.
+     * @type {number}
+     */
+    #lookup_capacity = 0;
+
+    /**
+     * Workgroups the batch dispatches, across every page: one per aligned run of leaves of every
+     * resident tree. Zero means there is nothing to record.
+     *
+     * @type {number}
+     */
+    #workgroup_count = 0;
+
+    /**
+     * Words of arrival counters the batch needs: the sum of every resident tree's node slots.
+     *
+     * @type {number}
+     */
+    #counter_words = 0;
+
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device) {
+        assert.defined(device, 'device');
+
+        this.#device = device;
+    }
+
+    /**
+     * The set of trees to refit from now on. Replaces the previous set; the tables are rebuilt on the
+     * next {@link record}.
+     *
+     * An owner may appear once: two rows for one tree would be two climbs racing on its nodes.
+     *
+     * @param {{owner: object, geometry_index: number}[]} entries
+     */
+    set_entries(entries) {
+        assert.defined(entries, 'entries');
+        assert.isArray(entries, 'entries');
+
+        const owners = new Set();
+
+        for (const entry of entries) {
+            assert.defined(entry.owner, 'entry.owner');
+            assert.isNonNegativeInteger(entry.geometry_index, 'entry.geometry_index');
+            assert.notOk(owners.has(entry.owner), 'an owner is listed twice; two rows for one tree would race on its nodes');
+
+            owners.add(entry.owner);
+        }
+
+        this.#entries = entries.map(entry => ({ owner: entry.owner, geometry_index: entry.geometry_index }));
+        this.#entries_dirty = true;
+    }
+
+    /**
+     * Record this frame's refit of every listed tree that is resident.
+     *
+     * @param {ShadeGPUCommandContext} cmd
+     * @param {GPUGeometryBVHManager} blas tree residency — arenas for nodes, parents and leaf lists
+     * @param {GPUGeometryManager} geometries geometry metadata table the leaf boxes read vertices through
+     * @returns {boolean} whether anything was recorded
+     */
+    record(cmd, { blas, geometries }) {
+        assert.defined(cmd, 'cmd');
+        assert.defined(blas, 'blas');
+        assert.defined(geometries, 'geometries');
+
+        if (this.#entries_dirty || this.#resolved_version !== blas.residency_version) {
+            this.#resolve(blas);
+        }
+
+        const workgroup_count = this.#workgroup_count;
+
+        if (workgroup_count === 0) {
+            return false;
+        }
+
+        // One counter per node slot of every tree, and every one of them has to start at zero: a
+        // leftover count lets a first arrival believe it is a second and fit a node from a sibling
+        // nothing has written yet. The transient allocator pools its buffers, so whatever comes
+        // back is carrying the last frame's counts and gets cleared — once, for the whole batch.
+        const counters_size = this.#counter_words * Uint32Array.BYTES_PER_ELEMENT;
+
+        const counters = cmd.allocateTransientBuffer(GPUBufferUsage.STORAGE, counters_size);
+
+        cmd.clearBuffer(counters, 0, counters_size);
+
+        const meshlets = geometries.meshlets;
+
+        // The arena buffers are read off the manager here and now, every frame: they are replaced
+        // when an arena grows, and only their contents' offsets are stable.
+        const page = this.#device.limits.maxComputeWorkgroupsPerDimension;
+
+        for (let offset = 0; offset < workgroup_count; offset += page) {
+            shader_blas_refit_batch.dispatch({
+                encoder: cmd,
+                group_count_x: Math.min(page, workgroup_count - offset),
+                bindings: {
+                    dispatch_offset: offset,
+                    targets: this.#targets_buffer,
+                    lookup: this.#lookup_buffer,
+                    leaf_nodes: blas.buffer_leaf_nodes,
+                    parents: blas.buffer_parents,
+                    counters,
+                    nodes: blas.buffer_data,
+                    geometries: geometries.buffer_metadata,
+                    meshlet_metadata: meshlets.buffer_metadata,
+                    meshlet_data: meshlets.buffer_data,
+                },
+            });
+        }
+
+        return true;
+    }
+
+    /**
+     * Rebuild both tables from what the manager answers for every entry today.
+     *
+     * @param {GPUGeometryBVHManager} blas
+     */
+    #resolve(blas) {
+        const rows = [];
+
+        let counter_words = 0;
+        let workgroup_count = 0;
+
+        for (const entry of this.#entries) {
+            const target = blas.get_refit_target(entry.owner);
+
+            if (target === undefined || target.leaf_count === 0) {
+                // not resident yet, or nothing to fit; the version moving is what brings it in
+                continue;
+            }
+
+            rows.push({
+                node_word_offset: target.node_word_offset,
+                parents_offset: target.parents_offset,
+                leaf_nodes_offset: target.leaf_nodes_offset,
+                leaf_count: target.leaf_count,
+                counters_offset: counter_words,
+                geometry_index: entry.geometry_index,
+            });
+
+            counter_words += target.node_count;
+            workgroup_count += Math.ceil(target.leaf_count / BLAS_REFIT_BATCH_WORKGROUP_SIZE);
+        }
+
+        if (rows.length > 0) {
+            this.#upload_targets(rows);
+            this.#upload_lookup(rows, workgroup_count);
+        }
+
+        this.#workgroup_count = workgroup_count;
+        this.#counter_words = counter_words;
+
+        this.#entries_dirty = false;
+        this.#resolved_version = blas.residency_version;
+    }
+
+    /**
+     * @param {object[]} rows
+     */
+    #upload_targets(rows) {
+        const stride = BLAS_REFIT_TARGET_STRUCT.aligned_size;
+
+        this.#ensure_targets_capacity(rows.length);
+
+        const data = new ArrayBuffer(rows.length * stride);
+
+        for (let i = 0; i < rows.length; i++) {
+            write_gpu_typed_buffer(rows[i], BLAS_REFIT_TARGET_STRUCT, data, i * stride);
+        }
+
+        this.#device.queue.writeBuffer(this.#targets_buffer, 0, data);
+    }
+
+    /**
+     * One `(target_index, leaf_base)` pair per workgroup: tree by tree, run by run of its leaves.
+     *
+     * @param {object[]} rows
+     * @param {number} workgroup_count
+     */
+    #upload_lookup(rows, workgroup_count) {
+        this.#ensure_lookup_capacity(workgroup_count);
+
+        const pairs = new Uint32Array(workgroup_count * LOOKUP_PAIR_WORDS);
+
+        let cursor = 0;
+
+        for (let target_index = 0; target_index < rows.length; target_index++) {
+            const leaf_count = rows[target_index].leaf_count;
+
+            for (let leaf_base = 0; leaf_base < leaf_count; leaf_base += BLAS_REFIT_BATCH_WORKGROUP_SIZE) {
+                pairs[cursor++] = target_index;
+                pairs[cursor++] = leaf_base;
+            }
+        }
+
+        this.#device.queue.writeBuffer(this.#lookup_buffer, 0, pairs);
+    }
+
+    /**
+     * @param {number} rows
+     */
+    #ensure_targets_capacity(rows) {
+        if (this.#targets_buffer !== null && rows <= this.#targets_capacity) {
+            return;
+        }
+
+        let capacity = Math.max(this.#targets_capacity, TARGETS_INITIAL_CAPACITY);
+
+        while (capacity < rows) {
+            capacity *= 2;
+        }
+
+        if (this.#targets_buffer !== null) {
+            this.#targets_buffer.destroy();
+        }
+
+        this.#targets_buffer = this.#device.createBuffer({
+            label: 'GPUBLASRefitBatch/Targets',
+            size: capacity * BLAS_REFIT_TARGET_STRUCT.aligned_size,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        });
+
+        this.#targets_capacity = capacity;
+    }
+
+    /**
+     * @param {number} pairs
+     */
+    #ensure_lookup_capacity(pairs) {
+        if (this.#lookup_buffer !== null && pairs <= this.#lookup_capacity) {
+            return;
+        }
+
+        let capacity = Math.max(this.#lookup_capacity, LOOKUP_INITIAL_CAPACITY);
+
+        while (capacity < pairs) {
+            capacity *= 2;
+        }
+
+        if (this.#lookup_buffer !== null) {
+            this.#lookup_buffer.destroy();
+        }
+
+        this.#lookup_buffer = this.#device.createBuffer({
+            label: 'GPUBLASRefitBatch/Lookup',
+            size: capacity * LOOKUP_PAIR_WORDS * Uint32Array.BYTES_PER_ELEMENT,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        });
+
+        this.#lookup_capacity = capacity;
+    }
+
+    destroy() {
+        if (this.#targets_buffer !== null) {
+            this.#targets_buffer.destroy();
+            this.#targets_buffer = null;
+        }
+
+        if (this.#lookup_buffer !== null) {
+            this.#lookup_buffer.destroy();
+            this.#lookup_buffer = null;
+        }
+
+        this.#targets_capacity = 0;
+        this.#lookup_capacity = 0;
+        this.#workgroup_count = 0;
+        this.#counter_words = 0;
+        this.#entries_dirty = true;
+    }
+}

package/src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.d.ts

@@ -5,6 +5,19 @@
  * this manager's business — see {@link GPUGeometryBVHManager#publish_lookup}.
  */
 export const BLAS_METADATA_STRUCT: WebGPUStruct;
+/**
+ * Arena node index of the empty tree: what the lookup names for a geometry that has no tree yet.
+ *
+ * One internal node whose box is +inf below and -inf above. No ray enters it, so the ray queries
+ * pop it and miss; no point is within any distance of it, so the point queries prune it; and it is
+ * internal, so nothing ever fetches a triangle for it. Its children are itself, and are never
+ * descended into. Every traversal reads `blas_lookup[geometry_index]` and starts walking without a
+ * null check, so "no tree" has to be a tree — and it must not be whatever tree happens to sit at
+ * the arena's end, which is what a record resident over zero bytes used to point at.
+ *
+ * @type {number}
+ */
+export const BLAS_EMPTY_TREE_ADDRESS: number;
 /**
  * Residency for BLAS node data: one arena buffer holding every registered tree's nodes, and a
  * lookup buffer that maps *something else's* index onto an arena address.
@@ -44,6 +57,16 @@ export class GPUGeometryBVHManager {
      * @returns {GPUBuffer}
      */
     get buffer_leaf_nodes(): GPUBuffer;
+    /**
+     * @returns {number}
+     */
+    get residency_version(): number;
+    /**
+     * Arena node index of the tree a geometry traces while it has none of its own.
+     *
+     * @returns {number}
+     */
+    get empty_tree_address(): number;
     get gpu_memory_usage(): number;
     /**
      * The tree belonging to `owner`, registered against `source`'s shape if it does not exist yet.
@@ -64,6 +87,13 @@ export class GPUGeometryBVHManager {
     /**
      * Everything a refit needs to find a resident tree, or `undefined` while it is not resident.
      *
+     * "Resident" means the owner's nodes and its shape are both in their arenas, and that they are
+     * the same tree. A record snapshots its geometry's bytes when it is registered, and a geometry
+     * registered before its tree exists is uploaded as nothing — resident over zero bytes, at the
+     * arena's end. Its shape is derived later, from the bytes as they are then. Answering with that
+     * shape's counts at that record's address would hand a refit whichever tree was appended next,
+     * so the answer is withheld until the nodes actually uploaded are the tree the shape describes.
+     *
      * @param {object} owner the identity passed to {@link obtain}
      * @returns {{node_word_offset: number, node_count: number, leaf_count: number, parents_offset: number, leaf_nodes_offset: number}|undefined}
      */
@@ -103,6 +133,14 @@ export class GPUGeometryBVHManager {
      * @returns {boolean} true if a BLAS was registered for this owner and released
      */
     remove(owner: object): boolean;
+    /**
+     * Bring the arenas up to date with everything registered since the last call, and move the
+     * residency version if anything a refit reads has changed.
+     *
+     * Shapes first, and as their own question: they are not behind the node queue, so a frame in
+     * which a shape arrives for an already-uploaded record still uploads it — and still moves the
+     * version, because that record's refit answer has changed all the same.
+     */
     update(): void;
     #private;
 }

package/src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometryBVHManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH,gDAGG;AAUH;;;;;;;;;;;;;;GAcG;AACH;IAoGI;;;OAGG;IACH,+BA2BC;IA3HD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,6BAEC;IAqBD;;OAEG;IACH,gCAEC;IAOD;;OAEG;IACH,mCAEC;IAoED,+BAoBC;IAED;;;;;;;;;;;;;;OAcG;IACH,cALW,MAAM,4BAGJ,sBAAsB,CAalC;IA4DD;;;;;OAKG;IACH,wBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,GAAC,SAAS,CAgB3I;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAU5B;IAED;;;;;;;;;OASG;IACH,0BAFW,WAAW,QAQrB;IAED;;;;;;;;OAQG;IACH,cAHW,MAAM,GACJ,OAAO,CAkBnB;IAsID,eAgHC;;CACJ;6BAlmB4B,mCAAmC;uCAIzB,6BAA6B"}
+{"version":3,"file":"GPUGeometryBVHManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js"],"names":[],"mappings":"AAkBA;;;;;GAKG;AACH,gDAGG;AAEH;;;;;;;;;;;GAWG;AACH,sCAFU,MAAM,CAEyB;AAUzC;;;;;;;;;;;;;;GAcG;AACH;IAwHI;;;OAGG;IACH,+BAwCC;IA5JD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,6BAEC;IAqBD;;OAEG;IACH,gCAEC;IAOD;;OAEG;IACH,mCAEC;IA+BD;;OAEG;IACH,gCAEC;IAiED;;;;OAIG;IACH,iCAEC;IAED,+BAoBC;IAED;;;;;;;;;;;;;;OAcG;IACH,cALW,MAAM,4BAGJ,sBAAsB,CAalC;IA8DD;;;;;;;;;;;;OAYG;IACH,wBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,GAAC,SAAS,CAqB3I;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAU5B;IAED;;;;;;;;;OASG;IACH,0BAFW,WAAW,QAQrB;IAED;;;;;;;;OAQG;IACH,cAHW,MAAM,GACJ,OAAO,CAqBnB;IA8ID;;;;;;;OAOG;IACH,eAOC;;CA6HJ;6BAntB4B,mCAAmC;uCASzB,6BAA6B"}