@3driseai/3drise-viewer 0.1.40 → 0.1.41

package/dist/components/image/core/lenticular.js

@@ -0,0 +1,132 @@
+// GENERATED from the lab (Claude outputs/gallery-lab/image/lenticular.mjs) by emit_image.mjs — change the lab and re-emit.
+// lenticular — an image variant (type 'image', config.type 'lenticular'). Material: MeshPhysicalMaterial (clearcoat;
+// lit by the scene; object effects attach).
+//
+// A lenticular print: a sheet of fine cylindrical lenses over an interleaved print — under every lens a strip of
+// the outgoing picture and a strip of the incoming one. Which strip a lens shows depends on the angle it is seen
+// from: q = 1/4 + (view . lens axis normal) * thickness + flip / 2, B when q falls in the second half (smoothed by the
+// lens blur, with a faint chromatic split at the boundary, as real prints ghost). A change sweeps `flip` across
+// the sheet; because the view angle is part of it, the boundary sits differently for every camera and moves when
+// the camera orbits or the object is turned — the change is seen *through* the lenses, not painted on. The lens ridges
+// are a normal perturbation on the clearcoat, so the scene's light draws fine vertical highlights that slide as
+// you move. At rest both strips carry the same picture: no artefact, only the ribbed gloss. Idle: a slow, very
+// low bow of the sheet rolls the highlights. Cursor: `peek` — the lenses near the cursor flip back to the
+// previous picture; `bend` — the sheet bows toward the cursor, so the ridge highlights roll (and, mid-change,
+// the flip line bends with it).
+import * as THREE from 'three';
+import { baseUniforms, applyBase, setU, createPicture, stepPointer, patchMaterial, aspectOf, fit } from './imageCore.js';
+export const POINTER_MODES = ['peek', 'bend'];
+export const STRUCTURAL = ['imageUrls'];
+export function createUniforms() {
+    return { ...baseUniforms(), uLenses: { value: 110 }, uThick: { value: 1.1 }, uSharp: { value: 0.55 }, uGhost: { value: 0.35 }, uRidge: { value: 0.5 }, uSelf: { value: 0.1 },
+        uTexP: { value: null }, uFitP: { value: new THREE.Vector2(1, 1) }, uHasP: { value: 0 } };
+}
+export function applyConfig(u, c) {
+    applyBase(u, c, POINTER_MODES);
+    setU(u, 'uLenses', c.lenses);
+    setU(u, 'uThick', c.thickness);
+    setU(u, 'uSharp', c.sharpness);
+    setU(u, 'uGhost', c.ghost);
+    setU(u, 'uRidge', c.ridge);
+    setU(u, 'uSelf', c.selfLight);
+}
+const pars = /* glsl */ `
+uniform float uLenses, uThick, uSharp, uGhost, uRidge, uSelf, uHasP; uniform sampler2D uTexP; uniform vec2 uFitP;
+varying vec2 vPic; varying vec3 vTanX; varying float vL;
+float bowAt(vec2 xy){
+  float z = uBreathe * 0.01 * sin(xy.x * 1.1 + uTime * 0.31) * cos(xy.y * 0.9 - uTime * 0.23);
+  if (uPointerMode > 0.5) z += 0.07 * pointerBump(xy);
+  return z;
+}
+`;
+const vertex = /* glsl */ `
+  vec2 uv0 = position.xy + 0.5;
+  vec2 xy = position.xy * uSize;
+  float e = 0.01;
+  float z0 = bowAt(xy), zx = bowAt(xy + vec2(e, 0.0)), zy = bowAt(xy + vec2(0.0, e));
+  vec3 tx = normalize(vec3(e, 0.0, zx - z0)), ty = normalize(vec3(0.0, e, zy - z0));
+  fxP = vec3(xy, z0);
+  fxN = normalize(cross(tx, ty));
+  vTanX = normalize((modelViewMatrix * vec4(tx, 0.0)).xyz);
+  vPic = uv0; vL = localP(uv0);
+`;
+// what a lens shows: B weight from the strip position q seen through it (cyclic), one channel offset for the ghost
+const diffuse = /* glsl */ `
+  vec3 V = normalize(vViewPosition);
+  float vx = dot(V, normalize(vTanX));
+  float flip = sstep(vL);
+  float k = mix(0.45, 0.04, uSharp);
+  float q = 0.25 + vx * uThick * 0.5 + 0.5 * flip;
+  float g = uGhost * 0.035;
+  vec3 wB = vec3(smoothstep(-k, k, sin(6.2831853 * (q - g - 0.5))), smoothstep(-k, k, sin(6.2831853 * (q - 0.5))), smoothstep(-k, k, sin(6.2831853 * (q + g - 0.5))));
+  vec3 pic = mix(picA(vPic), picB(vPic), wB);
+  if (uPointerMode > -0.5 && uPointerMode < 0.5 && uHasP > 0.5) {          // peek: lenses near the cursor flip to the previous picture
+    float pk = smoothstep(0.15, 0.85, pointerBump((vPic - 0.5) * uSize));
+    float qp = 0.25 + vx * uThick * 0.5 + 0.5 * pk;
+    float wp = smoothstep(-k, k, sin(6.2831853 * (qp - 0.5)));
+    vec3 prev = texture(uTexP, 0.5 + (vPic - 0.5) * uFitP).rgb;
+    pic = mix(pic, prev, wp * smoothstep(0.0, 0.35, pk));   // only where the cursor flips the lenses
+  }
+  // the lens boundaries: a hairline of shade where two lenses meet (faded out when lenses get smaller than a pixel)
+  float ph = vPic.x * uLenses;
+  float aa = 1.0 - smoothstep(0.2, 0.55, fwidth(ph));
+  float cell = fract(ph);
+  pic *= 1.0 - 0.1 * aa * pow(abs(cell - 0.5) * 2.0, 8.0);
+  diffuseColor.rgb = pic * uIntensity;
+  diffuseColor.a *= uOpacity;
+`;
+const ridgeN = /* glsl */ `
+  {
+    float ph = vPic.x * uLenses;
+    float aa = 1.0 - smoothstep(0.2, 0.55, fwidth(ph));
+    float nx = (fract(ph) - 0.5) * 2.0;                                 // across the cylinder: -1 .. 1
+    vec3 t = normalize(vTanX);
+    NAME = normalize(NAME + t * nx * 0.9 * uRidge * aa);
+  }
+`;
+const emissive = /* glsl */ `
+  totalEmissiveRadiance += diffuseColor.rgb * uSelf;
+`;
+export function build(u, c) {
+    const object = new THREE.Group();
+    const geo = new THREE.PlaneGeometry(1, 1, 64, 40);
+    const P = { key: 'lenticular', uniforms: u, pars, vertex, diffuse, emissive,
+        normalFrag: ridgeN.replace(/NAME/g, 'normal').replace('nx * 0.9', 'nx * 0.35'), clearcoatNormal: ridgeN.replace(/NAME/g, 'clearcoatNormal') };
+    const mat = patchMaterial(new THREE.MeshPhysicalMaterial({ roughness: c.roughness, metalness: 0, clearcoat: 1, clearcoatRoughness: c.gloss, side: THREE.DoubleSide }), P);
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    mesh.frustumCulled = false;
+    object.add(mesh);
+    const cfg = { ...c };
+    const pic = createPicture(u, cfg);
+    const pst = {};
+    let shown = null;
+    const api = {
+        object, materials: [mat],
+        controls: { show: (t) => pic.show(t), get busy() { return pic.busy; }, pic },
+        apply(k) { Object.assign(cfg, k); applyConfig(u, k); if (k.roughness !== undefined)
+            mat.roughness = k.roughness; if (k.gloss !== undefined)
+            mat.clearcoatRoughness = k.gloss; if (k.opacity !== undefined)
+            mat.transparent = k.opacity < 1; },
+        update(dt, pointer) {
+            dt = Math.min(dt, 0.1);
+            u.uTime.value += dt;
+            pic.step(dt);
+            stepPointer(u, pointer, dt, pst);
+            // the previous picture (for peek): the one the last completed change left behind
+            const st = pic.st;
+            if (st.dir === 0 && st.B && st.B !== shown) {
+                if (shown) {
+                    u.uTexP.value = shown;
+                    u.uHasP.value = 1;
+                }
+                shown = st.B;
+            }
+            if (u.uTexP.value)
+                fit(aspectOf(u.uTexP.value), st.frame, u.uFitP.value);
+        },
+        dispose() { geo.dispose(); mat.dispose(); pic.dispose(); },
+    };
+    return api;
+}

