@3driseai/3drise-viewer 0.1.40 → 0.1.42

package/dist/components/gallery/kit/lookBase.js

@@ -0,0 +1,211 @@
+// The gallery lab's shared base for the second batch of looks, verbatim but for its import paths
+// (Claude outputs/gallery-lab/lookBase.mjs). Plain JS-shaped code; typed at its one door, GalleryVariant.tsx.
+// lookBase — what the second batch of gallery looks share: the per-picture active value, the soft change wave,
+// the cursor mask, the layout placement, the navigation and the picture texture. A look adds its own meshes
+// (self-coloured ShaderMaterials, or scene-lit standard materials through litMaterial) and its own per-frame work.
+//
+//   act      per picture, 0 → 1 at a constant rate (changeTime) toward "this is the front picture": never jumps,
+//            reverses cleanly half-way.
+//   wave     waveAt(act, uv): a soft front crossing the picture (slightly diagonal) — 1 behind it, 0 ahead.
+//   mask     maskAt(p): the cursor's soft disc (pointerRadius) in the gallery's own frame.
+//   place    placeAt(img, local) / fadeAt(img): the shared layouts (row, wave, ring, helix, tunnel, stack, fan,
+//            constellation), one matrix per picture.
+import * as THREE from 'three';
+import { fragHead, createScroll, focusAt, approach, withLean } from './galleryKit.js';
+import { createLayout, layoutUniforms, fillLayout, layoutGlsl, LAYOUT_GUI } from './galleryKit.js';
+export { fragHead, LAYOUT_GUI, withLean };
+export const MAXI = 32;
+export const BASE_DEFAULTS = {
+    enabled: true, lean: 1, imageUrls: [], autoplay: 0, intensity: 1, opacity: 1,
+    layout: 'row', spacing: 1.3, depth: 1.0, visible: 2.4, shape: 1,
+    stiffness: 26, damping: 8.5, throwing: 0.12,
+    changeTime: 1.8, wave: 0.35, slant: 0.3, dim: 0.3,
+    pointerStrength: 1, pointerRadius: 0.5,
+};
+export const BASE_GUI_MOTION = [
+    { key: 'stiffness', min: 5, max: 120, step: 1 }, { key: 'damping', min: 2, max: 30, step: 0.1 },
+    { key: 'changeTime', min: 0.4, max: 6, step: 0.1, tip: 'Seconds the change takes to cross a picture' },
+    { key: 'wave', min: 0.05, max: 1, step: 0.01, tip: 'Width of the soft change wave' }, { key: 'slant', min: 0, max: 1, step: 0.01, tip: 'How diagonal the wave is' },
+    { key: 'dim', min: 0, max: 1, step: 0.01, tip: 'Brightness of the inactive pictures' },
+    { key: 'autoplay', min: 0, max: 20, step: 0.5 },
+];
+export const BASE_GUI_TAIL = [
+    { key: 'pointerStrength', min: 0, max: 2, step: 0.01 }, { key: 'pointerRadius', min: 0.1, max: 2, step: 0.01 },
+    { key: 'intensity', min: 0, max: 3, step: 0.01 }, { key: 'opacity', min: 0, max: 1, step: 0.01 },
+];
+export function baseUniforms() {
+    return {
+        ...layoutUniforms(), uTex: { value: null }, uS: { value: 0 }, uCount: { value: 1 }, uTime: { value: 0 },
+        uAct: { value: new Float32Array(MAXI).fill(0) },
+        uW: { value: 2 }, uH: { value: 1.4 }, uWave: { value: 0.35 }, uSlant: { value: 0.3 }, uDim: { value: 0.3 },
+        uIntensity: { value: 1 }, uOpacity: { value: 1 },
+        uPointer: { value: new THREE.Vector3() }, uPointerActive: { value: 0 }, uPointerMode: { value: 0 }, uPointerStrength: { value: 1 }, uPointerRadius: { value: 0.5 },
+    };
+}
+export function applyBase(u, c, modes) {
+    const set = (k, v) => { if (v === undefined || !u[k])
+        return; if (u[k].value && u[k].value.isColor) {
+        if (v.isColor)
+            u[k].value.copy(v);
+        else
+            u[k].value.set(v);
+    }
+    else
+        u[k].value = v; };
+    set('uWave', c.wave);
+    set('uSlant', c.slant);
+    set('uDim', c.dim);
+    set('uIntensity', c.intensity);
+    set('uOpacity', c.opacity);
+    set('uPointerStrength', c.pointerStrength);
+    set('uPointerRadius', c.pointerRadius);
+    if (c.pointerMode !== undefined)
+        u.uPointerMode.value = modes.indexOf(c.pointerMode);
+    return set;
+}
+/** GLSL shared by every shader of the batch (vertex and fragment). */
+export const baseGlsl = /* glsl */ `
+    uniform float uS, uCount, uTime, uW, uH, uWave, uSlant, uDim, uIntensity, uOpacity;
+    uniform float uAct[${MAXI}];
+    uniform vec3 uPointer; uniform float uPointerActive, uPointerMode, uPointerStrength, uPointerRadius;
+    ${layoutGlsl}
+    float actOf(float img){ return uAct[int(img + 0.5)]; }
+    float waveAt(float act, vec2 g){
+        float pos = mix(g.x, 1.0 - g.y, uSlant * 0.5);
+        float front = act * (1.0 + uWave) - uWave * 0.5;
+        float w = smoothstep(front + uWave * 0.5, front - uWave * 0.5, pos);
+        return w * w * (3.0 - 2.0 * w);
+    }
+    float maskAt(vec2 p){ if (uPointerMode < -0.5) return 0.0; float d = length(p - uPointer.xy); return uPointerActive * uPointerStrength * (1.0 - smoothstep(uPointerRadius * 0.4, uPointerRadius, d)); }
+    float lumOf(vec3 c){ return dot(c, vec3(0.299, 0.587, 0.114)); }
+    // the inactive look: the picture's own luminance, grey and dim
+    vec3 fadedOf(vec3 pic){ return vec3(0.1 + 0.9 * lumOf(pic)) * uDim; }
+`;
+/** An instanced geometry: `base` repeated `per` times for each of the 32 pictures; aI = (picture, index, u, v). */
+export function instanced(base, per, cell) {
+    const g = new THREE.InstancedBufferGeometry();
+    g.index = base.index;
+    for (const k of Object.keys(base.attributes))
+        g.setAttribute(k, base.attributes[k]);
+    const a = new Float32Array(MAXI * per * 4);
+    for (let i = 0; i < MAXI; i++)
+        for (let k = 0; k < per; k++) {
+            const [uu, vv] = cell(k);
+            a.set([i, k, uu, vv], (i * per + k) * 4);
+        }
+    g.setAttribute('aI', new THREE.InstancedBufferAttribute(a, 4));
+    g.instanceCount = 0;
+    g.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 40);
+    g.userData.per = per;
+    return g;
+}
+/** A self-coloured ShaderMaterial of the batch (premultiplied). */
+export function shaderMaterial(u, vertexShader, fragmentShader, opts = {}) {
+    return new THREE.ShaderMaterial({ uniforms: u, vertexShader, fragmentShader, glslVersion: THREE.GLSL3, side: THREE.DoubleSide, transparent: true, depthWrite: true, premultipliedAlpha: true, ...opts });
+}
+/**
+ * A scene-lit standard material whose geometry and colour come from the look's own GLSL:
+ *   vertex.head / vertex.body — body sets `gPos` (local position, before the layout) and `gNrm` (local normal);
+ *                               the layout's matrix is applied here.
+ *   fragment.head / fragment.body — body sets `diffuseColor.rgb` (and may scale `diffuseColor.a`).
+ * It lights with the scene's lights like any standard material (the gallery adds none).
+ */
+export function litMaterial(u, key, vertex, fragment, opts = {}) {
+    const m = new THREE.MeshStandardMaterial({ roughness: 0.55, metalness: 0, side: THREE.DoubleSide, transparent: true, ...opts });
+    m.onBeforeCompile = (sh) => {
+        for (const k of Object.keys(u))
+            sh.uniforms[k] = u[k];
+        sh.vertexShader = sh.vertexShader
+            .replace('#include <common>', `#include <common>\nprecision highp sampler2DArray;\nuniform sampler2DArray uTex;\nattribute vec4 aI;\n${baseGlsl}\n${vertex.head}`)
+            .replace('#include <beginnormal_vertex>', `vec3 gPos = position; vec3 gNrm = normal;\n${vertex.body}\n    { mat4 M = uPlace[int(aI.x + 0.5)]; M[3][3] = 1.0; gPos = (M * vec4(gPos, 1.0)).xyz; gNrm = mat3(M) * gNrm; }\n    vec3 objectNormal = gNrm;`)
+            .replace('#include <begin_vertex>', 'vec3 transformed = gPos;');
+        sh.fragmentShader = sh.fragmentShader
+            .replace('#include <common>', `#include <common>\nprecision highp sampler2DArray;\nuniform sampler2DArray uTex;\n${baseGlsl}\n${fragment.head}`)
+            .replace('#include <color_fragment>', `#include <color_fragment>\n${fragment.body}`);
+    };
+    m.customProgramCacheKey = () => key;
+    return m;
+}
+/**
+ * The shadow twin of a litMaterial: the same geometry (vertex.body + the layout) and the same cut-out
+ * (cutout.head / cutout.body, which may `discard`), so the look casts true shadows of its own shape.
+ * Set as mesh.customDepthMaterial (directional and spot lights).
+ */
+export function litDepthMaterial(u, key, vertex, cutout = { head: '', body: '' }) {
+    const m = new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking, side: THREE.DoubleSide });
+    m.onBeforeCompile = (sh) => {
+        for (const k of Object.keys(u))
+            sh.uniforms[k] = u[k];
+        sh.vertexShader = sh.vertexShader
+            .replace('#include <common>', `#include <common>\nprecision highp sampler2DArray;\nuniform sampler2DArray uTex;\nattribute vec4 aI;\n${baseGlsl}\n${vertex.head}`)
+            .replace('#include <begin_vertex>', `vec3 gPos = position; vec3 gNrm = normal;\n${vertex.body}\n    { mat4 M = uPlace[int(aI.x + 0.5)]; M[3][3] = 1.0; gPos = (M * vec4(gPos, 1.0)).xyz; }\n    vec3 transformed = gPos;`);
+        sh.fragmentShader = sh.fragmentShader
+            .replace('#include <common>', `#include <common>\nprecision highp sampler2DArray;\nuniform sampler2DArray uTex;\n${baseGlsl}\n${cutout.head}`)
+            .replace('#include <clipping_planes_fragment>', `#include <clipping_planes_fragment>\n${cutout.body}`);
+    };
+    m.customProgramCacheKey = () => key + '-depth';
+    return m;
+}
+/**
+ * The gallery shell: navigation, layout, act, cursor, texture. `meshes` are added under the object; `setCount(n)`
+ * is called when the pictures change (set instance counts); `extra(dt, pointer, state)` runs every frame after
+ * the shared state is up to date.
+ */
+export function makeGallery(u, c, opts) {
+    const { W, H, meshes, setCount, extra, dispose } = opts; // extra and dispose are optional
+    u.uW.value = W;
+    u.uH.value = H;
+    const pick = new THREE.Mesh(new THREE.PlaneGeometry(W, H), new THREE.MeshBasicMaterial({ visible: false }));
+    const object = new THREE.Group();
+    for (const m of meshes)
+        object.add(m);
+    object.add(pick);
+    const cfg = { ...c };
+    const scroll = createScroll(cfg, () => { });
+    scroll.st.pitch = W * c.spacing;
+    const layout = createLayout(W, H);
+    const act = u.uAct.value;
+    const st = { time: 0 };
+    const _inv = new THREE.Matrix4(), _p = new THREE.Vector3();
+    const controls = Object.assign(scroll.controls, {
+        setTexture(tex, count) { if (u.uTex.value)
+            u.uTex.value.dispose(); u.uTex.value = tex; scroll.st.count = Math.min(count, MAXI); u.uCount.value = scroll.st.count; setCount(scroll.st.count); act.fill(0); act[controls.index] = 1; },
+    });
+    object.userData.gallery = controls;
+    return {
+        object, controls, pickMesh: pick, materials: meshes.map((m) => m.material), cfg,
+        apply(k) { Object.assign(cfg, k); scroll.st.pitch = W * cfg.spacing; },
+        update(dt, pointer, state) {
+            dt = Math.min(dt, 0.05);
+            st.time += dt;
+            u.uTime.value = st.time;
+            scroll.step(dt, pointer);
+            u.uS.value = scroll.st.s;
+            const n = scroll.st.count;
+            fillLayout(layout, u, scroll.st.s, n, cfg);
+            for (let i = 0; i < n; i++)
+                act[i] = approach(act[i], focusAt(i, scroll.st.s, n) > 0.5 ? 1 : 0, dt, cfg.changeTime);
+            // the cursor in the gallery's own frame (undo the lean's turn)
+            const rig = meshes[0].parent;
+            if (pointer && rig) {
+                rig.updateMatrix();
+                _inv.copy(rig.matrix).invert();
+                _p.set(pointer.x, pointer.y, 0).applyMatrix4(_inv);
+                u.uPointer.value.set(_p.x, _p.y, 0);
+            }
+            u.uPointerActive.value += ((pointer ? 1 : 0) - u.uPointerActive.value) * (1 - Math.exp(-dt * 5));
+            extra?.(dt, pointer, state);
+        },
+        dispose() {
+            for (const m of meshes) {
+                m.geometry.dispose();
+                m.material.dispose();
+            }
+            pick.geometry.dispose();
+            pick.material.dispose();
+            dispose?.();
+            if (u.uTex.value)
+                u.uTex.value.dispose();
+        },
+    };
+}

