@woosh/meep-engine 3.38.0 → 3.39.0

package/src/shade/renderer/path_tracer/graph_path_trace_scene.js

@@ -1,186 +1,189 @@
-import { assert } from "../../../core/assert.js";
-import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
-import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_camera_ray_from_uv } from "../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
-import { F32_MAX_DEFINITION } from "../shader/chunk/math/F32_MAX_DEFINITION.js";
-import { chunk_hammersley_2d } from "../shader/chunk/noise/chunk_hammersley_2d.js";
-import { chunk_random } from "../shader/chunk/random/chunk_random.js";
-import { chunk_random_initialize } from "../shader/chunk/random/chunk_random_initialize.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { sr_create_group_RTX } from "../geometry/sr_create_group_RTX.js";
-import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
-import { chunk_render_trace_path } from "./shader/chunk_render_trace_path.js";
-
-const RAY_TRACING_UNIFORMS_STRUCT = WebGPUStruct.from({
-    random_seed: u32
-});
-
-const resources = new ShaderResourceSetDescriptor();
-
-sr_create_group_RTX(resources);
-
-resources.createGroup()
-    .addUniform("materials", INDIRECT_MATERIAL_ARRAY_TYPE)
-    .addTexture("textures", "unfilterable-float", "2d-array")
-
-resources.createGroup()
-    .addStorageBuffer("light_data", WebGPUArray.u32)
-    .addTexture("tEnvironment", "unfilterable-float", "2d")
-
-resources.createGroup()
-    .addUniform("common_uniforms", RAY_TRACING_UNIFORMS_STRUCT)
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addStorageTexture("output_texture", "rgba16float", "2d", "write-only")
-;
-
-const body = CodeChunk.from(
-//language=WGSL
-    `
-@compute @workgroup_size(8,8,1)
-fn main(@builtin(global_invocation_id) invocation_id : vec3<u32>){
-    let viewport_dimensions = textureDimensions(output_texture);
-
-    if (any(invocation_id.xy >= viewport_dimensions)){
-        return;
-    }
-    
-    random_initialize(invocation_id, vec3(common_uniforms.random_seed));
-    
-    let uv = vec2f(invocation_id.xy) / vec2f(viewport_dimensions);
-    let pixel_uv_size = 1.0 / vec2f(viewport_dimensions);
-    
-    const BOUNCE_LIMIT = 3;
-    const SAMPLE_LIMIT = 32;
-    
-    var irradiance = vec3(0.0);
-    
-    for(var sample_index=0u; sample_index < SAMPLE_LIMIT; sample_index++){
-    
-        // construct ray
-        
-        var jitter = hammersley_2d(sample_index, SAMPLE_LIMIT);
-        
-        let uv_coordinate = uv + jitter * pixel_uv_size;
-        
-        var ray = camera_ray_from_uv(vec2(uv_coordinate.x, uv_coordinate.y), camera);
-        
-        ray.tmax = F32_MAX; // TODO set based on "far" clipping plane from camera
-                            
-        irradiance += render_trace_path(ray, BOUNCE_LIMIT).irradiance;
-    }
-    
-    var output = irradiance / SAMPLE_LIMIT;
-           
-    textureStore(output_texture, invocation_id.xy, vec4(output, 1));
-}
-`, [
-        F32_MAX_DEFINITION,
-        chunk_camera_ray_from_uv,
-        chunk_hammersley_2d,
-        chunk_random_initialize,
-        chunk_random,
-        chunk_render_trace_path,
-    ]);
-
-const shader = ComputeShader.from({
-    label: 'Path Tracer',
-    resources,
-    body
-})
-
-
-/**
- *
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @param {GPUViewContext} options.view
- * @returns {number}
- */
-export function graph_path_trace_scene({
-                                           graph,
-                                           view,
-                                       }) {
-
-    assert.defined(graph, 'graph');
-
-    assert.defined(view, 'view');
-    assert.equal(view.isGPUViewContext, true, '"view" must be a GPUViewContext');
-
-
-    const pass_data = {};
-
-    /**
-     *
-     * @param data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(data, resources, context) {
-
-        const graphics = context.graphics;
-
-        const r_materials = graphics.materials_resident;
-
-        const scene_ctx = view.scene;
-
-        r_materials.ensure_scene_materials(scene_ctx);
-        r_materials.update();
-
-        const geometries = scene_ctx.geometries;
-
-        /**
-         * @type {GPUTextureContext}
-         */
-        const output_texture = resources.get(data.output);
-
-        const rt_uniforms = context.encoder.allocateTransientBufferAndLoad(new Uint32Array([0]).buffer, GPUBufferUsage.UNIFORM);
-
-        shader.dispatchThreads({
-            encoder: context.encoder,
-
-            thread_count_x: output_texture.width,
-            thread_count_y: output_texture.height,
-
-            bindings: {
-                materials: r_materials.buffer_materials,
-                textures: r_materials.textureView,
-
-                //
-                tlas: scene_ctx.tlas.buffer,
-                blas_lookup: geometries.blas.buffer_metadata,
-                blas_data: geometries.blas.buffer_data,
-                scene_database: scene_ctx.scene_database_buffer,
-                geometries: geometries.buffer_metadata,
-
-                meshlet_data: geometries.meshlets.buffer_data,
-                meshlet_metadata: geometries.meshlets.buffer_metadata,
-
-                //
-                light_data: scene_ctx.lights.buffer_data,
-                tEnvironment: view.scene.lights.environment.obtainView(),
-
-                common_uniforms: rt_uniforms,
-                camera: view.camera.gpu_buffer,
-                output_texture: output_texture.obtainView()
-            }
-        });
-
-
-    }
-
-    const builder = graph.add('path trace scene', pass_data, execute);
-
-    pass_data.output = builder.create("output", TextureResourceDescriptor.from({
-        resolution: view.resolution,
-        format: 'rgba16float',
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING
-    }));
-
-
-    return pass_data.output;
+import { assert } from "../../../core/assert.js";
+import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
+import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_camera_ray_from_uv } from "../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
+import { F32_MAX_DEFINITION } from "../shader/chunk/math/F32_MAX_DEFINITION.js";
+import { chunk_hammersley_2d } from "../shader/chunk/noise/chunk_hammersley_2d.js";
+import { chunk_random } from "../shader/chunk/random/chunk_random.js";
+import { chunk_random_initialize } from "../shader/chunk/random/chunk_random_initialize.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { sr_create_group_RTX } from "../geometry/sr_create_group_RTX.js";
+import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
+import { MEDIA_TABLE_STRUCT } from "../medium/MEDIA_TABLE_STRUCT.js";
+import { chunk_render_trace_path } from "./shader/chunk_render_trace_path.js";
+
+const RAY_TRACING_UNIFORMS_STRUCT = WebGPUStruct.from({
+    random_seed: u32
+});
+
+const resources = new ShaderResourceSetDescriptor();
+
+sr_create_group_RTX(resources);
+
+resources.createGroup()
+    .addUniform("materials", INDIRECT_MATERIAL_ARRAY_TYPE)
+    .addUniform("media", MEDIA_TABLE_STRUCT)
+    .addTexture("textures", "unfilterable-float", "2d-array")
+
+resources.createGroup()
+    .addStorageBuffer("light_data", WebGPUArray.u32)
+    .addTexture("tEnvironment", "unfilterable-float", "2d")
+
+resources.createGroup()
+    .addUniform("common_uniforms", RAY_TRACING_UNIFORMS_STRUCT)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addStorageTexture("output_texture", "rgba16float", "2d", "write-only")
+;
+
+const body = CodeChunk.from(
+//language=WGSL
+    `
+@compute @workgroup_size(8,8,1)
+fn main(@builtin(global_invocation_id) invocation_id : vec3<u32>){
+    let viewport_dimensions = textureDimensions(output_texture);
+
+    if (any(invocation_id.xy >= viewport_dimensions)){
+        return;
+    }
+    
+    random_initialize(invocation_id, vec3(common_uniforms.random_seed));
+    
+    let uv = vec2f(invocation_id.xy) / vec2f(viewport_dimensions);
+    let pixel_uv_size = 1.0 / vec2f(viewport_dimensions);
+    
+    const BOUNCE_LIMIT = 3;
+    const SAMPLE_LIMIT = 32;
+    
+    var irradiance = vec3(0.0);
+    
+    for(var sample_index=0u; sample_index < SAMPLE_LIMIT; sample_index++){
+    
+        // construct ray
+        
+        var jitter = hammersley_2d(sample_index, SAMPLE_LIMIT);
+        
+        let uv_coordinate = uv + jitter * pixel_uv_size;
+        
+        var ray = camera_ray_from_uv(vec2(uv_coordinate.x, uv_coordinate.y), camera);
+        
+        ray.tmax = F32_MAX; // TODO set based on "far" clipping plane from camera
+                            
+        irradiance += render_trace_path(ray, BOUNCE_LIMIT).irradiance;
+    }
+    
+    var output = irradiance / SAMPLE_LIMIT;
+           
+    textureStore(output_texture, invocation_id.xy, vec4(output, 1));
+}
+`, [
+        F32_MAX_DEFINITION,
+        chunk_camera_ray_from_uv,
+        chunk_hammersley_2d,
+        chunk_random_initialize,
+        chunk_random,
+        chunk_render_trace_path,
+    ]);
+
+const shader = ComputeShader.from({
+    label: 'Path Tracer',
+    resources,
+    body
+})
+
+
+/**
+ *
+ * @param {Object} options
+ * @param {FrameGraph} options.graph
+ * @param {GPUViewContext} options.view
+ * @returns {number}
+ */
+export function graph_path_trace_scene({
+                                           graph,
+                                           view,
+                                       }) {
+
+    assert.defined(graph, 'graph');
+
+    assert.defined(view, 'view');
+    assert.equal(view.isGPUViewContext, true, '"view" must be a GPUViewContext');
+
+
+    const pass_data = {};
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+
+        const graphics = context.graphics;
+
+        const r_materials = graphics.materials_resident;
+
+        const scene_ctx = view.scene;
+
+        r_materials.ensure_scene_materials(scene_ctx);
+        r_materials.update();
+
+        const geometries = scene_ctx.geometries;
+
+        /**
+         * @type {GPUTextureContext}
+         */
+        const output_texture = resources.get(data.output);
+
+        const rt_uniforms = context.encoder.allocateTransientBufferAndLoad(new Uint32Array([0]).buffer, GPUBufferUsage.UNIFORM);
+
+        shader.dispatchThreads({
+            encoder: context.encoder,
+
+            thread_count_x: output_texture.width,
+            thread_count_y: output_texture.height,
+
+            bindings: {
+                materials: r_materials.buffer_materials,
+                media: r_materials.buffer_media,
+                textures: r_materials.textureView,
+
+                //
+                tlas: scene_ctx.tlas.buffer,
+                blas_lookup: geometries.blas.buffer_metadata,
+                blas_data: geometries.blas.buffer_data,
+                scene_database: scene_ctx.scene_database_buffer,
+                geometries: geometries.buffer_metadata,
+
+                meshlet_data: geometries.meshlets.buffer_data,
+                meshlet_metadata: geometries.meshlets.buffer_metadata,
+
+                //
+                light_data: scene_ctx.lights.buffer_data,
+                tEnvironment: view.scene.lights.environment.obtainView(),
+
+                common_uniforms: rt_uniforms,
+                camera: view.camera.gpu_buffer,
+                output_texture: output_texture.obtainView()
+            }
+        });
+
+
+    }
+
+    const builder = graph.add('path trace scene', pass_data, execute);
+
+    pass_data.output = builder.create("output", TextureResourceDescriptor.from({
+        resolution: view.resolution,
+        format: 'rgba16float',
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING
+    }));
+
+
+    return pass_data.output;
 }

