@woosh/meep-engine 3.14.1 → 3.14.2

package/src/shade/playground/ground_seam/measure_flicker.js

@@ -0,0 +1,531 @@
+import { m4_invert } from "../../../core/geom/3d/mat4/m4_invert.js";
+import { GPUTextureContext } from "../../renderer/texture/GPUTextureContext.js";
+
+/**
+ * Temporal-difference measurement for the ground-seam repro.
+ *
+ * ## Why it renders into its own texture
+ *
+ * A canvas texture is configured by the presentation path, cannot carry `COPY_SRC`, and is rotated
+ * away the moment the frame is presented — a `drawImage` off it a task later returns an empty
+ * bitmap, and a comparison of two blanks reports perfect agreement. `Renderer.render_to_target`
+ * exists for exactly this and shares the view context, so all the temporal history the measurement
+ * is *about* is the same history the on-screen path accumulates.
+ *
+ * Driving the frames from here rather than off `requestAnimationFrame` also takes the swap chain
+ * out of the loop, so the number of frames the temporal filter has seen is a number this module
+ * chose rather than one the compositor handed it.
+ *
+ * ## Why the seam is classified, not fitted
+ *
+ * The brief this repro came from retracted a conclusion that had been *fitted* to the seam's
+ * apparent slope, and the fit was wrong because the observer's camera basis had a sign error in it.
+ * Nothing here fits anything. Each pixel is unprojected through the camera's own
+ * `view_projection_matrix`, intersected with the ground plane, and labelled by the sign of
+ * `x + z` — which is the shared edge of the default triangulation, derived from the index buffer
+ * rather than from the picture. {@link classify_ground} round-trips one pixel back through the
+ * forward matrix and reports the error, so a broken convention shows up as a number instead of as a
+ * plausible story.
+ */
+
+/**
+ * @param {number} h a float16 bit pattern
+ * @returns {number}
+ */
+function half_to_float(h) {
+    const sign = (h & 0x8000) !== 0 ? -1 : 1;
+    const exponent = (h & 0x7C00) >> 10;
+    const fraction = h & 0x03FF;
+
+    if (exponent === 0) {
+        return sign * Math.pow(2, -14) * (fraction / 1024);
+    }
+
+    if (exponent === 31) {
+        return fraction !== 0 ? NaN : sign * Infinity;
+    }
+
+    return sign * Math.pow(2, exponent - 15) * (1 + fraction / 1024);
+}
+
+/**
+ * Which of the ground quad's two triangles covers each pixel, and where on the plane it lands.
+ *
+ * The classification is `sign(x + z)`: the default triangulation's shared edge is the world line
+ * `x = −z` (v2→v1 of `make_plane_geometry`'s 1×1 quad, laid flat by the −90° X rotation), so the
+ * two triangles are exactly the two sides of `x + z = 0`. For the flipped index buffer the shared
+ * edge is `x = z` instead, so `side_flipped` carries `sign(x − z)` alongside it and a caller can
+ * ask about whichever diagonal is currently in the mesh.
+ *
+ * @param {PerspectiveCamera} camera must already have had `update_matrices` run for this frame
+ * @param {number} width in pixels
+ * @param {number} height in pixels
+ * @param {number} [extent] half-width of the quad; pixels outside it are not ground
+ * @returns {{side: Int8Array, side_flipped: Int8Array, round_trip_error_px: number, covered: number}}
+ * `side` is −1, +1 or 0 (not ground). `round_trip_error_px` is the worst error, in pixels, from
+ * projecting a recovered world point back through the forward matrix — a sanity check on the whole
+ * convention, which should be a small fraction of a pixel.
+ */
+export function classify_ground(camera, width, height, extent = 212.5) {
+
+    const inverse = new Float64Array(16);
+
+    if (!m4_invert(inverse, camera.view_projection_matrix)) {
+        throw new Error('camera view-projection matrix is not invertible');
+    }
+
+    const forward = camera.view_projection_matrix;
+
+    const side = new Int8Array(width * height);
+    const side_flipped = new Int8Array(width * height);
+
+    let round_trip_error_px = 0;
+    let covered = 0;
+
+    /**
+     * NDC → world, with the homogeneous divide.
+     *
+     * @param {number} ndc_x
+     * @param {number} ndc_y
+     * @param {number} ndc_z
+     * @param {number[]} out
+     */
+    function unproject(ndc_x, ndc_y, ndc_z, out) {
+        const x = inverse[0] * ndc_x + inverse[4] * ndc_y + inverse[8] * ndc_z + inverse[12];
+        const y = inverse[1] * ndc_x + inverse[5] * ndc_y + inverse[9] * ndc_z + inverse[13];
+        const z = inverse[2] * ndc_x + inverse[6] * ndc_y + inverse[10] * ndc_z + inverse[14];
+        const w = inverse[3] * ndc_x + inverse[7] * ndc_y + inverse[11] * ndc_z + inverse[15];
+
+        out[0] = x / w;
+        out[1] = y / w;
+        out[2] = z / w;
+    }
+
+    const near_point = [0, 0, 0];
+    const far_point = [0, 0, 0];
+
+    for (let py = 0; py < height; py++) {
+
+        /*
+         Framebuffer rows run top to bottom and NDC Y runs bottom to top, so the row index is
+         flipped here. This is precisely the convention the retracted analysis got wrong, which is
+         why `round_trip_error_px` below re-derives the pixel from the world point instead of
+         trusting this line.
+        */
+        const ndc_y = 1 - 2 * (py + 0.5) / height;
+
+        for (let px = 0; px < width; px++) {
+            const ndc_x = 2 * (px + 0.5) / width - 1;
+
+            // reverse-Z with an infinite far plane: z = 1 is the near plane, z = 0 is infinity.
+            // Two points at different depths give a ray without needing to know which is which.
+            unproject(ndc_x, ndc_y, 1, near_point);
+            unproject(ndc_x, ndc_y, 0.5, far_point);
+
+            const dx = far_point[0] - near_point[0];
+            const dy = far_point[1] - near_point[1];
+            const dz = far_point[2] - near_point[2];
+
+            if (dy === 0) {
+                continue;
+            }
+
+            // intersect the ray with the ground plane, y = 0
+            const t = -near_point[1] / dy;
+
+            if (t < 0) {
+                // the plane is behind the ray's start — this pixel is sky
+                continue;
+            }
+
+            const wx = near_point[0] + dx * t;
+            const wz = near_point[2] + dz * t;
+
+            if (Math.abs(wx) > extent || Math.abs(wz) > extent) {
+                continue;
+            }
+
+            const index = py * width + px;
+
+            side[index] = wx + wz >= 0 ? 1 : -1;
+            side_flipped[index] = wx - wz >= 0 ? 1 : -1;
+
+            covered++;
+
+            /*
+             Round-trip check, on a sparse sample so it costs nothing: push the recovered world
+             point back through the *forward* matrix and see whether it lands on the pixel it came
+             from. Any sign error, row flip or depth-range mistake in the block above shows up here
+             as a large number rather than as a confident wrong answer.
+            */
+            if ((px & 63) === 0 && (py & 63) === 0) {
+                const cx = forward[0] * wx + forward[8] * wz + forward[12];
+                const cy = forward[1] * wx + forward[9] * wz + forward[13];
+                const cw = forward[3] * wx + forward[11] * wz + forward[15];
+
+                const back_px = (cx / cw * 0.5 + 0.5) * width - 0.5;
+                const back_py = (0.5 - cy / cw * 0.5) * height - 0.5;
+
+                round_trip_error_px = Math.max(
+                    round_trip_error_px,
+                    Math.abs(back_px - px),
+                    Math.abs(back_py - py)
+                );
+            }
+        }
+    }
+
+    return { side, side_flipped, round_trip_error_px, covered };
+}
+
+/**
+ * Owns the render target, the readback buffer, and the frame-driving loop.
+ *
+ * @param {object} context
+ * @param {Renderer} context.renderer
+ * @param {Scene} context.scene
+ * @param {PerspectiveCamera} context.camera
+ */
+export function attach_measurement({ renderer, scene, camera }) {
+
+    const device = renderer.device;
+
+    /** @type {object|null} */
+    let capture = null;
+
+    function make_target() {
+        if (capture !== null) {
+            capture.texture.destroy();
+            capture.buffer.destroy();
+        }
+
+        const resolution = renderer.output_resolution;
+
+        const width = resolution.x;
+        const height = resolution.y;
+
+        // the rule the renderer's own context configuration follows
+        const format = window.matchMedia('(dynamic-range: high)').matches
+            ? 'rgba16float'
+            : navigator.gpu.getPreferredCanvasFormat();
+
+        const texture = device.createTexture({
+            label: 'ground_seam/capture',
+            size: [width, height, 1],
+            format,
+            usage: GPUTextureUsage.RENDER_ATTACHMENT
+                | GPUTextureUsage.COPY_SRC
+                | GPUTextureUsage.COPY_DST
+                | GPUTextureUsage.TEXTURE_BINDING,
+        });
+
+        const bytes_per_pixel = format === 'rgba16float' ? 8 : 4;
+
+        // copyTextureToBuffer wants rows on a 256-byte boundary
+        const bytes_per_row = Math.ceil(width * bytes_per_pixel / 256) * 256;
+
+        capture = {
+            texture,
+            target: GPUTextureContext.fromTexture(texture, device),
+            width,
+            height,
+            format,
+            bytes_per_row,
+            buffer: device.createBuffer({
+                label: 'ground_seam/readback',
+                size: bytes_per_row * height,
+                usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+            }),
+        };
+
+        return capture;
+    }
+
+    function target() {
+        const resolution = renderer.output_resolution;
+
+        if (capture === null || capture.width !== resolution.x || capture.height !== resolution.y) {
+            make_target();
+        }
+
+        return capture;
+    }
+
+    /**
+     * One frame into the owned target.
+     * @param {number} [time_delta_s]
+     */
+    function frame(time_delta_s = 1 / 60) {
+        renderer.render_to_target(camera, scene, time_delta_s, target().target);
+    }
+
+    /**
+     * `n` frames with nothing read back, for letting the temporal filter converge.
+     * @param {number} n
+     */
+    async function settle(n) {
+        for (let i = 0; i < n; i++) {
+            frame();
+        }
+
+        await device.queue.onSubmittedWorkDone();
+    }
+
+    /**
+     * Per-pixel luminance of whatever is in the capture texture.
+     *
+     * @param {Float32Array} out length width*height
+     */
+    async function read_luminance(out) {
+        const c = target();
+
+        const encoder = device.createCommandEncoder({ label: 'ground_seam/readback' });
+
+        encoder.copyTextureToBuffer(
+            { texture: c.texture },
+            { buffer: c.buffer, bytesPerRow: c.bytes_per_row },
+            [c.width, c.height, 1]
+        );
+
+        device.queue.submit([encoder.finish()]);
+
+        await c.buffer.mapAsync(GPUMapMode.READ);
+
+        const raw = c.buffer.getMappedRange();
+
+        /*
+         The channel order is not cosmetic: the preferred canvas format on Windows is `bgra8unorm`,
+         and weighting it as if it were RGBA swaps the 0.2126 and 0.0722 coefficients. Still a usable
+         difference metric, but not the luminance it claims to be.
+        */
+        if (c.format === 'rgba16float') {
+            const source = new Uint16Array(raw);
+            const stride = c.bytes_per_row / 2;
+
+            for (let y = 0; y < c.height; y++) {
+                for (let x = 0; x < c.width; x++) {
+                    const i = y * stride + x * 4;
+
+                    out[y * c.width + x] = 0.2126 * half_to_float(source[i])
+                        + 0.7152 * half_to_float(source[i + 1])
+                        + 0.0722 * half_to_float(source[i + 2]);
+                }
+            }
+        } else {
+            const source = new Uint8Array(raw);
+            const stride = c.bytes_per_row;
+
+            const bgra = c.format.startsWith('bgra');
+
+            const r_offset = bgra ? 2 : 0;
+            const b_offset = bgra ? 0 : 2;
+
+            for (let y = 0; y < c.height; y++) {
+                for (let x = 0; x < c.width; x++) {
+                    const i = y * stride + x * 4;
+
+                    out[y * c.width + x] = (
+                        0.2126 * source[i + r_offset]
+                        + 0.7152 * source[i + 1]
+                        + 0.0722 * source[i + b_offset]
+                    ) / 255;
+                }
+            }
+        }
+
+        c.buffer.unmap();
+    }
+
+    /**
+     * Drive `frames` frames with the camera perfectly still and record, per pixel, the spread of
+     * luminance across the burst.
+     *
+     * `max − min` rather than a variance: a pixel that alternates between two values every frame and
+     * a pixel that drifts once both matter, and the spread catches both without weighting by how
+     * many frames were spent at each value.
+     *
+     * @param {object} [options]
+     * @param {number} [options.settle_frames] frames to converge before recording
+     * @param {number} [options.frames] frames in the burst
+     * @returns {Promise<{spread: Float32Array, mean: Float32Array, width: number, height: number}>}
+     */
+    async function burst({ settle_frames = 240, frames = 16 } = {}) {
+
+        await settle(settle_frames);
+
+        const c = target();
+
+        const count = c.width * c.height;
+
+        const current = new Float32Array(count);
+        const min = new Float32Array(count).fill(Infinity);
+        const max = new Float32Array(count).fill(-Infinity);
+        const total = new Float64Array(count);
+
+        for (let i = 0; i < frames; i++) {
+            frame();
+
+            await read_luminance(current);
+
+            for (let p = 0; p < count; p++) {
+                const v = current[p];
+
+                if (v < min[p]) {
+                    min[p] = v;
+                }
+
+                if (v > max[p]) {
+                    max[p] = v;
+                }
+
+                total[p] += v;
+            }
+        }
+
+        const spread = new Float32Array(count);
+        const mean = new Float32Array(count);
+
+        for (let p = 0; p < count; p++) {
+            spread[p] = max[p] - min[p];
+            mean[p] = total[p] / frames;
+        }
+
+        return { spread, mean, width: c.width, height: c.height };
+    }
+
+    /** @type {object|null} */
+    let depth_readback = null;
+
+    /**
+     * The frame's depth buffer, as the rasterizer left it.
+     *
+     * `Renderer.texture_depth_current` is public and the texture already carries `COPY_SRC`, so
+     * this needs no shader and no graph hook — what comes back is the rasterizer's own output,
+     * unmodified by anything downstream.
+     *
+     * It is at the *internal* resolution (output × `internal_resolution_scale`), so a caller lining
+     * it up against a colour readback has to use the size reported here rather than assume the two
+     * agree.
+     *
+     * @returns {Promise<{depth: Float32Array, width: number, height: number}>}
+     */
+    async function read_depth() {
+        const texture = renderer.texture_depth_current;
+
+        const width = texture.width;
+        const height = texture.height;
+
+        const bytes_per_row = Math.ceil(width * 4 / 256) * 256;
+
+        if (depth_readback === null
+            || depth_readback.width !== width
+            || depth_readback.height !== height) {
+
+            if (depth_readback !== null) {
+                depth_readback.buffer.destroy();
+            }
+
+            depth_readback = {
+                width,
+                height,
+                bytes_per_row,
+                buffer: device.createBuffer({
+                    label: 'ground_seam/depth_readback',
+                    size: bytes_per_row * height,
+                    usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+                }),
+            };
+        }
+
+        const encoder = device.createCommandEncoder({ label: 'ground_seam/depth' });
+
+        encoder.copyTextureToBuffer(
+            { texture: texture.gpu_texture, mipLevel: 0 },
+            { buffer: depth_readback.buffer, bytesPerRow: bytes_per_row },
+            [width, height, 1]
+        );
+
+        device.queue.submit([encoder.finish()]);
+
+        await depth_readback.buffer.mapAsync(GPUMapMode.READ);
+
+        const raw = new Float32Array(depth_readback.buffer.getMappedRange());
+
+        const depth = new Float32Array(width * height);
+
+        const stride = bytes_per_row / 4;
+
+        for (let y = 0; y < height; y++) {
+            depth.set(raw.subarray(y * stride, y * stride + width), y * width);
+        }
+
+        depth_readback.buffer.unmap();
+
+        return { depth, width, height };
+    }
+
+    return {
+        frame,
+        settle,
+        burst,
+        read_depth,
+        get capture() {
+            return target();
+        },
+    };
+}
+
+/**
+ * Where a world-space line on the ground plane lands on screen, as a signed-distance function.
+ *
+ * A projective map takes a straight line to a straight line, so two projected points are the whole
+ * of it. This exists so a profile can be taken *across* the seam in pixels: the half-plane means a
+ * split reports cannot tell a step at the boundary from a smooth gradient over the whole frame, and
+ * that is exactly the difference between "a seam" and "one half of the view is more oblique".
+ *
+ * @param {PerspectiveCamera} camera
+ * @param {number} width
+ * @param {number} height
+ * @param {number[]} direction unit direction of the line in the XZ plane
+ * @returns {function(number, number): number} pixel → signed perpendicular distance, in pixels
+ */
+export function screen_line_distance(camera, width, height, direction) {
+
+    const m = camera.view_projection_matrix;
+
+    /**
+     * @param {number} x
+     * @param {number} z
+     * @returns {number[]} pixel coordinates
+     */
+    function project(x, z) {
+        const cx = m[0] * x + m[8] * z + m[12];
+        const cy = m[1] * x + m[9] * z + m[13];
+        const cw = m[3] * x + m[11] * z + m[15];
+
+        return [
+            (cx / cw * 0.5 + 0.5) * width - 0.5,
+            (0.5 - cy / cw * 0.5) * height - 0.5,
+        ];
+    }
+
+    /*
+     Two points on the line, both well inside the frustum. Taking them near the camera rather than
+     at the quad's corners keeps them away from the eye plane, where a projected point's magnitude
+     explodes and the difference of two large numbers is all rounding.
+    */
+    const a = project(direction[0] * 5, direction[1] * 5);
+    const b = project(direction[0] * -5, direction[1] * -5);
+
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+
+    const length = Math.hypot(dx, dy);
+
+    if (!(length > 1e-6)) {
+        throw new Error('the seam projects to a point — the camera is looking along it');
+    }
+
+    // 2D cross product with the line direction gives the signed perpendicular offset
+    return (px, py) => ((px - a[0]) * dy - (py - a[1]) * dx) / length;
+}

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA4FA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAkB1C,uCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAgB/B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EA0NC;IAED;;OAEG;IACH,gBAGC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CAu2BnB;;CACJ;6BA74E4B,yBAAyB;0CACZ,gCAAgC;2BApB/C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAiC7C,uBAAuB;gCAtCnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BApDvC,2BAA2B;iCAkDrB,0CAA0C;4CApC/B,+DAA+D;yBA6BlF,yBAAyB;kCAMhB,wBAAwB;oBAvBtC,0BAA0B;uCAPP,sDAAsD"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA4FA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAkB1C,uCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAgB/B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EAkOC;IAED;;OAEG;IACH,gBAGC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CAu2BnB;;CACJ;6BAr5E4B,yBAAyB;0CACZ,gCAAgC;2BApB/C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAiC7C,uBAAuB;gCAtCnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BApDvC,2BAA2B;iCAkDrB,0CAA0C;4CApC/B,+DAA+D;yBA6BlF,yBAAyB;kCAMhB,wBAAwB;oBAvBtC,0BAA0B;uCAPP,sDAAsD"}