@3driseai/3drise-viewer 0.1.40 → 0.1.41

package/dist/components/gallery/looks/loom.js

@@ -0,0 +1,256 @@
+// The approved lab module, verbatim but for its import paths and the lab's picture loader (Claude outputs/gallery-lab/
+// loom.mjs). Plain JS-shaped code (the viewer compiles non-strict); typed at its one door, kit/GalleryVariant.tsx. Its own DEFAULTS only fill knobs the
+// core defaults (DEFAULT_GALLERY_OBJECTS.loom) do not carry; its own autoplay is never used.
+// loom — the picture is woven. A taut warp of fine threads is always there, for every picture in the row. The
+// image is the weft: one horizontal thread per row, carrying its row of the picture. An inactive picture is a sparse
+// grey weave — thin grey weft threads with the warp showing between them. When a picture becomes the active one a
+// soft diagonal wave crosses it from the top-left: under the wave each weft thread swells to fill its row and takes
+// its colour, until the cloth is closed and the warp disappears under the picture. Leaving runs the wave back. Each
+// picture follows its own active value at a constant rate, so the wave never jumps and can reverse half-way.
+// Self-coloured: no lighting of its own. Cursor: a soft reveal — the grey weave swells and colours where it passes.
+import * as THREE from 'three';
+import { fragHead, col, mulberry32, createScroll, focusAt, approach, withLean } from '../kit/galleryKit.js';
+import { createLayout, layoutUniforms, fillLayout, layoutGlsl, LAYOUT_GUI } from '../kit/galleryKit.js';
+export const catalog = { key: 'loom', name: 'Loom', camera: { position: [0.4, 0.15, 4.9], target: [0, 0, 0] },
+    description: 'Pictures woven on a loom: inactive pictures are a sparse grey weave of thin threads over a fine warp; the active one is woven closed in full colour by a soft diagonal wave, and a change unravels it the same way. Use for craft, textiles, slow reveals, graphic showcases.',
+    tags: ['gallery', 'loom', 'weave', 'threads', 'reveal', 'navigation', 'interactive'] };
+export const DEFAULTS = {
+    type: 'loom', enabled: true, lean: 1, imageUrls: [], autoplay: 0, intensity: 1, opacity: 1,
+    aspect: 1.5, width: 2.4, warp: 150, weft: 96, // structural
+    layout: 'row', spacing: 1.3, depth: 1.0, visible: 2.2, shape: 1, dim: 0.35,
+    stiffness: 30, damping: 9, throwing: 0.12,
+    weaveTime: 2.2, unravelTime: 1.6, wave: 0.35, slant: 0.35, thread: 0.22, shuttle: 0.3, weave: 0.25, warpGlow: 0.22,
+    warpColor: '#d8c9a8', shuttleColor: '#ffd9a6',
+    pointerMode: 'reveal', pointerStrength: 1, pointerRadius: 0.5, pointerColor: '#ffd9a6',
+};
+export const STRUCTURAL = ['imageUrls', 'aspect', 'width', 'warp', 'weft'];
+export const POINTER_MODES = ['reveal'];
+export const GUI = [
+    { key: 'lean', min: 0, max: 3, step: 0.01, tip: 'The gallery turns toward the cursor' },
+    { key: 'aspect', min: 0.6, max: 2.5, step: 0.01 }, { key: 'width', min: 1, max: 4, step: 0.01 }, { key: 'warp', min: 30, max: 300, step: 1 }, { key: 'weft', min: 20, max: 160, step: 1 },
+    ...LAYOUT_GUI, { key: 'dim', min: 0, max: 1, step: 0.01 },
+    { key: 'stiffness', min: 5, max: 120, step: 1 }, { key: 'damping', min: 2, max: 30, step: 0.1 },
+    { key: 'weaveTime', min: 0.5, max: 8, step: 0.1 }, { key: 'unravelTime', min: 0.3, max: 6, step: 0.1 },
+    { key: 'wave', min: 0.05, max: 1, step: 0.01, tip: 'Softness of the weaving wave' }, { key: 'slant', min: 0, max: 1, step: 0.01, tip: 'How diagonal the wave is' },
+    { key: 'thread', min: 0.05, max: 0.8, step: 0.01, tip: 'Thickness of the inactive weft threads' }, { key: 'shuttle', min: 0, max: 1.5, step: 0.01, tip: 'A faint brightening on the wave' }, { key: 'weave', min: 0, max: 1, step: 0.01 }, { key: 'warpGlow', min: 0, max: 2, step: 0.01 }, { key: 'autoplay', min: 0, max: 20, step: 0.5 },
+    { key: 'pointerMode', options: ['none', ...POINTER_MODES] }, { key: 'pointerStrength', min: 0, max: 3, step: 0.01 }, { key: 'pointerRadius', min: 0.2, max: 3, step: 0.01 },
+    { key: 'intensity', min: 0, max: 3, step: 0.01 }, { key: 'opacity', min: 0, max: 1, step: 0.01 },
+    { key: 'warpColor', color: true }, { key: 'shuttleColor', color: true }, { key: 'pointerColor', color: true },
+];
+export const PRESETS = [
+    { name: 'Loom', description: 'The default.', patch: {} },
+    { name: 'Fine cloth', description: 'Dense warp and weft, quick weaving.', patch: { warp: 240, weft: 140, weaveTime: 1.6, thread: 0.3 } },
+    { name: 'Tapestry', description: 'Coarse threads, a slow, soft wave.', patch: { warp: 60, weft: 40, weaveTime: 3.6, wave: 0.6, thread: 0.18, warpGlow: 0.35 } },
+    { name: 'Curtain', description: 'A straight wave straight down.', patch: { slant: 0, wave: 0.2 } },
+];
+const MAXI = 32;
+export function createUniforms() {
+    return {
+        ...layoutUniforms(), uTex: { value: null }, uS: { value: 0 }, uCount: { value: 1 }, uTime: { value: 0 },
+        uWoven: { value: new Float32Array(MAXI).fill(0) }, // 0..1 rows woven (from the top); >1 none
+        uSpacing: { value: 1.3 }, uDepth: { value: 1 }, uVisible: { value: 2.2 }, uDim: { value: 0.35 },
+        uShuttle: { value: 0.3 }, uWave: { value: 0.35 }, uSlant: { value: 0.35 }, uThread: { value: 0.22 }, uWeave: { value: 0.6 }, uWarpGlow: { value: 0.5 }, uSway: { value: 0.3 }, uIntensity: { value: 1 }, uOpacity: { value: 1 },
+        uWarpColor: { value: col('#d8c9a8') }, uRimColor: { value: col('#ffe2b8') }, uShuttleColor: { value: col('#ffd9a6') }, uPointerColor: { value: col('#ffd9a6') },
+        uPointer: { value: new THREE.Vector3() }, uPointerActive: { value: 0 }, uPointerMode: { value: 0 }, uPointerStrength: { value: 1 }, uPointerRadius: { value: 0.6 },
+        uW: { value: 2.4 }, uH: { value: 1.6 }, uNw: { value: 120 }, uNf: { value: 72 }, uKey: { value: new THREE.Vector3(0.4, 0.5, 0.75).normalize() },
+    };
+}
+export function applyConfig(u, c) {
+    const set = (k, v) => { if (v === undefined)
+        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('uSpacing', c.spacing);
+    set('uDepth', c.depth);
+    set('uVisible', c.visible);
+    set('uDim', c.dim);
+    set('uShuttle', c.shuttle);
+    set('uWave', c.wave);
+    set('uSlant', c.slant);
+    set('uThread', c.thread);
+    set('uWeave', c.weave);
+    set('uWarpGlow', c.warpGlow);
+    set('uSway', c.sway);
+    set('uIntensity', c.intensity);
+    set('uOpacity', c.opacity);
+    set('uWarpColor', c.warpColor);
+    set('uShuttleColor', c.shuttleColor);
+    set('uPointerColor', c.pointerColor);
+    set('uPointerStrength', c.pointerStrength);
+    set('uPointerRadius', c.pointerRadius);
+    if (c.pointerMode !== undefined)
+        u.uPointerMode.value = POINTER_MODES.indexOf(c.pointerMode);
+}
+const common = /* glsl */ `
+    uniform float uS, uCount, uTime, uSpacing, uDepth, uVisible, uSway, uW, uH, uNw, uNf;
+    uniform float uWoven[${MAXI}];
+    uniform vec3 uPointer; uniform float uPointerActive, uPointerMode, uPointerStrength, uPointerRadius;
+    ${layoutGlsl}
+    float wrapd(float d, float n){ return n > 1.0 ? mod(d + n * 0.5, n) - n * 0.5 : d; }
+    float focusOf(float img, out float d){ d = wrapd(img - uS, uCount); return 1.0 - smoothstep(0.0, 1.0, abs(d)); }
+`;
+// warp: one vertical thread per instance per picture
+const warpVert = /* glsl */ `
+    attribute vec4 aInst;   // image, k, hash, hash2
+    ${common}
+    varying float vFocus; varying float vAlpha; varying float vH; varying vec3 vN; varying vec3 vV; varying float vPw; varying float vY; varying float vWoven;
+    void main(){
+        vWoven = uWoven[int(aInst.x + 0.5)];
+        float img = aInst.x, k = aInst.y, h1 = aInst.z; float d; float focus = focusOf(img, d);
+        float x = (k / uNw - 0.5) * uW + 0.5 / uNw * uW;
+        vec3 p = placeAt(img, vec3(x + position.x, position.y * uH, 0.0));
+        vec2 dp = p.xy - uPointer.xy; float dist = length(dp);
+        float pw = uPointerActive * (1.0 - smoothstep(0.0, uPointerRadius, dist));
+        vPw = pw; vY = position.y + 0.5;
+        vFocus = focus; vAlpha = fadeAt(img); vH = h1;
+        vec4 mv = modelViewMatrix * vec4(p, 1.0); vN = normalize(normalMatrix * vec3(0.0, 0.0, 1.0)); vV = -mv.xyz;
+        gl_Position = projectionMatrix * mv;
+    }
+`;
+const warpFrag = /* glsl */ `
+    ${fragHead}
+    uniform float uWarpGlow, uDim, uIntensity, uOpacity, uPointerMode; uniform vec3 uWarpColor, uRimColor, uKey, uPointerColor;
+    varying float vFocus; varying float vAlpha; varying float vH; varying vec3 vN; varying vec3 vV; varying float vPw; varying float vY; varying float vWoven;
+    void main(){
+        vec3 c = uWarpColor * uWarpGlow * (0.75 + 0.25 * vH);
+        c *= 1.0 - uDim * (1.0 - vFocus) * 0.6;
+        // the closed cloth hides the warp
+        float a = vAlpha * uOpacity * (1.0 - 0.9 * smoothstep(0.5, 1.0, vWoven));
+        if (a < 0.003) discard;
+        gl_FragColor = vec4(c * uIntensity * a, a);
+        #include <tonemapping_fragment>
+        #include <colorspace_fragment>
+    }
+`;
+// weft: one horizontal thread per row per picture, revealed by the shuttle
+const weftVert = /* glsl */ `
+    attribute vec4 aInst;   // image, row j, hash, hash2
+    ${common}
+    uniform float uWeave;
+    varying vec2 vUv; varying float vImg; varying float vFocus; varying float vAlpha; varying float vWoven; varying float vRowT; varying float vRow; varying float vPw; varying float vV;
+    void main(){
+        vV = position.y + 0.5;
+        float img = aInst.x, j = aInst.y, h1 = aInst.z; float d; float focus = focusOf(img, d);
+        int ii = int(img + 0.5); float woven = uWoven[ii];
+        float rowT = (j + 0.5) / uNf;                   // 0 at the top
+        float y = (0.5 - rowT) * uH;
+        float z = (mod(j, 2.0) < 0.5 ? 1.0 : -1.0) * uWeave * 0.006;   // over / under the warp
+        float xLocal = (uv.x - 0.5) * uW;
+        vWoven = woven; vRowT = rowT;
+        vec3 p = placeAt(img, vec3(xLocal, y + position.y * (uH / uNf), z));
+        vec2 dp = p.xy - uPointer.xy; float dist = length(dp);
+        float pw = uPointerActive * uPointerStrength * (1.0 - smoothstep(uPointerRadius * 0.35, uPointerRadius, dist)); vPw = pw;
+        vUv = vec2(uv.x, 1.0 - rowT); vImg = img; vFocus = focus; vRow = j;
+        vAlpha = fadeAt(img);
+        gl_Position = projectionMatrix * modelViewMatrix * vec4(p, 1.0);
+    }
+`;
+const weftFrag = /* glsl */ `
+    ${fragHead}
+    precision highp sampler2DArray;
+    uniform sampler2DArray uTex; uniform float uDim, uShuttle, uWave, uSlant, uThread, uIntensity, uOpacity, uPointerMode; uniform vec3 uShuttleColor, uPointerColor;
+    varying vec2 vUv; varying float vImg; varying float vFocus; varying float vAlpha; varying float vWoven; varying float vRowT; varying float vRow; varying float vPw; varying float vV;
+    void main(){
+        // the wave: a soft diagonal front from the top-left; behind it the cloth is closed and coloured
+        float pos = mix(vRowT, vUv.x, uSlant * 0.5) ;                       // 0 at the top-left .. ~1 at the bottom-right
+        float front = vWoven * (1.0 + uWave) - uWave * 0.5;
+        float w = smoothstep(front + uWave * 0.5, front - uWave * 0.5, pos);
+        w = w * w * (3.0 - 2.0 * w);
+        float act = max(w, vPw * step(-0.5, uPointerMode) * (1.0 - w) * 0.85);
+        // the weft thread: thin when grey, swelling to fill its row (covering the warp) as it is woven
+        float thick = mix(uThread, 1.12, act);                              // a little over 1: the closed cloth has no gaps
+        float y = abs(vV - 0.5) * 2.0;                                       // 0 on the thread's crown, 1 at the row's edge
+        float aa = fwidth(y) * 1.5;
+        float body = 1.0 - smoothstep(thick - aa, thick + aa, y);
+        if (body < 0.003) discard;
+        float round = 0.8 + 0.2 * sqrt(max(0.0, 1.0 - (y / max(thick, 0.001)) * (y / max(thick, 0.001))));
+        vec3 pic = texture(uTex, vec3(vUv, vImg)).rgb;
+        float lum = dot(pic, vec3(0.299, 0.587, 0.114));
+        vec3 faded = vec3(0.12 + 0.88 * lum) * uDim;
+        vec3 c = mix(faded, pic * 1.08, act) * mix(round, 1.0, act * act);
+        c += (pic + uShuttleColor * 0.3) * uShuttle * 0.5 * (w * (1.0 - w) * 4.0) * vWoven * (1.0 - vWoven) * 4.0;   // faint, only while weaving
+        float a = vAlpha * uOpacity * body * mix(0.85, 1.0, act);
+        if (a < 0.003) discard;
+        gl_FragColor = vec4(c * uIntensity * a, a);
+        #include <tonemapping_fragment>
+        #include <colorspace_fragment>
+    }
+`;
+export function build(u, c) { return withLean(buildGallery(u, c), c); }
+function buildGallery(u, c) {
+    const Nw = Math.max(10, c.warp | 0), Nf = Math.max(8, c.weft | 0), W = c.width, H = W / c.aspect;
+    u.uW.value = W;
+    u.uH.value = H;
+    u.uNw.value = Nw;
+    u.uNf.value = Nf;
+    const rnd = mulberry32(4);
+    const mk = (per, q) => { const geo = new THREE.InstancedBufferGeometry(); geo.index = q.index; geo.attributes.position = q.attributes.position; geo.attributes.uv = q.attributes.uv; const a = new Float32Array(MAXI * per * 4); for (let i = 0; i < MAXI; i++)
+        for (let k = 0; k < per; k++)
+            a.set([i, k, rnd(), rnd()], (i * per + k) * 4); geo.setAttribute('aInst', new THREE.InstancedBufferAttribute(a, 4)); geo.instanceCount = 0; geo.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 20); return geo; };
+    const warpGeo = mk(Nw, new THREE.PlaneGeometry(W / Nw * 0.22, 1));
+    const weftGeo = mk(Nf, new THREE.PlaneGeometry(W, 1));
+    const warpMat = new THREE.ShaderMaterial({ uniforms: u, vertexShader: warpVert, fragmentShader: warpFrag, glslVersion: THREE.GLSL3, side: THREE.DoubleSide, transparent: true, depthWrite: true, premultipliedAlpha: true });
+    const weftMat = new THREE.ShaderMaterial({ uniforms: u, vertexShader: weftVert, fragmentShader: weftFrag, glslVersion: THREE.GLSL3, side: THREE.DoubleSide, transparent: true, depthWrite: true, premultipliedAlpha: true });
+    const warp = new THREE.Mesh(warpGeo, warpMat);
+    warp.frustumCulled = false;
+    warp.raycast = () => { };
+    const weft = new THREE.Mesh(weftGeo, weftMat);
+    weft.frustumCulled = false;
+    weft.raycast = () => { };
+    const beamMat = new THREE.MeshStandardMaterial({ color: '#4a3a2a', roughness: 0.7 });
+    const beamT = new THREE.Mesh(new THREE.CylinderGeometry(0.02, 0.02, 1, 10), beamMat);
+    beamT.rotation.z = Math.PI / 2;
+    beamT.position.y = H / 2 + 0.03;
+    const beamB = beamT.clone();
+    beamB.position.y = -H / 2 - 0.03;
+    const pick = new THREE.Mesh(new THREE.PlaneGeometry(W, H), new THREE.MeshBasicMaterial({ visible: false }));
+    const object = new THREE.Group();
+    object.add(warp, weft, pick);
+    beamT.visible = beamB.visible = false;
+    const cfg = { ...c };
+    const scroll = createScroll(cfg, () => { });
+    scroll.st.pitch = W * c.spacing;
+    const st = { time: 0, prevIndex: 0, unravel: new Float32Array(MAXI) };
+    const woven = u.uWoven.value;
+    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; warpGeo.instanceCount = scroll.st.count * Nw; weftGeo.instanceCount = scroll.st.count * Nf; woven.fill(0); woven[controls.index] = 1; } });
+    object.userData.gallery = controls;
+    const _inv = new THREE.Matrix4(), _p = new THREE.Vector3();
+    const layout = createLayout(W, H);
+    return {
+        object, controls, pickMesh: pick, materials: [warpMat, weftMat, beamMat],
+        apply(k) { Object.assign(cfg, k); applyConfig(u, k); scroll.st.pitch = W * cfg.spacing; },
+        update(dt, pointer) {
+            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 idx = controls.index, n = scroll.st.count;
+            fillLayout(layout, u, scroll.st.s, n, cfg);
+            for (let i = 0; i < n; i++) {
+                const on = focusAt(i, scroll.st.s, n) > 0.5;
+                woven[i] = approach(woven[i], on ? 1 : 0, dt, on ? cfg.weaveTime : cfg.unravelTime);
+            }
+            const span = Math.min(n, 2 * cfg.visible + 1) * W * cfg.spacing;
+            beamT.scale.set(1, span, 1);
+            beamB.scale.set(1, span, 1);
+            beamT.position.x = beamB.position.x = 0;
+            pick.position.x = 0;
+            if (pointer) {
+                weft.parent.updateMatrix();
+                _inv.copy(weft.parent.matrix).invert(); /* the cursor arrives in the gallery's own frame; undo the lean */
+                _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 * 6));
+        },
+        dispose() { warpGeo.dispose(); weftGeo.dispose(); warpMat.dispose(); weftMat.dispose(); beamT.geometry.dispose(); beamMat.dispose(); pick.geometry.dispose(); if (u.uTex.value)
+            u.uTex.value.dispose(); },
+    };
+}

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