package/dist/components/gallery/kit/pictures.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+export interface PictureArray {
+    data: Uint8Array;
+    width: number;
+    height: number;
+    count: number;
+}
+/** Numbered gradient pictures, shown while a gallery has none of its own. */
+export declare function placeholderPictures(n: number, aspect: number): HTMLCanvasElement[];
+/** Load and cover-fit every picture into one array (bottom row first, as WebGL samples it). */
+export declare function loadPictureArray(sources: (string | HTMLCanvasElement)[], aspect: number, W?: number): Promise<PictureArray>;
+/** A fresh array texture over the pictures' pixels (the looks dispose their textures; the pixels stay). */
+export declare function pictureTexture(p: PictureArray): THREE.DataArrayTexture;
+//# sourceMappingURL=pictures.d.ts.map

package/dist/components/gallery/kit/pictures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pictures.d.ts","sourceRoot":"","sources":["../../../../src/components/gallery/kit/pictures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAa/B,MAAM,WAAW,YAAY;IAAG,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AAkBhG,6EAA6E;AAC7E,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAmBlF;AAED,+FAA+F;AAC/F,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,CAAC,MAAM,GAAG,iBAAiB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,SAAO,GAAG,OAAO,CAAC,YAAY,CAAC,CAmB/H;AAED,2GAA2G;AAC3G,wBAAgB,cAAc,CAAC,CAAC,EAAE,YAAY,GAAG,KAAK,CAAC,gBAAgB,CAMtE"}

