@woosh/meep-engine 3.12.0 → 3.13.1

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.js

@@ -1,142 +1,145 @@
-import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    BVH_NODE_BOUNDS_WORD,
-    BVH_NODE_CHILD_1_WORD,
-    BVH_NODE_CHILD_2_WORD,
-    BVH_NODE_STRIDE_WORDS
-} from "./BVH_BUFFER_LAYOUT.js";
-import { BVH_BUILD_SETTINGS_STRUCT, BVH_NO_ROOT_WORD } from "./BVH_BUILD_SETTINGS_STRUCT.js";
-import { chunk_bvh_determine_range } from "./chunk_bvh_determine_range.js";
-import { chunk_bvh_find_split } from "./chunk_bvh_find_split.js";
-
-export const BVH_EMIT_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", BVH_BUILD_SETTINGS_STRUCT)
-    // sorted Morton codes, and the leaf index each one came from
-    .addStorageBuffer("keys", WebGPUArray.from(u32), false)
-    .addStorageBuffer("values", WebGPUArray.from(u32), false)
-    .addStorageBuffer("leaf_bounds", WebGPUArray.from(f32), false)
-    .addStorageBuffer("leaf_payload", WebGPUArray.from(u32), false)
-    // `{root: u32, nodes: array<BVH2_NODE_STRUCT>}`, written flat
-    .addStorageBuffer("nodes", WebGPUArray.from(u32), true)
-    // parent of every node, indexed the same way the node buffer is
-    .addStorageBuffer("parents", WebGPUArray.from(u32), true)
-    // which node each leaf ordinal lives at — see the shader's note on why this is written out
-    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
-const NODE_BOUNDS = ${BVH_NODE_BOUNDS_WORD}u;
-const NODE_CHILD_1 = ${BVH_NODE_CHILD_1_WORD}u;
-const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
-const NO_ROOT_WORD = ${BVH_NO_ROOT_WORD}u;
-
-fn bvh_node_word(node: u32) -> u32 {
-    return settings.node_word_offset + node * NODE_STRIDE;
-}
-
-@compute @workgroup_size(${BVH_EMIT_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let i = gid.x;
-    let n = settings.element_count;
-
-    if (i >= n) {
-        return;
-    }
-
-    // Leaf j lives at node (n-1)+j, internal node k at node k. Root is internal node 0 by Karras's
-    // construction — it is the node whose range is the whole array.
-    let leaf_source = values[i];
-    let leaf_node = (n - 1u) + i;
-
-    let bounds_source = leaf_source * 6u;
-    let leaf_word = bvh_node_word(leaf_node);
-
-    for (var k = 0u; k < 6u; k += 1u) {
-        nodes[leaf_word + NODE_BOUNDS + k] = bitcast<u32>(leaf_bounds[bounds_source + k]);
-    }
-
-    nodes[leaf_word + NODE_CHILD_1] = BVH_NULL_NODE;
-    nodes[leaf_word + NODE_CHILD_2] = leaf_payload[leaf_source];
-
-    // Where the leaves are is an output of construction, not a convention two kernels have to
-    // share. For this layout it is (n-1)+i and the refit could work it out — but a tree that was
-    // copied rather than built has its leaves wherever its builder put them, and the refit reads
-    // this the same way for both.
-    leaf_nodes[i] = leaf_node;
-
-    // n leaves, n-1 internal nodes — the tail thread has only a leaf to write.
-    if (i < n - 1u) {
-        let range = bvh_determine_range(&keys, n, i);
-
-        let first = range.x;
-        let last = range.y;
-
-        let split = bvh_find_split(&keys, n, first, last);
-
-        // A subrange of one element is a leaf; otherwise it is owned by the internal node whose
-        // left boundary sits at that code index.
-        let child_1 = select(split, (n - 1u) + split, split == first);
-        let child_2 = select(split + 1u, (n - 1u) + split + 1u, split + 1u == last);
-
-        let node_word = bvh_node_word(i);
-
-        nodes[node_word + NODE_CHILD_1] = child_1;
-        nodes[node_word + NODE_CHILD_2] = child_2;
-
-        // The refit climbs these; internal-node bounds are its business, not this pass's.
-        parents[child_1] = i;
-        parents[child_2] = i;
-    }
-
-    if (i == 0u) {
-        // Constant by construction, but a tree whose format has a root word has consumers that read
-        // it. A BLAS has none — its root is node 0 by convention — and says so with NO_ROOT_WORD.
-        if (settings.root_word_offset != NO_ROOT_WORD) {
-            nodes[settings.root_word_offset] = 0u;
-        }
-
-        // Where the refit's climb stops.
-        parents[0] = BVH_NULL_NODE;
-    }
-}
-`, [
-    BVH_NULL_NODE_DEFINITION,
-    chunk_bvh_determine_range,
-    chunk_bvh_find_split,
-]);
-
-/**
- * Karras hierarchy emission — pass 3 of {@link graph_bvh_build_lbvh}, and a transliteration of
- * {@link ebvh_build_hierarchy_radix} with the DXR Fallback's index layout: internal node `k` at node
- * `k` (root = 0), leaf `j` at node `(n-1)+j`, `2n-1` nodes in total.
- *
- * Node indices are local to the tree; where node 0 actually lands is `settings.node_word_offset`,
- * so the same kernel writes a TLAS that owns its buffer and a BLAS that is a tenant in a shared
- * arena. Root-at-node-0 is what both conventions want, which is why one kernel can serve them.
- *
- * One dispatch of `n` threads with a tail `if`, which is the canonical LBVH formulation: thread `i`
- * always writes leaf `(n-1)+i`, and threads below `n-1` additionally derive internal node `i`'s
- * range and split and wire its two children.
- *
- * Barrier-free, atomic-free, subgroup-free, and a pure function of the sorted keys — deliberately,
- * because that is what lets the WGSL emulator execute this kernel point-wise in vitest against the
- * in-repo CPU oracle, duplicate-code runs and all. Internal-node bounds are left to
- * {@link shader_bvh_refit}.
- *
- * @type {ComputeShader}
- */
-export const shader_bvh_emit_hierarchy = ComputeShader.from({
-    label: "BVHBuild/EmitHierarchy",
-    resources,
-    body,
-});
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import {
+    BVH_NODE_BOUNDS_WORD,
+    BVH_NODE_CHILD_1_WORD,
+    BVH_NODE_CHILD_2_WORD,
+    BVH_NODE_STRIDE_WORDS
+} from "./BVH_BUFFER_LAYOUT.js";
+import { BVH_BUILD_SETTINGS_STRUCT, BVH_NO_ROOT_WORD } from "./BVH_BUILD_SETTINGS_STRUCT.js";
+import { chunk_bvh_determine_range } from "./chunk_bvh_determine_range.js";
+import { chunk_bvh_find_split } from "./chunk_bvh_find_split.js";
+
+export const BVH_EMIT_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// see shader_bvh_morton — the same build settings, carried as immediate data
+resources.setImmediate("settings", BVH_BUILD_SETTINGS_STRUCT);
+
+resources.createGroup()
+    // sorted Morton codes, and the leaf index each one came from
+    .addStorageBuffer("keys", WebGPUArray.from(u32), false)
+    .addStorageBuffer("values", WebGPUArray.from(u32), false)
+    .addStorageBuffer("leaf_bounds", WebGPUArray.from(f32), false)
+    .addStorageBuffer("leaf_payload", WebGPUArray.from(u32), false)
+    // `{root: u32, nodes: array<BVH2_NODE_STRUCT>}`, written flat
+    .addStorageBuffer("nodes", WebGPUArray.from(u32), true)
+    // parent of every node, indexed the same way the node buffer is
+    .addStorageBuffer("parents", WebGPUArray.from(u32), true)
+    // which node each leaf ordinal lives at — see the shader's note on why this is written out
+    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
+const NODE_BOUNDS = ${BVH_NODE_BOUNDS_WORD}u;
+const NODE_CHILD_1 = ${BVH_NODE_CHILD_1_WORD}u;
+const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
+const NO_ROOT_WORD = ${BVH_NO_ROOT_WORD}u;
+
+fn bvh_node_word(node: u32) -> u32 {
+    return settings.node_word_offset + node * NODE_STRIDE;
+}
+
+@compute @workgroup_size(${BVH_EMIT_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let n = settings.element_count;
+
+    if (i >= n) {
+        return;
+    }
+
+    // Leaf j lives at node (n-1)+j, internal node k at node k. Root is internal node 0 by Karras's
+    // construction — it is the node whose range is the whole array.
+    let leaf_source = values[i];
+    let leaf_node = (n - 1u) + i;
+
+    let bounds_source = leaf_source * 6u;
+    let leaf_word = bvh_node_word(leaf_node);
+
+    for (var k = 0u; k < 6u; k += 1u) {
+        nodes[leaf_word + NODE_BOUNDS + k] = bitcast<u32>(leaf_bounds[bounds_source + k]);
+    }
+
+    nodes[leaf_word + NODE_CHILD_1] = BVH_NULL_NODE;
+    nodes[leaf_word + NODE_CHILD_2] = leaf_payload[leaf_source];
+
+    // Where the leaves are is an output of construction, not a convention two kernels have to
+    // share. For this layout it is (n-1)+i and the refit could work it out — but a tree that was
+    // copied rather than built has its leaves wherever its builder put them, and the refit reads
+    // this the same way for both.
+    leaf_nodes[i] = leaf_node;
+
+    // n leaves, n-1 internal nodes — the tail thread has only a leaf to write.
+    if (i < n - 1u) {
+        let range = bvh_determine_range(&keys, n, i);
+
+        let first = range.x;
+        let last = range.y;
+
+        let split = bvh_find_split(&keys, n, first, last);
+
+        // A subrange of one element is a leaf; otherwise it is owned by the internal node whose
+        // left boundary sits at that code index.
+        let child_1 = select(split, (n - 1u) + split, split == first);
+        let child_2 = select(split + 1u, (n - 1u) + split + 1u, split + 1u == last);
+
+        let node_word = bvh_node_word(i);
+
+        nodes[node_word + NODE_CHILD_1] = child_1;
+        nodes[node_word + NODE_CHILD_2] = child_2;
+
+        // The refit climbs these; internal-node bounds are its business, not this pass's.
+        parents[child_1] = i;
+        parents[child_2] = i;
+    }
+
+    if (i == 0u) {
+        // Constant by construction, but a tree whose format has a root word has consumers that read
+        // it. A BLAS has none — its root is node 0 by convention — and says so with NO_ROOT_WORD.
+        if (settings.root_word_offset != NO_ROOT_WORD) {
+            nodes[settings.root_word_offset] = 0u;
+        }
+
+        // Where the refit's climb stops.
+        parents[0] = BVH_NULL_NODE;
+    }
+}
+`, [
+    BVH_NULL_NODE_DEFINITION,
+    chunk_bvh_determine_range,
+    chunk_bvh_find_split,
+]);
+
+/**
+ * Karras hierarchy emission — pass 3 of {@link graph_bvh_build_lbvh}, and a transliteration of
+ * {@link ebvh_build_hierarchy_radix} with the DXR Fallback's index layout: internal node `k` at node
+ * `k` (root = 0), leaf `j` at node `(n-1)+j`, `2n-1` nodes in total.
+ *
+ * Node indices are local to the tree; where node 0 actually lands is `settings.node_word_offset`,
+ * so the same kernel writes a TLAS that owns its buffer and a BLAS that is a tenant in a shared
+ * arena. Root-at-node-0 is what both conventions want, which is why one kernel can serve them.
+ *
+ * One dispatch of `n` threads with a tail `if`, which is the canonical LBVH formulation: thread `i`
+ * always writes leaf `(n-1)+i`, and threads below `n-1` additionally derive internal node `i`'s
+ * range and split and wire its two children.
+ *
+ * Barrier-free, atomic-free, subgroup-free, and a pure function of the sorted keys — deliberately,
+ * because that is what lets the WGSL emulator execute this kernel point-wise in vitest against the
+ * in-repo CPU oracle, duplicate-code runs and all. Internal-node bounds are left to
+ * {@link shader_bvh_refit}.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh_emit_hierarchy = ComputeShader.from({
+    label: "BVHBuild/EmitHierarchy",
+    resources,
+    body,
+});

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_morton.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.js"],"names":[],"mappings":"AAQA,2CAA4C;AAwD5C;;;;;;;;;;;;GAYG;AACH,gCAFU,aAAa,CAMpB;8BA7E2B,+BAA+B"}
+{"version":3,"file":"shader_bvh_morton.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.js"],"names":[],"mappings":"AAQA,2CAA4C;AA6D5C;;;;;;;;;;;;GAYG;AACH,gCAFU,aAAa,CAMpB;8BAlF2B,+BAA+B"}

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.js

@@ -1,82 +1,87 @@
-import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { chunk_v3_morton_encode } from "../../shader/chunk/bvh/morton/chunk_v3_morton_encode.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { BVH_BUILD_SETTINGS_STRUCT } from "./BVH_BUILD_SETTINGS_STRUCT.js";
-
-export const BVH_MORTON_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", BVH_BUILD_SETTINGS_STRUCT)
-    // six floats per leaf: [min.xyz, max.xyz]
-    .addStorageBuffer("leaf_bounds", WebGPUArray.from(f32), false)
-    // the same six floats over the whole set, produced by the extraction pass
-    .addStorageBuffer("scene_bounds", WebGPUArray.from(f32), false)
-    .addStorageBuffer("keys", WebGPUArray.from(u32), true)
-    .addStorageBuffer("values", WebGPUArray.from(u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${BVH_MORTON_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let i = gid.x;
-
-    if (i >= settings.element_count) {
-        return;
-    }
-
-    let base = i * 6u;
-
-    let low = vec3<f32>(leaf_bounds[base], leaf_bounds[base + 1u], leaf_bounds[base + 2u]);
-    let high = vec3<f32>(leaf_bounds[base + 3u], leaf_bounds[base + 4u], leaf_bounds[base + 5u]);
-
-    let centroid = (low + high) * 0.5;
-
-    let scene_low = vec3<f32>(scene_bounds[0], scene_bounds[1], scene_bounds[2]);
-    let scene_high = vec3<f32>(scene_bounds[3], scene_bounds[4], scene_bounds[5]);
-
-    let span = scene_high - scene_low;
-
-    // An axis of zero extent contributes nothing to the code, exactly as it does in
-    // v3_morton_encode_bounded — every centroid quantises to 0 along it rather than to a division
-    // by zero.
-    let scale = select(vec3<f32>(0.0), vec3<f32>(1.0) / span, span != vec3<f32>(0.0));
-
-    // The centroid of a leaf box is inside the union of every leaf box by construction, so the
-    // clamp never binds on well-formed input; it is here so that a rounding error at the extreme,
-    // or a NaN-free degenerate box, cannot produce an out-of-range quantised coordinate.
-    let normalized = clamp((centroid - scene_low) * scale, vec3<f32>(0.0), vec3<f32>(1.0));
-
-    let quantised = vec3<u32>(round(normalized * 1023.0));
-
-    keys[i] = v3_morton_encode(quantised.x, quantised.y, quantised.z);
-
-    // the sort carries this along as the payload, so after it the leaves are in Morton order
-    values[i] = i;
-}
-`, [
-    chunk_v3_morton_encode,
-]);
-
-/**
- * Morton code per leaf — pass 1 of {@link graph_bvh_build_lbvh}.
- *
- * The leaf's centroid is quantised to ten bits per axis inside the scene bounds and interleaved
- * into a 30-bit code, matching `v3_morton_encode_bounded` + `v3_morton_encode_normalized` on the
- * CPU term for term (`round(1023 * t)`, zero-extent axes scaled by zero). `values[i] = i` seeds the
- * permutation the sort then carries.
- *
- * Pure per-invocation: no barriers, no atomics, no subgroups — which is what lets the emulator tier
- * run it point-wise against the CPU encoder.
- *
- * @type {ComputeShader}
- */
-export const shader_bvh_morton = ComputeShader.from({
-    label: "BVHBuild/Morton",
-    resources,
-    body,
-});
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_v3_morton_encode } from "../../shader/chunk/bvh/morton/chunk_v3_morton_encode.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { BVH_BUILD_SETTINGS_STRUCT } from "./BVH_BUILD_SETTINGS_STRUCT.js";
+
+export const BVH_MORTON_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 20 bytes, read-only: immediate data rather than a uniform buffer. An LBVH build
+// dispatches this shader, emit_hierarchy and refit in sequence, each of which was allocating and
+// filling its own copy of the same settings.
+resources.setImmediate("settings", BVH_BUILD_SETTINGS_STRUCT);
+
+resources.createGroup()
+    // six floats per leaf: [min.xyz, max.xyz]
+    .addStorageBuffer("leaf_bounds", WebGPUArray.from(f32), false)
+    // the same six floats over the whole set, produced by the extraction pass
+    .addStorageBuffer("scene_bounds", WebGPUArray.from(f32), false)
+    .addStorageBuffer("keys", WebGPUArray.from(u32), true)
+    .addStorageBuffer("values", WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${BVH_MORTON_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+
+    if (i >= settings.element_count) {
+        return;
+    }
+
+    let base = i * 6u;
+
+    let low = vec3<f32>(leaf_bounds[base], leaf_bounds[base + 1u], leaf_bounds[base + 2u]);
+    let high = vec3<f32>(leaf_bounds[base + 3u], leaf_bounds[base + 4u], leaf_bounds[base + 5u]);
+
+    let centroid = (low + high) * 0.5;
+
+    let scene_low = vec3<f32>(scene_bounds[0], scene_bounds[1], scene_bounds[2]);
+    let scene_high = vec3<f32>(scene_bounds[3], scene_bounds[4], scene_bounds[5]);
+
+    let span = scene_high - scene_low;
+
+    // An axis of zero extent contributes nothing to the code, exactly as it does in
+    // v3_morton_encode_bounded — every centroid quantises to 0 along it rather than to a division
+    // by zero.
+    let scale = select(vec3<f32>(0.0), vec3<f32>(1.0) / span, span != vec3<f32>(0.0));
+
+    // The centroid of a leaf box is inside the union of every leaf box by construction, so the
+    // clamp never binds on well-formed input; it is here so that a rounding error at the extreme,
+    // or a NaN-free degenerate box, cannot produce an out-of-range quantised coordinate.
+    let normalized = clamp((centroid - scene_low) * scale, vec3<f32>(0.0), vec3<f32>(1.0));
+
+    let quantised = vec3<u32>(round(normalized * 1023.0));
+
+    keys[i] = v3_morton_encode(quantised.x, quantised.y, quantised.z);
+
+    // the sort carries this along as the payload, so after it the leaves are in Morton order
+    values[i] = i;
+}
+`, [
+    chunk_v3_morton_encode,
+]);
+
+/**
+ * Morton code per leaf — pass 1 of {@link graph_bvh_build_lbvh}.
+ *
+ * The leaf's centroid is quantised to ten bits per axis inside the scene bounds and interleaved
+ * into a 30-bit code, matching `v3_morton_encode_bounded` + `v3_morton_encode_normalized` on the
+ * CPU term for term (`round(1023 * t)`, zero-extent axes scaled by zero). `values[i] = i` seeds the
+ * permutation the sort then carries.
+ *
+ * Pure per-invocation: no barriers, no atomics, no subgroups — which is what lets the emulator tier
+ * run it point-wise against the CPU encoder.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh_morton = ComputeShader.from({
+    label: "BVHBuild/Morton",
+    resources,
+    body,
+});

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_refit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_refit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_refit.js"],"names":[],"mappings":"AAcA,0CAA2C;AAqG3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+BAFU,aAAa,CAMpB;8BAvI2B,+BAA+B"}
+{"version":3,"file":"shader_bvh_refit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_refit.js"],"names":[],"mappings":"AAcA,0CAA2C;AAwG3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+BAFU,aAAa,CAMpB;8BA1I2B,+BAA+B"}