@@ -0,0 +1,181 @@
+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;
+    radius: number;
+    spacing: number;
+    sag: number;
+    span: number;
+    cord: number;
+    focusDrop: number;
+    focusLift: number;
+    visible: number;
+    stiffness: number;
+    damping: number;
+    throwing: number;
+    gravity: number;
+    swingDamping: number;
+    wind: number;
+    tug: number;
+    glow: number;
+    lamp: number;
+    lampColor: string;
+    paperColor: string;
+    rimColor: string;
+    ringColor: 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: {
+        wind?: undefined;
+        swingDamping?: undefined;
+        gravity?: undefined;
+        span?: undefined;
+        sag?: undefined;
+        spacing?: undefined;
+        tug?: undefined;
+        glow?: undefined;
+        lamp?: undefined;
+        focusDrop?: undefined;
+        focusLift?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        wind: number;
+        swingDamping: number;
+        gravity: number;
+        span: number;
+        sag: number;
+        spacing: number;
+        tug?: undefined;
+        glow?: undefined;
+        lamp?: undefined;
+        focusDrop?: undefined;
+        focusLift?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        wind: number;
+        swingDamping: number;
+        gravity: number;
+        spacing: number;
+        sag: number;
+        tug: number;
+        span?: undefined;
+        glow?: undefined;
+        lamp?: undefined;
+        focusDrop?: undefined;
+        focusLift?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    patch: {
+        sag: number;
+        wind: number;
+        glow: number;
+        lamp: number;
+        focusDrop: number;
+        focusLift: number;
+        spacing: number;
+        swingDamping?: undefined;
+        gravity?: undefined;
+        span?: undefined;
+        tug?: undefined;
+    };
+})[];
+export declare function createUniforms(): {
+    uTex: {
+        value: any;
+    };
+    uGlow: {
+        value: number;
+    };
+    uLamp: {
+        value: number;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uLampColor: {
+        value: THREE.Color;
+    };
+    uPaperColor: {
+        value: THREE.Color;
+    };
+    uRimColor: {
+        value: THREE.Color;
+    };
+    uPointerColor: {
+        value: THREE.Color;
+    };
+    uTime: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare function build(u: any, c: any): any;
+//# sourceMappingURL=paperLanterns.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paperLanterns.d.ts","sourceRoot":"","sources":["../../../../src/components/gallery/looks/paperLanterns.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,UAAoC,CAAC;AAC5D,eAAO,MAAM,aAAa,UAAqB,CAAC;AAEhD,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYf,CAAC;AACF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKnB,CAAC;AAMF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO7B;AACD,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAI/B;AAuED,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,OAA6C"}