package/src/shade/renderer/path_tracer/shader/STANDARD_MATERIAL_DATA_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"STANDARD_MATERIAL_DATA_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/STANDARD_MATERIAL_DATA_STRUCT.js"],"names":[],"mappings":"AAGA,yDAUG;6BAZ0B,mCAAmC"}
+{"version":3,"file":"STANDARD_MATERIAL_DATA_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/STANDARD_MATERIAL_DATA_STRUCT.js"],"names":[],"mappings":"AAGA,yDAaG;6BAf0B,mCAAmC"}

package/src/shade/renderer/path_tracer/shader/STANDARD_MATERIAL_DATA_STRUCT.js

@@ -1,4 +1,4 @@
-import { f32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { bool, f32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 
 export const STANDARD_MATERIAL_DATA_STRUCT = WebGPUStruct.from({
@@ -11,4 +11,7 @@ export const STANDARD_MATERIAL_DATA_STRUCT = WebGPUStruct.from({
     emissive: vec3f,
     normal_shading: vec3f,
     normal_geometric: vec3f,
+    // the ray hit the side the face normal points to: entering what the surface encloses, for a
+    // closed mesh. Both normals above are turned to face the ray either way
+    front_facing: bool,
 });

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_tangent_normal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A resident material's tangent-space normal at `uv`, from its normal texture in the atlas — or +Z,
+ * the geometric normal exactly, when it has none (`id` is GPU_DATABASE_NULL; see
+ * INDIRECT_MATERIAL_STRUCT's `texture_normal` for why there is no default texture to read instead).
+ *
+ * Reads the `textures` atlas binding, which {@link chunk_indirect_sample_texture} leaves to the
+ * shader that includes it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_indirect_sample_tangent_normal: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_indirect_sample_tangent_normal.d.ts.map

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_tangent_normal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_indirect_sample_tangent_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_indirect_sample_tangent_normal.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,mDAFU,SAAS,CAeZ;0BA1BmB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_indirect_sample_tangent_normal.js

@@ -0,0 +1,29 @@
+import { GPU_DATABASE_NULL } from "../../buffer/table/GPU_DATABASE_NULL.js";
+import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_indirect_sample_texture } from "./chunk_indirect_sample_texture.js";
+
+/**
+ * A resident material's tangent-space normal at `uv`, from its normal texture in the atlas — or +Z,
+ * the geometric normal exactly, when it has none (`id` is GPU_DATABASE_NULL; see
+ * INDIRECT_MATERIAL_STRUCT's `texture_normal` for why there is no default texture to read instead).
+ *
+ * Reads the `textures` atlas binding, which {@link chunk_indirect_sample_texture} leaves to the
+ * shader that includes it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_indirect_sample_tangent_normal = CodeChunk.from(
+    //language=WGSL
+    `
+fn indirect_sample_tangent_normal(id: u32, sampler_packed: u32, uv: vec2<f32>) -> vec3<f32> {
+    if (id == ${GPU_DATABASE_NULL}u) {
+        return vec3<f32>(0.0, 0.0, 1.0);
+    }
+
+    return decode_tangent_normal(indirect_sample_texture(id, sampler_packed, uv));
+}
+`, [
+        chunk_decode_tangent_normal,
+        chunk_indirect_sample_texture,
+    ]);

package/src/shade/renderer/path_tracer/shader/chunk_render_trace_path.d.ts

@@ -1,4 +1,83 @@
 export const PATH_TRACE_RESULT_STRUCT: WebGPUStruct;
+/**
+ * Scattering events in media one path may take. Each costs a ray to the next surface and a shadow
+ * ray, and every thread of a group waits for its longest path, so this bounds the work a thread can
+ * hold its group for rather than leaving it to Russian roulette, which a medium that scatters much
+ * and absorbs little barely ends. Light still in such a medium after this many events is dropped.
+ * @type {number}
+ */
+export const PATH_MEDIUM_SCATTER_LIMIT: number;
+/**
+ * Reflections and refractions at interfaces into media one path may take: entering and leaving a
+ * glass costs two, water in a glass four, total internal reflection one each. Not counted against
+ * the caller's bounce limit, which is for diffuse and glossy bounces. Light still bouncing between
+ * interfaces after this many is dropped: 0.3% of a white furnace built to trap it (a scattering
+ * n = 1.333 sphere), where 64 events dropped none measurable.
+ * @type {number}
+ */
+export const PATH_INTERFACE_EVENT_LIMIT: number;
+/**
+ * Interface events a path takes about the interpolated shading normal; after them, about the
+ * triangle's own. A tessellated curved interface traps light the smooth one it stands for would
+ * not: a ray entering a sphere near its outline refracts to just under the critical angle, the
+ * normals interpolated across flat triangles tip it over at the far side, and from there the
+ * interpolated normals keep its angle from triangle to triangle, so it circles by total internal
+ * reflection until {@link PATH_INTERFACE_EVENT_LIMIT} drops it — a dark band inside the outline. The
+ * triangles' own normals break that symmetry and let it out. Every event still reflects or
+ * transmits the light whole.
+ *
+ * Measured on a white furnace with an n = 1.5 sphere of 5,000 triangles, at its left outline, the
+ * side the tessellation tilts: with 64 interface events, 4.4% low always smooth, 1.1% with 8 smooth
+ * events, 0.66% with 2 (and loss appearing on the other sides); with 16, 2.8% with 8 smooth events
+ * and 1.4% with 4. What remains is light the faceted surface itself holds past the limit.
+ * @type {number}
+ */
+export const PATH_INTERFACE_SMOOTH_EVENT_LIMIT: number;
+/**
+ * Medium-bounding surfaces one path may pass straight through, where no interface is: a second
+ * mesh of the medium it is in, or a medium of lower priority.
+ * @type {number}
+ */
+export const PATH_MEDIUM_PASS_LIMIT: number;
+/**
+ * How far above a surface's horizon, as the cosine to its geometric normal, the shadow ray toward a
+ * light behind the surface goes, inside a medium, to find the interface its light may bend through.
+ * @type {number}
+ */
+export const PATH_HORIZON_LIFT: number;
+/**
+ * Traces one path and returns the radiance it carries back along `inRay`.
+ *
+ * Between surfaces the path crosses participating media: the medium the surfaces it entered through
+ * enclose (`StandardShadeMaterial.medium`, on the material's surface) and the scene's
+ * participating-media volumes. In them it may scatter (light sampled from the scattering point, then
+ * the medium's phase function sampled) or be absorbed — see chunk_medium_transport for the
+ * estimators, which track RGB with hero-channel MIS: every contribution is the path's throughput over
+ * the mean of its MIS state `r_u`, and `r_u` stays 1 where there are no media, leaving such paths
+ * exactly as they were.
+ *
+ * Light from a light behind one refracting interface — the sun under water, a lamp behind glass —
+ * reaches surfaces and scattering points by manifold next-event estimation (`manifold_connect`), up to
+ * `PATH_MANIFOLD_LIMIT` connections a path. A surface inside a medium chooses its light with no
+ * receiver cosine and traces its shadow ray whichever side of it the light is on, since the
+ * interface may bend the light round to its front. Two things still judge by the straight line to
+ * the light: a spot's cone, which can rule out a receiver its refracted beam reaches, and a surface
+ * outside every medium lit through an interface by a light inside one — a pool light on a ceiling.
+ *
+ * A surface inside a medium reflects by the ratio of its index to the medium's (its specular F0).
+ *
+ * A surface whose material has a medium is a refracting interface into it — exact Fresnel at the
+ * ratio of the two sides' `ior_factor`, total internal reflection, the radiance weight
+ * (n_from / n_to)² refraction carries — with probability `transmission_factor`, and the rest of its
+ * material otherwise. Without a medium, transmission is thin-walled, as it always was.
+ *
+ * `bounce_limit` counts diffuse and glossy surface bounces, as it always did; interface events and
+ * medium scattering have their own limits ({@link PATH_INTERFACE_EVENT_LIMIT},
+ * {@link PATH_MEDIUM_SCATTER_LIMIT}).
+ *
+ * The importing shader binds the ray-tracing group, `materials`, `textures`, `media`, `light_data`
+ * and `tEnvironment`.
+ */
 export const chunk_render_trace_path: CodeChunk;
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";

package/src/shade/renderer/path_tracer/shader/chunk_render_trace_path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_render_trace_path.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js"],"names":[],"mappings":"AAkCA,oDAIG;AAGH,gDAkVE;6BA1X2B,mCAAmC;0BA2BtC,oCAAoC"}
+{"version":3,"file":"chunk_render_trace_path.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_render_trace_path.js"],"names":[],"mappings":"AA2CA,oDAIG;AAEH;;;;;;GAMG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;;;GAOG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,gDAFU,MAAM,CAEmC;AAEnD;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,gCAFU,MAAM,CAEsB;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,gDAwhBE;6BA5pB2B,mCAAmC;0BA2BtC,oCAAoC"}