package/dist/components/image/core/pinscreen.d.ts

@@ -0,0 +1,126 @@
+import * as THREE from 'three';
+export declare const POINTER_MODES: string[];
+export declare const STRUCTURAL: string[];
+export declare function createUniforms(): {
+    uCols: {
+        value: THREE.Vector2;
+    };
+    uDepth: {
+        value: number;
+    };
+    uDip: {
+        value: number;
+    };
+    uPinSize: {
+        value: number;
+    };
+    uPinColor: {
+        value: THREE.Color;
+    };
+    uMetal: {
+        value: number;
+    };
+    uRough: {
+        value: number;
+    };
+    uSelf: {
+        value: number;
+    };
+    uTexA: {
+        value: any;
+    };
+    uTexB: {
+        value: any;
+    };
+    uFitA: {
+        value: THREE.Vector2;
+    };
+    uFitB: {
+        value: THREE.Vector2;
+    };
+    uP: {
+        value: number;
+    };
+    uHasA: {
+        value: number;
+    };
+    uSeq: {
+        value: number;
+    };
+    uSize: {
+        value: THREE.Vector2;
+    };
+    uTime: {
+        value: number;
+    };
+    uDir: {
+        value: THREE.Vector2;
+    };
+    uSpread: {
+        value: number;
+    };
+    uBlank: {
+        value: THREE.Color;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uBreathe: {
+        value: number;
+    };
+    uPointer: {
+        value: THREE.Vector3;
+    };
+    uPointerVel: {
+        value: THREE.Vector2;
+    };
+    uPointerActive: {
+        value: number;
+    };
+    uPointerMode: {
+        value: number;
+    };
+    uPointerStrength: {
+        value: number;
+    };
+    uPointerRadius: {
+        value: number;
+    };
+    uPointerColor: {
+        value: THREE.Color;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: any[];
+    controls: {
+        show: (t: any) => void;
+        readonly busy: boolean;
+        pic: {
+            st: {
+                A: any;
+                B: any;
+                aspA: number;
+                aspB: number;
+                p: number;
+                dir: number;
+                pending: any;
+                seq: number;
+                frame: number;
+            };
+            show: (tex: any) => void;
+            jump: (tex: any) => void;
+            step: (dt: any) => void;
+            readonly busy: boolean;
+            dispose(): void;
+        };
+    };
+    apply(k: any): void;
+    update(dt: any, pointer: any): void;
+    dispose(): void;
+};
+//# sourceMappingURL=pinscreen.d.ts.map

package/dist/components/image/core/pinscreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinscreen.d.ts","sourceRoot":"","sources":["../../../../src/components/image/core/pinscreen.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,aAAa,UAAoB,CAAC;AAC/C,eAAO,MAAM,UAAU,UAAwB,CAAC;AAEhD,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG7B;AACD,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAG/B;AAwDD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCzB"}

package/dist/components/image/core/pinscreen.js

@@ -0,0 +1,147 @@
+// GENERATED from the lab (Claude outputs/gallery-lab/image/pinscreen.mjs) by emit_image.mjs — change the lab and re-emit.
+// pinscreen — an image variant (type 'image', config.type 'pinscreen'). Material: MeshStandardMaterial (lit by the
+// scene; object effects attach).
+//
+// The picture is a pinscreen: thousands of fine metal pins through a dark plate, each standing out by the
+// picture's brightness under it and capped with a domed head carrying the picture's colour. The relief is real
+// geometry, so the scene's light rolls over the heads and the pins shadow each other; from the side it reads as a
+// sculpted field, from the front as the picture. A change is a pressure wave across the plate: under the front
+// the pins sink back almost flush, their heads change colour at the bottom of the stroke (where the change is
+// hidden in the plate's shadow) and rise again to the new picture's relief. The first picture rises out of a
+// flat plate. Idle: a slow, very low swell runs through the pins. One InstancedMesh (one draw call) + the plate.
+// Cursor: `press` pushes the pins in under the cursor (a hand behind the screen, inverted), `lift` draws them out.
+import * as THREE from 'three';
+import { baseUniforms, applyBase, setU, createPicture, stepPointer, patchMaterial, depthTwin, mulberry32 } from './imageCore.js';
+export const POINTER_MODES = ['press', 'lift'];
+export const STRUCTURAL = ['imageUrls', 'cols'];
+export function createUniforms() {
+    return { ...baseUniforms(), uCols: { value: new THREE.Vector2(110, 70) }, uDepth: { value: 1 }, uDip: { value: 0.85 }, uPinSize: { value: 0.86 },
+        uPinColor: { value: new THREE.Color('#9aa0a8') }, uMetal: { value: 0.6 }, uRough: { value: 0.32 }, uSelf: { value: 0.15 } };
+}
+export function applyConfig(u, c) {
+    applyBase(u, c, POINTER_MODES);
+    setU(u, 'uDepth', c.depth);
+    setU(u, 'uDip', c.dip);
+    setU(u, 'uPinSize', c.pinSize);
+    setU(u, 'uPinColor', c.pinColor);
+    setU(u, 'uMetal', c.metal);
+    setU(u, 'uRough', c.roughness);
+    setU(u, 'uSelf', c.selfLight);
+}
+const pars = /* glsl */ `
+uniform vec2 uCols; uniform float uDepth, uDip, uPinSize, uMetal, uRough; uniform vec3 uPinColor;
+attribute vec3 aCell;            // pin centre uv, random
+varying vec3 vHeadCol; varying float vHead;
+`;
+const fragPars = /* glsl */ `
+uniform vec2 uCols; uniform float uDepth, uDip, uPinSize, uMetal, uRough, uSelf; uniform vec3 uPinColor;
+varying vec3 vHeadCol; varying float vHead;
+`;
+const vertex = /* glsl */ `
+  vec2 c = aCell.xy;
+  vec2 pitch = uSize / uCols;
+  float r = 0.5 * uPinSize * min(pitch.x, pitch.y);
+  float l = localP(c); float s = sstep(l);
+  vec3 ca = picAL(c, 2.5), cb = picBL(c, 2.5);
+  float ext = 0.012 + mix(luma(ca), luma(cb), s) * uDepth * 0.12;
+  ext *= 1.0 - uDip * sin(PI * l);                                       // the pressure wave
+  ext += uBreathe * 0.004 * (0.5 + 0.5 * sin(uTime * 0.55 + c.x * 7.0 + c.y * 4.0 + aCell.z * 0.6));
+  vec2 xy = (c - 0.5) * uSize;
+  float pb = pointerBump(xy);
+  if (uPointerMode > -0.5 && uPointerMode < 0.5) ext = mix(ext, 0.006, min(1.0, pb));
+  else if (uPointerMode > 0.5) ext += 0.08 * pb;
+  // profile: z < -0.1 is the shaft (length 0.3), above it the head dome (scaled by the head radius)
+  float pz = position.z;
+  float z = pz >= -0.1 ? pz * r * 1.4 : -0.1 * r * 1.4 + (pz + 0.1) * 0.33;
+  fxP = vec3(xy + position.xy * r, ext + z);
+  fxN = normal;
+  vHead = smoothstep(-0.12, -0.06, pz);
+  // the head swaps colour at the bottom of the stroke
+  vHeadCol = mix(ca, cb, smoothstep(0.38, 0.62, l));
+`;
+const diffuse = /* glsl */ `
+  diffuseColor.rgb = mix(uPinColor, vHeadCol * uIntensity, vHead);
+  diffuseColor.a *= uOpacity;
+`;
+const emissive = /* glsl */ `
+  totalEmissiveRadiance += vHeadCol * uIntensity * uSelf * vHead;
+`;
+const roughness = /* glsl */ `
+  roughnessFactor = mix(uRough, uRough + 0.15, vHead);
+  metalnessFactor = mix(uMetal, 0.05, vHead);
+`;
+function pinGeometry() {
+    // a lathe profile about y, then turned to stand along +z: shaft (radius 0.55) then a domed head (radius 1)
+    const pts = [];
+    pts.push(new THREE.Vector2(0.001, -1.0), new THREE.Vector2(0.55, -1.0), new THREE.Vector2(0.55, -0.12), new THREE.Vector2(0.98, -0.1));
+    for (let i = 0; i <= 4; i++) {
+        const a = (i / 4) * Math.PI / 2;
+        pts.push(new THREE.Vector2(Math.cos(a) * 1.0 + 0.0, -0.1 + Math.sin(a) * 0.1 + 0.0));
+    }
+    pts.push(new THREE.Vector2(0.001, 0.0));
+    const g = new THREE.LatheGeometry(pts, 8);
+    g.rotateX(Math.PI / 2); // y -> z
+    return g;
+}
+export function build(u, c) {
+    const object = new THREE.Group();
+    const cols = Math.max(8, c.cols | 0), rows = Math.round(cols * 0.65);
+    u.uCols.value.set(cols, rows);
+    const base = pinGeometry();
+    const geo = new THREE.InstancedBufferGeometry();
+    geo.index = base.index;
+    geo.setAttribute('position', base.attributes.position);
+    geo.setAttribute('normal', base.attributes.normal);
+    const n = cols * rows, cell = new Float32Array(n * 3), rnd = mulberry32(5);
+    for (let j = 0; j < rows; j++)
+        for (let i = 0; i < cols; i++) {
+            const k = j * cols + i;
+            cell[k * 3] = (i + 0.5) / cols;
+            cell[k * 3 + 1] = (j + 0.5) / rows;
+            cell[k * 3 + 2] = rnd() * 6.28;
+        }
+    geo.setAttribute('aCell', new THREE.InstancedBufferAttribute(cell, 3));
+    geo.instanceCount = n;
+    geo.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 1.4);
+    const P = { key: 'pinscreen', uniforms: u, pars, vertexPars: '', fragmentPars: '', vertex, diffuse, roughness, emissive };
+    P.pars = '';
+    P.vertexPars = pars;
+    P.fragmentPars = fragPars;
+    const mat = patchMaterial(new THREE.MeshStandardMaterial({ roughness: 0.4, metalness: 0.5 }), P);
+    const pins = new THREE.Mesh(geo, mat);
+    pins.castShadow = true;
+    pins.receiveShadow = true;
+    pins.frustumCulled = false;
+    pins.customDepthMaterial = depthTwin(P);
+    // the plate: a thin box the pins go through, sized to the frame each frame
+    const plateMat = new THREE.MeshStandardMaterial({ color: c.plateColor, roughness: 0.8, metalness: 0.2 });
+    const plate = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), plateMat);
+    plate.receiveShadow = true;
+    plate.castShadow = true;
+    object.add(plate, pins);
+    const cfg = { ...c };
+    const pic = createPicture(u, cfg);
+    const pst = {};
+    const api = {
+        object, materials: [mat, plateMat],
+        controls: { show: (t) => pic.show(t), get busy() { return pic.busy; }, pic },
+        apply(k) { Object.assign(cfg, k); applyConfig(u, k); if (k.plateColor !== undefined)
+            plateMat.color.set(k.plateColor); if (k.opacity !== undefined) {
+            for (const m of [mat, plateMat]) {
+                m.transparent = k.opacity < 1;
+                m.opacity = k.opacity;
+            }
+        } },
+        update(dt, pointer) {
+            dt = Math.min(dt, 0.1);
+            u.uTime.value += dt;
+            pic.step(dt);
+            stepPointer(u, pointer, dt, pst);
+            const s = u.uSize.value;
+            plate.scale.set(s.x + 0.04, s.y + 0.04, 0.03);
+            plate.position.z = -0.015;
+        },
+        dispose() { base.dispose(); geo.dispose(); mat.dispose(); plateMat.dispose(); plate.geometry.dispose(); pins.customDepthMaterial.dispose(); pic.dispose(); },
+    };
+    return api;
+}