package/dist/components/gallery/kit/pictures.js

@@ -0,0 +1,81 @@
+import * as THREE from 'three';
+const images = new Map();
+function loadImage(url) {
+    let p = images.get(url);
+    if (!p) {
+        p = new Promise((resolve) => {
+            const im = new Image();
+            im.crossOrigin = 'anonymous';
+            im.onload = () => resolve(im);
+            im.onerror = () => resolve(null);
+            im.src = url;
+        });
+        images.set(url, p);
+    }
+    return p;
+}
+/** Numbered gradient pictures, shown while a gallery has none of its own. */
+export function placeholderPictures(n, aspect) {
+    const W = 512, H = Math.round(W / aspect);
+    const pal = [['#0f2027', '#2c5364', '#ffb347'], ['#1b1b2f', '#0f3460', '#e94560'], ['#2d1b69', '#1de9b6', '#f9a825'],
+        ['#0b3d2e', '#b5e48c', '#ff9f1c'], ['#3a0ca3', '#4cc9f0', '#f72585'], ['#23395d', '#06d6a0', '#ffd166']];
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const cv = document.createElement('canvas');
+        cv.width = W;
+        cv.height = H;
+        const g = cv.getContext('2d');
+        const p = pal[i % pal.length];
+        const lin = g.createLinearGradient(0, 0, W, H);
+        lin.addColorStop(0, p[0]);
+        lin.addColorStop(1, p[1]);
+        g.fillStyle = lin;
+        g.fillRect(0, 0, W, H);
+        const rg = g.createRadialGradient(W * 0.7, H * 0.35, 0, W * 0.7, H * 0.35, W * 0.5);
+        rg.addColorStop(0, p[2] + 'aa');
+        rg.addColorStop(1, p[2] + '00');
+        g.fillStyle = rg;
+        g.fillRect(0, 0, W, H);
+        g.fillStyle = 'rgba(255,255,255,0.85)';
+        g.font = `600 ${Math.round(H * 0.16)}px system-ui, sans-serif`;
+        g.fillText(String(i + 1).padStart(2, '0'), W * 0.07, H * 0.9);
+        out.push(cv);
+    }
+    return out;
+}
+/** Load and cover-fit every picture into one array (bottom row first, as WebGL samples it). */
+export async function loadPictureArray(sources, aspect, W = 1024) {
+    const H = Math.max(2, Math.round(W / Math.max(0.1, aspect)));
+    const n = Math.max(1, sources.length);
+    const data = new Uint8Array(W * H * 4 * n);
+    const cv = document.createElement('canvas');
+    cv.width = W;
+    cv.height = H;
+    const ctx = cv.getContext('2d', { willReadFrequently: true });
+    const loaded = await Promise.all(sources.map((s) => (typeof s === 'string' ? loadImage(s) : Promise.resolve(s))));
+    for (let i = 0; i < n; i++) {
+        const img = loaded[i];
+        ctx.fillStyle = '#16181f';
+        ctx.fillRect(0, 0, W, H);
+        if (img) {
+            const iw = img.naturalWidth || img.width, ih = img.naturalHeight || img.height;
+            const s = Math.max(W / iw, H / ih);
+            ctx.drawImage(img, (W - iw * s) / 2, (H - ih * s) / 2, iw * s, ih * s);
+        }
+        const px = ctx.getImageData(0, 0, W, H).data, rb = W * 4;
+        for (let y = 0; y < H; y++)
+            data.set(px.subarray(y * rb, (y + 1) * rb), i * W * H * 4 + (H - 1 - y) * rb);
+    }
+    return { data, width: W, height: H, count: sources.length };
+}
+/** A fresh array texture over the pictures' pixels (the looks dispose their textures; the pixels stay). */
+export function pictureTexture(p) {
+    const tex = new THREE.DataArrayTexture(p.data, p.width, p.height, Math.max(1, p.count));
+    tex.colorSpace = THREE.SRGBColorSpace;
+    tex.minFilter = THREE.LinearMipmapLinearFilter;
+    tex.magFilter = THREE.LinearFilter;
+    tex.generateMipmaps = true;
+    tex.anisotropy = 4;
+    tex.needsUpdate = true;
+    return tex;
+}

