@3driseai/3drise-core 1.0.1

package/dist/three/effects/LightningEffectV.js

@@ -0,0 +1,255 @@
+import * as THREE from 'three';
+const glowVert = /* glsl */ `
+  attribute float aBrightness;
+  uniform float uPointSize;
+  varying float vB;
+  void main() {
+    vB           = aBrightness;
+    vec4 mv      = modelViewMatrix * vec4(position, 1.0);
+    gl_PointSize = uPointSize * aBrightness * (200.0 / -mv.z);
+    gl_Position  = projectionMatrix * mv;
+  }
+`;
+const glowFrag = /* glsl */ `
+  uniform vec3  uColor;
+  uniform float uOpacity;
+  varying float vB;
+  void main() {
+    if (vB < 0.01) discard;
+    vec2  c = gl_PointCoord - 0.5;
+    if (length(c) > 0.5) discard;
+    float g = exp(-dot(c, c) * 5.5);
+    gl_FragColor = vec4(uColor, g * vB * uOpacity);
+  }
+`;
+const FADE_DUR = 0.22;
+function makeRng(seed) {
+    let s = (seed * 1664525 + 1013904223) >>> 0;
+    return () => { s = (s * 1664525 + 1013904223) >>> 0; return s / 0xffffffff; };
+}
+function fractalPolyline(start, end, depth, rng) {
+    if (depth === 0)
+        return [start.clone(), end.clone()];
+    const mid = start.clone().lerp(end, 0.42 + rng() * 0.16);
+    const dir = end.clone().sub(start);
+    const len = dir.length();
+    dir.normalize();
+    let perp1 = new THREE.Vector3(dir.z, 0, -dir.x);
+    if (perp1.lengthSq() < 0.001)
+        perp1.set(0, dir.z, -dir.y);
+    perp1.normalize();
+    const perp2 = dir.clone().cross(perp1).normalize();
+    const spread = len * 0.38;
+    mid.addScaledVector(perp1, (rng() - 0.5) * 2 * spread);
+    mid.addScaledVector(perp2, (rng() - 0.5) * spread * 0.7);
+    const a = fractalPolyline(start, mid, depth - 1, rng);
+    const b = fractalPolyline(mid, end, depth - 1, rng);
+    return [...a.slice(0, -1), ...b];
+}
+export class LightningEffectV {
+    scene;
+    group;
+    materials = [];
+    config;
+    boundingRadius;
+    bolts = [];
+    lineMat = null;
+    glowMats = [];
+    coreCol = new THREE.Color();
+    glowCol = new THREE.Color();
+    depth = 4;
+    N = 17;
+    sr = 1;
+    constructor(scene, config, boundingRadius = 1) {
+        this.scene = scene;
+        this.config = config;
+        this.boundingRadius = boundingRadius;
+        this.group = new THREE.Group();
+        scene.add(this.group);
+        this.build();
+    }
+    boltEndpoints(rng) {
+        const theta = rng() * Math.PI * 2;
+        const elev = 0.3 + rng() * 0.4;
+        return [
+            new THREE.Vector3(Math.cos(theta) * this.sr * elev, this.sr * (0.8 + rng() * 0.4), Math.sin(theta) * this.sr * elev),
+            new THREE.Vector3((rng() - 0.5) * this.boundingRadius * 0.4, (rng() - 0.5) * this.boundingRadius * 0.3, (rng() - 0.5) * this.boundingRadius * 0.4),
+        ];
+    }
+    makeGeos(pts, colBuf, brightBuf) {
+        const N = this.N;
+        const posArr = new Float32Array(N * 3);
+        for (let i = 0; i < pts.length && i < N; i++) {
+            posArr[i * 3] = pts[i].x;
+            posArr[i * 3 + 1] = pts[i].y;
+            posArr[i * 3 + 2] = pts[i].z;
+        }
+        const lineGeo = new THREE.BufferGeometry();
+        lineGeo.setAttribute('position', new THREE.BufferAttribute(posArr.slice(), 3));
+        lineGeo.setAttribute('color', new THREE.BufferAttribute(colBuf, 3));
+        const pointGeo = new THREE.BufferGeometry();
+        pointGeo.setAttribute('position', new THREE.BufferAttribute(posArr.slice(), 3));
+        pointGeo.setAttribute('aBrightness', new THREE.BufferAttribute(brightBuf, 1));
+        return { lineGeo, pointGeo };
+    }
+    refreshColors(bolt, overallScale) {
+        const { progress, points, colBuf, brightBuf, lineGeo, pointGeo } = bolt;
+        const n = points.length;
+        for (let i = 0; i < n; i++) {
+            const t = i / (n - 1);
+            if (t > progress + 0.001) {
+                colBuf[i * 3] = colBuf[i * 3 + 1] = colBuf[i * 3 + 2] = 0;
+                brightBuf[i] = 0;
+                continue;
+            }
+            const behind = progress - t;
+            const trail = Math.exp(-behind * 7.0);
+            const buildUp = 0.3 + 0.7 * progress;
+            const corona = Math.exp(-behind * behind * 220) * 3.0;
+            const totalBri = (trail * buildUp + corona) * this.config.intensity * overallScale;
+            const headMix = Math.min(1, corona * 0.5);
+            colBuf[i * 3] = (this.glowCol.r + (this.coreCol.r - this.glowCol.r) * headMix) * totalBri;
+            colBuf[i * 3 + 1] = (this.glowCol.g + (this.coreCol.g - this.glowCol.g) * headMix) * totalBri;
+            colBuf[i * 3 + 2] = (this.glowCol.b + (this.coreCol.b - this.glowCol.b) * headMix) * totalBri;
+            brightBuf[i] = Math.min(1, (trail * buildUp * 0.5 + corona * 0.3) * overallScale);
+        }
+        lineGeo.attributes.color.needsUpdate = true;
+        pointGeo.attributes.aBrightness.needsUpdate = true;
+    }
+    rebuildShape(bolt) {
+        bolt.seed++;
+        const rng = makeRng(bolt.seed);
+        const [o, t] = this.boltEndpoints(rng);
+        bolt.points = fractalPolyline(o, t, this.depth, rng);
+        bolt.waitDur = 0.3 + rng() * 1.3;
+        bolt.progress = 0;
+        const pts = bolt.points;
+        const posL = bolt.lineGeo.attributes.position;
+        const posP = bolt.pointGeo.attributes.position;
+        for (let i = 0; i < pts.length && i < this.N; i++) {
+            posL.setXYZ(i, pts[i].x, pts[i].y, pts[i].z);
+            posP.setXYZ(i, pts[i].x, pts[i].y, pts[i].z);
+        }
+        posL.needsUpdate = true;
+        posP.needsUpdate = true;
+    }
+    build() {
+        const { boltCount, branchDepth, color, glowColor, opacity, intensity, strikeRadius } = this.config;
+        this.depth = Math.min(Math.max(branchDepth, 2), 6);
+        this.N = Math.pow(2, this.depth) + 1;
+        this.sr = this.boundingRadius * strikeRadius;
+        this.coreCol = new THREE.Color(color);
+        this.glowCol = new THREE.Color(glowColor);
+        const glowVec = new THREE.Vector3(this.glowCol.r, this.glowCol.g, this.glowCol.b);
+        this.lineMat = new THREE.LineBasicMaterial({
+            vertexColors: true,
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+        this.bolts = Array.from({ length: boltCount }, (_, bi) => {
+            const seed = bi * 997 + 1;
+            const rng = makeRng(seed);
+            const [o, t] = this.boltEndpoints(rng);
+            const pts = fractalPolyline(o, t, this.depth, rng);
+            const col = new Float32Array(this.N * 3);
+            const bri = new Float32Array(this.N);
+            const { lineGeo, pointGeo } = this.makeGeos(pts, col, bri);
+            return {
+                phase: 'wait', timer: (bi / boltCount) * 1.8,
+                progress: 0, seed, waitDur: 0.5 + rng() * 1.0,
+                points: pts, colBuf: col, brightBuf: bri, lineGeo, pointGeo,
+            };
+        });
+        this.glowMats = this.bolts.map(() => new THREE.ShaderMaterial({
+            vertexShader: glowVert,
+            fragmentShader: glowFrag,
+            uniforms: {
+                uPointSize: { value: 6 * intensity },
+                uColor: { value: glowVec },
+                uOpacity: { value: opacity * 0.12 },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        }));
+        this.materials.push(...this.glowMats);
+        const lineObjects = this.bolts.map(bolt => new THREE.Line(bolt.lineGeo, this.lineMat));
+        for (let bi = 0; bi < boltCount; bi++) {
+            this.group.add(lineObjects[bi]);
+            this.group.add(new THREE.Points(this.bolts[bi].pointGeo, this.glowMats[bi]));
+        }
+    }
+    update(_elapsed, delta = 0.016) {
+        const { speed, opacity } = this.config;
+        const dt = delta * speed;
+        this.bolts.forEach((bolt, bi) => {
+            switch (bolt.phase) {
+                case 'wait':
+                    bolt.timer -= delta;
+                    bolt.colBuf.fill(0);
+                    bolt.brightBuf.fill(0);
+                    bolt.lineGeo.attributes.color.needsUpdate = true;
+                    bolt.pointGeo.attributes.aBrightness.needsUpdate = true;
+                    if (bolt.timer <= 0) {
+                        this.rebuildShape(bolt);
+                        bolt.phase = 'travel';
+                    }
+                    break;
+                case 'travel':
+                    bolt.progress += dt * 8.0;
+                    if (bolt.progress >= 1) {
+                        bolt.progress = 1;
+                        bolt.phase = 'flash';
+                        bolt.timer = 0.06 + Math.random() * 0.05;
+                    }
+                    this.refreshColors(bolt, 1.0);
+                    break;
+                case 'flash': {
+                    bolt.timer -= delta;
+                    const flashBoost = 1.0 + Math.max(0, bolt.timer / 0.08) * 2.5;
+                    this.refreshColors(bolt, flashBoost);
+                    if (bolt.timer <= 0) {
+                        bolt.phase = 'fade';
+                        bolt.timer = FADE_DUR;
+                    }
+                    break;
+                }
+                case 'fade': {
+                    bolt.timer -= delta;
+                    const ratio = Math.max(0, bolt.timer / FADE_DUR);
+                    this.refreshColors(bolt, ratio);
+                    this.glowMats[bi].uniforms.uOpacity.value = opacity * 0.12 * ratio;
+                    if (bolt.timer <= 0) {
+                        bolt.phase = 'wait';
+                        bolt.timer = bolt.waitDur;
+                        this.glowMats[bi].uniforms.uOpacity.value = opacity * 0.12;
+                    }
+                    break;
+                }
+            }
+        });
+    }
+    updateConfig(config, boundingRadius) {
+        this.config = config;
+        if (boundingRadius !== undefined)
+            this.boundingRadius = boundingRadius;
+        this.dispose(false);
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        this.bolts.forEach(bolt => {
+            bolt.lineGeo.dispose();
+            bolt.pointGeo.dispose();
+        });
+        this.bolts = [];
+        this.lineMat?.dispose();
+        this.lineMat = null;
+        this.materials.forEach(m => m.dispose());
+        this.materials = [];
+        this.glowMats = [];
+        this.group.clear();
+        if (removeFromScene && this.group.parent)
+            this.group.parent.remove(this.group);
+    }
+}

package/dist/three/effects/MoleculesEffectV.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import type { MoleculesConfig } from "../../types/generativeEffects";
+export declare class MoleculesEffectV {
+    private scene;
+    private group;
+    private materials;
+    private config;
+    private boundingRadius;
+    private nodeGeo;
+    private nodeMat;
+    private bondGeo;
+    private bondMat;
+    private tRef;
+    private orbitalParams;
+    private atomPos;
+    private tmpCol;
+    constructor(scene: THREE.Scene, config: MoleculesConfig, boundingRadius?: number);
+    private build;
+    update(elapsed: number, delta?: number): void;
+    updateConfig(config: MoleculesConfig, boundingRadius?: number): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=MoleculesEffectV.d.ts.map

package/dist/three/effects/MoleculesEffectV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MoleculesEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/MoleculesEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAiDrE,qBAAa,gBAAgB;IACzB,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,cAAc,CAAC;IACvB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,IAAI,CAAuB;IACnC,OAAO,CAAC,aAAa,CAAM;IAC3B,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,MAAM,CAAqB;gBACvB,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,cAAc,GAAE,MAAU;IAQnF,OAAO,CAAC,KAAK;IAuEb,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IAqCpD,YAAY,CAAC,MAAM,EAAE,eAAe,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOpE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAkBjD"}

package/dist/three/effects/MoleculesEffectV.js

@@ -0,0 +1,204 @@
+import * as THREE from 'three';
+const nodeVertShader = /* glsl */ `
+  attribute float aPhase;
+  attribute float aSize;
+
+  uniform float u_time;
+  uniform float uPointSize;
+  uniform float uIntensity;
+
+  varying float vAlpha;
+  varying vec3  vColor;
+
+  vec3 hsv2rgb(float h, float s, float v){
+    vec3 rgb=clamp(abs(mod(h*6.+vec3(0.,4.,2.),6.)-3.)-1.,0.,1.);
+    return v*mix(vec3(1.),rgb,s);
+  }
+
+  void main() {
+    float hue    = mod(aPhase + u_time * 0.08, 1.0);
+    float pulse  = 0.5 + 0.5 * sin(u_time * 2.5 + aPhase * 6.28);
+    vColor       = hsv2rgb(hue, 0.85, 1.0);
+    vAlpha       = 0.55 + 0.45 * pulse;
+
+    vec4 mv       = modelViewMatrix * vec4(position, 1.0);
+    gl_PointSize  = uPointSize * aSize * (0.6 + 0.4 * pulse) * uIntensity * (250.0 / -mv.z);
+    gl_Position   = projectionMatrix * mv;
+  }
+`;
+const nodeFragShader = /* glsl */ `
+  varying float vAlpha;
+  varying vec3  vColor;
+  uniform float uOpacity;
+
+  void main() {
+    vec2  coord = gl_PointCoord - vec2(0.5);
+    float dist  = length(coord);
+    if (dist > 0.5) discard;
+
+    float glow = exp(-dist * dist * 8.0);
+    float cx   = exp(-abs(coord.x) * 20.0) * exp(-coord.y*coord.y * 36.0);
+    float cy   = exp(-abs(coord.y) * 20.0) * exp(-coord.x*coord.x * 36.0);
+    float spike = (cx + cy) * 0.5;
+    float core  = exp(-dist * dist * 80.0);
+
+    vec3 col = mix(vColor, vec3(1.0), core * 0.8 + spike * 0.2);
+    gl_FragColor = vec4(col, vAlpha * uOpacity * (glow + spike * 0.6 + core));
+  }
+`;
+export class MoleculesEffectV {
+    scene;
+    group;
+    materials = [];
+    config;
+    boundingRadius;
+    nodeGeo = null;
+    nodeMat = null;
+    bondGeo = null;
+    bondMat = null;
+    tRef = new Float32Array(0);
+    orbitalParams = [];
+    atomPos = [];
+    tmpCol = new THREE.Color();
+    constructor(scene, config, boundingRadius = 1) {
+        this.scene = scene;
+        this.config = config;
+        this.boundingRadius = boundingRadius;
+        this.group = new THREE.Group();
+        scene.add(this.group);
+        this.build();
+    }
+    build() {
+        const { atomCount, orbitRadius, atomSize, showBonds, opacity, intensity } = this.config;
+        const r = this.boundingRadius * orbitRadius;
+        const PHI = 1.6180339887;
+        const pairs = [
+            [1, 2, 3], [2, 3, 1], [3, 1, 2], [1, 3, 2], [2, 1, 3], [3, 2, 1],
+            [1, 1, 2], [2, 2, 1], [1, 2, 2], [2, 1, 1], [3, 3, 2], [2, 3, 3],
+        ];
+        this.orbitalParams = Array.from({ length: atomCount }, (_, i) => {
+            const [fx, fy, fz] = pairs[i % pairs.length];
+            return {
+                fx, fy, fz,
+                px: (i * PHI * Math.PI) % (Math.PI * 2),
+                py: (i * PHI * PHI * Math.PI) % (Math.PI * 2),
+                pz: (i * Math.pow(PHI, 3) * Math.PI) % (Math.PI * 2),
+                hueBase: i / Math.max(atomCount - 1, 1),
+                speedMult: 0.65 + (i % 7) * 0.07,
+            };
+        });
+        this.tRef = new Float32Array(atomCount);
+        for (let i = 0; i < atomCount; i++)
+            this.tRef[i] = (i / atomCount) * Math.PI * 2;
+        this.atomPos = Array.from({ length: atomCount }, () => new THREE.Vector3());
+        // Node geometry
+        const phases = new Float32Array(atomCount);
+        const sizes = new Float32Array(atomCount);
+        for (let i = 0; i < atomCount; i++) {
+            phases[i] = i / atomCount;
+            sizes[i] = 0.8 + Math.random() * 0.6;
+        }
+        const nodeGeo = new THREE.BufferGeometry();
+        nodeGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(atomCount * 3), 3));
+        nodeGeo.setAttribute('aPhase', new THREE.BufferAttribute(phases, 1));
+        nodeGeo.setAttribute('aSize', new THREE.BufferAttribute(sizes, 1));
+        const nodeMat = new THREE.ShaderMaterial({
+            vertexShader: nodeVertShader,
+            fragmentShader: nodeFragShader,
+            uniforms: {
+                u_time: { value: 0 },
+                uPointSize: { value: atomSize * 200 },
+                uIntensity: { value: intensity },
+                uOpacity: { value: opacity },
+            },
+            transparent: true,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+        });
+        this.nodeGeo = nodeGeo;
+        this.nodeMat = nodeMat;
+        this.materials.push(nodeMat);
+        this.group.add(new THREE.Points(nodeGeo, nodeMat));
+        // Bond geometry
+        if (showBonds) {
+            const vertCount = atomCount * 2;
+            const bondGeo = new THREE.BufferGeometry();
+            const positions = new Float32Array(vertCount * 3);
+            const colors = new Float32Array(vertCount * 3);
+            bondGeo.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+            bondGeo.setAttribute('color', new THREE.BufferAttribute(colors, 3));
+            const bondMat = new THREE.LineBasicMaterial({
+                vertexColors: true,
+                transparent: true,
+                opacity: opacity * 0.7,
+                depthWrite: false,
+                blending: THREE.AdditiveBlending,
+            });
+            this.bondGeo = bondGeo;
+            this.bondMat = bondMat;
+            this.group.add(new THREE.LineSegments(bondGeo, bondMat));
+        }
+    }
+    update(elapsed, delta = 0.016) {
+        const { atomCount, orbitRadius, showBonds, speed } = this.config;
+        const r = this.boundingRadius * orbitRadius;
+        if (!this.nodeMat || !this.nodeGeo)
+            return;
+        this.nodeMat.uniforms.u_time.value = elapsed;
+        const nodePos = this.nodeGeo.attributes.position;
+        for (let i = 0; i < atomCount; i++) {
+            this.tRef[i] += delta * speed * this.orbitalParams[i].speedMult;
+            const a = this.tRef[i];
+            const p = this.orbitalParams[i];
+            const x = Math.cos(p.fx * a + p.px) * r;
+            const y = Math.sin(p.fy * a + p.py) * r * 0.75;
+            const z = Math.sin(p.fz * a + p.pz) * r;
+            this.atomPos[i].set(x, y, z);
+            nodePos.setXYZ(i, x, y, z);
+        }
+        nodePos.needsUpdate = true;
+        if (showBonds && this.bondGeo) {
+            const bondPos = this.bondGeo.attributes.position;
+            const bondCol = this.bondGeo.attributes.color;
+            for (let i = 0; i < atomCount; i++) {
+                const curr = this.atomPos[i];
+                const next = this.atomPos[(i + 1) % atomCount];
+                bondPos.setXYZ(i * 2, curr.x, curr.y, curr.z);
+                bondPos.setXYZ(i * 2 + 1, next.x, next.y, next.z);
+                const hue0 = (this.orbitalParams[i].hueBase + elapsed * 0.07) % 1;
+                const hue1 = (this.orbitalParams[(i + 1) % atomCount].hueBase + elapsed * 0.07) % 1;
+                this.tmpCol.setHSL(hue0, 1.0, 0.6);
+                bondCol.setXYZ(i * 2, this.tmpCol.r, this.tmpCol.g, this.tmpCol.b);
+                this.tmpCol.setHSL(hue1, 1.0, 0.6);
+                bondCol.setXYZ(i * 2 + 1, this.tmpCol.r, this.tmpCol.g, this.tmpCol.b);
+            }
+            bondPos.needsUpdate = true;
+            bondCol.needsUpdate = true;
+        }
+    }
+    updateConfig(config, boundingRadius) {
+        this.config = config;
+        if (boundingRadius !== undefined)
+            this.boundingRadius = boundingRadius;
+        this.dispose(false);
+        this.build();
+    }
+    dispose(removeFromScene = true) {
+        this.group.traverse(child => {
+            const c = child;
+            if (c.geometry)
+                c.geometry.dispose();
+        });
+        this.materials.forEach(m => m.dispose());
+        if (this.bondMat)
+            this.bondMat.dispose();
+        this.materials = [];
+        this.nodeGeo = null;
+        this.nodeMat = null;
+        this.bondGeo = null;
+        this.bondMat = null;
+        this.group.clear();
+        if (removeFromScene && this.group.parent)
+            this.group.parent.remove(this.group);
+    }
+}

package/dist/three/effects/NeuralNetworkEffectV.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import type { NeuralNetworkConfig } from "../../types/generativeEffects";
+export declare class NeuralNetworkEffectV {
+    private scene;
+    private group;
+    private materials;
+    private config;
+    private boundingRadius;
+    private orbitAngles;
+    private pulses;
+    private nextPulse;
+    private effectScene;
+    private tmpMat;
+    private tmpQuat;
+    private tmpVec;
+    private N;
+    constructor(scene: THREE.Scene, config: NeuralNetworkConfig, boundingRadius?: number);
+    private build;
+    update(_elapsed: number, delta?: number): void;
+    updateConfig(config: NeuralNetworkConfig, boundingRadius?: number): void;
+    dispose(removeFromScene?: boolean): void;
+}
+//# sourceMappingURL=NeuralNetworkEffectV.d.ts.map

package/dist/three/effects/NeuralNetworkEffectV.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NeuralNetworkEffectV.d.ts","sourceRoot":"","sources":["../../../src/three/effects/NeuralNetworkEffectV.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AA2BzE,qBAAa,oBAAoB;IAC7B,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,KAAK,CAAC;IACd,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,MAAM,CAAC;IACf,OAAO,CAAC,cAAc,CAAC;IACvB,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,WAAW,CAAQ;IAC3B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,CAAC,CAAM;gBACH,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,mBAAmB,EAAE,cAAc,GAAE,MAAU;IAQvF,OAAO,CAAC,KAAK;IAiFb,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,IAAI;IA2DrD,YAAY,CAAC,MAAM,EAAE,mBAAmB,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI;IAOxE,OAAO,CAAC,eAAe,GAAE,OAAc,GAAG,IAAI;CAejD"}