package/dist/components/image/core/prism.d.ts

@@ -0,0 +1,120 @@
+import * as THREE from 'three';
+export declare const POINTER_MODES: string[];
+export declare const STRUCTURAL: string[];
+export declare function createUniforms(): {
+    uCount: {
+        value: number;
+    };
+    uVert: {
+        value: number;
+    };
+    uSettle: {
+        value: number;
+    };
+    uGap: {
+        value: number;
+    };
+    uSlat: {
+        value: THREE.Color;
+    };
+    uSelf: {
+        value: number;
+    };
+    uTexA: {
+        value: any;
+    };
+    uTexB: {
+        value: any;
+    };
+    uFitA: {
+        value: THREE.Vector2;
+    };
+    uFitB: {
+        value: THREE.Vector2;
+    };
+    uP: {
+        value: number;
+    };
+    uHasA: {
+        value: number;
+    };
+    uSeq: {
+        value: number;
+    };
+    uSize: {
+        value: THREE.Vector2;
+    };
+    uTime: {
+        value: number;
+    };
+    uDir: {
+        value: THREE.Vector2;
+    };
+    uSpread: {
+        value: number;
+    };
+    uBlank: {
+        value: THREE.Color;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uBreathe: {
+        value: number;
+    };
+    uPointer: {
+        value: THREE.Vector3;
+    };
+    uPointerVel: {
+        value: THREE.Vector2;
+    };
+    uPointerActive: {
+        value: number;
+    };
+    uPointerMode: {
+        value: number;
+    };
+    uPointerStrength: {
+        value: number;
+    };
+    uPointerRadius: {
+        value: number;
+    };
+    uPointerColor: {
+        value: THREE.Color;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: any[];
+    controls: {
+        show: (t: any) => void;
+        readonly busy: boolean;
+        pic: {
+            st: {
+                A: any;
+                B: any;
+                aspA: number;
+                aspB: number;
+                p: number;
+                dir: number;
+                pending: any;
+                seq: number;
+                frame: number;
+            };
+            show: (tex: any) => void;
+            jump: (tex: any) => void;
+            step: (dt: any) => void;
+            readonly busy: boolean;
+            dispose(): void;
+        };
+    };
+    apply(k: any): void;
+    update(dt: any, pointer: any): void;
+    dispose(): void;
+};
+//# sourceMappingURL=prism.d.ts.map

package/dist/components/image/core/prism.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prism.d.ts","sourceRoot":"","sources":["../../../../src/components/image/core/prism.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,aAAa,UAAmB,CAAC;AAC9C,eAAO,MAAM,UAAU,UAAqC,CAAC;AAE7D,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7B;AACD,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAG/B;AAkFD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BzB"}