package/dist/components/gallery/looks/basicCarousel.d.ts

@@ -0,0 +1,177 @@
+import * as THREE from 'three';
+export declare const catalog: {
+    key: string;
+    name: string;
+    description: string;
+    tags: string[];
+    camera: {
+        position: number[];
+        target: number[];
+    };
+};
+export declare const DEFAULTS: {
+    type: string;
+    enabled: boolean;
+    lean: number;
+    imageUrls: any[];
+    autoplay: number;
+    intensity: number;
+    opacity: number;
+    aspect: number;
+    frameWidth: number;
+    spacing: number;
+    curve: number;
+    tilt: number;
+    depth: number;
+    visible: number;
+    focusScale: number;
+    focusLift: number;
+    focusAmount: number;
+    dim: number;
+    stiffness: number;
+    damping: number;
+    throwing: number;
+    breathe: number;
+    reflection: number;
+    floorGap: number;
+    border: number;
+    borderColor: string;
+    backColor: string;
+    pointerMode: string;
+    pointerStrength: number;
+    pointerRadius: number;
+    pointerColor: string;
+};
+export declare const STRUCTURAL: string[];
+export declare const POINTER_MODES: string[];
+export declare const GUI: ({
+    key: string;
+    min: number;
+    max: number;
+    step: number;
+    tip: string;
+    options?: undefined;
+    color?: undefined;
+} | {
+    key: string;
+    min: number;
+    max: number;
+    step: number;
+    tip?: undefined;
+    options?: undefined;
+    color?: undefined;
+} | {
+    key: string;
+    options: string[];
+    min?: undefined;
+    max?: undefined;
+    step?: undefined;
+    tip?: undefined;
+    color?: undefined;
+} | {
+    key: string;
+    color: boolean;
+    min?: undefined;
+    max?: undefined;
+    step?: undefined;
+    tip?: undefined;
+    options?: undefined;
+})[];
+export declare const PRESETS: ({
+    name: string;
+    description: string;
+    patch: {
+        curve?: undefined;
+        tilt?: undefined;
+        depth?: undefined;
+        spacing?: undefined;
+        focusScale?: undefined;
+        focusLift?: undefined;
+        dim?: undefined;
+        reflection?: undefined;
+        visible?: undefined;
+        stiffness?: undefined;
+        damping?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        curve: number;
+        tilt: number;
+        depth: number;
+        spacing: number;
+        focusScale: number;
+        focusLift: number;
+        dim: number;
+        reflection: number;
+        visible?: undefined;
+        stiffness?: undefined;
+        damping?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        curve: number;
+        tilt: number;
+        depth: number;
+        spacing: number;
+        visible: number;
+        focusScale: number;
+        focusLift: number;
+        dim: number;
+        reflection?: undefined;
+        stiffness?: undefined;
+        damping?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        spacing: number;
+        tilt: number;
+        depth: number;
+        curve: number;
+        focusScale: number;
+        dim: number;
+        stiffness: number;
+        damping: number;
+        focusLift?: undefined;
+        reflection?: undefined;
+        visible?: undefined;
+    };
+})[];
+export declare function createUniforms(): {
+    uTex: {
+        value: any;
+    };
+    uBorder: {
+        value: number;
+    };
+    uBorderColor: {
+        value: THREE.Color;
+    };
+    uBackColor: {
+        value: THREE.Color;
+    };
+    uPointerColor: {
+        value: THREE.Color;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uReflection: {
+        value: number;
+    };
+    uAspect: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare const TEX_W = 1024;
+export declare function build(u: any, c: any): any;
+//# sourceMappingURL=basicCarousel.d.ts.map

package/dist/components/gallery/looks/basicCarousel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basicCarousel.d.ts","sourceRoot":"","sources":["../../../../src/components/gallery/looks/basicCarousel.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,OAAO;;;;;;;;;CAMnB,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCpB,CAAC;AACF,eAAO,MAAM,UAAU,UAAwC,CAAC;AAChE,eAAO,MAAM,aAAa,UAAmB,CAAC;AAE9C,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAaf,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKnB,CAAC;AAKF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO7B;AACD,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAI/B;AAmDD,eAAO,MAAM,KAAK,OAAO,CAAC;AAG1B,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,OAA6C"}