egaki 0.7.2 → 0.9.0

package/CHANGELOG.md

@@ -2,6 +2,58 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.9.0
+
+1. **`<AngledScreen>` with true WebGL depth-of-field** — the 3D tilted screen component is now shader-based. Children DOM is captured per frame with Chromium's HTML-in-canvas API and rendered as a perspective-tilted plane in a WebGL2 fragment shader, giving true per-pixel depth. Depth drives bokeh blur (the exact Three.js BokehShader 41-tap ring kernel), fog toward `backgroundColor`, and subtle film grain. Available in MDX without imports:
+
+   ```mdx
+   # Hero duration=5s
+
+   <AngledScreen rotateX={9} rotateY={-17} translateZ={120} backgroundColor="#0a0608">
+     <Img src="/screenshot.png" style={{ width: '100%', borderRadius: 14 }} />
+   </AngledScreen>
+   ```
+
+   New depth-of-field props: `bokeh`, `aperture` (default 0.5), `maxBlur` (default 0.12), `focus` (default 0 = auto-track the near side so blur ramps toward the far edge), plus `fog` and `grainIntensity`. Transform props (`perspective`, `rotateX/Y/Z`, `translateX`, `translateZ`) keep the same semantics as before.
+
+   Requires Chrome 149+ with `chrome://flags/#canvas-draw-element`. When HTML-in-canvas is unsupported, the previous CSS version renders automatically as a fallback (also exported directly as `BasicAngledScreen`).
+
+2. **Tweakpane controls now follow animated props** — `useTweakpane`-backed components (like `AngledScreen`) previously froze all values at mount, so animated props like `translateX={interpolate(frame, ...)}` stayed stuck at frame 0. Untouched keys now return the live value every frame and their sliders visibly animate during playback. Once you touch a control, that key freezes to your value until remount, so manual overrides survive seeks. "Copy changes" now only reports keys you actually edited.
+
+3. **Fixed flat exports and screenshots of shader scenes** — web-renderer exports, SDK `screenshot()`, `filmstrip()`, and `export()` of scenes with HTML-in-canvas shaders came out without the shader output (the export scaffold is hidden, so Chromium produced no paint records for the capture). The composition root is now wrapped in a visible container for all web-renderer entry points, restoring shader output in every export path.
+
+4. **Fixed export hang with hidden `<AngledScreen>` instances** — instances inside hidden ancestors (LayoutTransition ghosts, inactive timed instances) never fired their paint callback, leaving an unreleased delayRender handle that stalled exports ~28s per frame. Handle registration is now gated on actual visibility.
+
+5. **Remotion bumped to 4.0.494** — required for WebGL contexts inside HTML-in-canvas components (earlier versions grabbed a 2D context on the offscreen canvas first, blocking WebGL).
+
+## 0.8.0
+
+1. **`egaki bpm` command** — detect BPM of audio files locally using peak detection and interval analysis. No API call needed, runs entirely on device via `node-web-audio-api`:
+
+   ```bash
+   egaki bpm song.mp3
+   egaki bpm track.wav --json
+   ffmpeg -i video.mp4 -f mp3 - | egaki bpm --stdin
+   ```
+
+   Returns BPM and beat interval in seconds. Useful for syncing music to video sections with `bpm:` frontmatter.
+
+2. **`egaki loudness` command** — measure perceived loudness (LUFS) of audio files locally. Uses K-weighted filtering and two-pass gating inspired by EBU R128:
+
+   ```bash
+   egaki loudness song.mp3
+   egaki loudness track.wav --json
+   ffmpeg -i video.mp4 -f mp3 - | egaki loudness --stdin
+   ```
+
+   Returns integrated, max, min loudness and loudness range. Helpful for normalizing audio levels across video scenes.
+
+3. **Collapsible tweakpane sidebar** — the right-side tweakpane panel is now collapsed by default so the video preview takes the full width. A panel icon button in the top-right corner toggles it open.
+
+4. **Fixed CodeBlock empty frames during export** — shiki highlight was racing with React's batched state updates, causing empty code blocks in screenshots, filmstrips, and video exports. Now uses `delayRender`/`continueRender` correctly via `useLayoutEffect`.
+
+5. **Removed HMR auto-seek on MDX edits** — editing the entry MDX no longer auto-seeks to the changed scene and auto-plays. The behavior was fragile and surprising. MDX edits still hot-reload via RSC update.
+
 ## 0.7.2
 
 1. **Fixed missing `spiceflow` and `@vitejs/plugin-react` dependencies** — both were listed as optional peer dependencies but imported unconditionally by the Vite plugin. Now included as regular dependencies so `egaki/vite` works out of the box without manually installing them.

package/dist/cli/bpm-detect.d.ts

@@ -0,0 +1,7 @@
+interface BpmResult {
+    bpm: number;
+    intervalInSeconds: number;
+}
+export declare function detectBpm(buffer: ArrayBuffer): Promise<Error | BpmResult>;
+export {};
+//# sourceMappingURL=bpm-detect.d.ts.map

package/dist/cli/bpm-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bpm-detect.d.ts","sourceRoot":"","sources":["../../src/cli/bpm-detect.ts"],"names":[],"mappings":"AAKA,UAAU,SAAS;IACjB,GAAG,EAAE,MAAM,CAAA;IACX,iBAAiB,EAAE,MAAM,CAAA;CAC1B;AAMD,wBAAsB,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAsB/E"}

package/dist/cli/bpm-detect.js

@@ -0,0 +1,123 @@
+// BPM detection for audio files using Web Audio API.
+// Ported from https://github.com/tornqvist/bpm-detective
+// Uses node-web-audio-api (native NAPI Rust binding) as an optional dependency.
+// If missing, returns an Error with install instructions.
+// Cached module reference set by detectBpm() before calling detect().
+// This avoids require() in ESM and avoids passing the module through every function.
+let webAudioMod = null;
+export async function detectBpm(buffer) {
+    try {
+        webAudioMod = await import('node-web-audio-api');
+    }
+    catch {
+        return new Error('node-web-audio-api is required for BPM detection. Install it:\n\n' +
+            '  pnpm add node-web-audio-api\n');
+    }
+    const context = new webAudioMod.AudioContext();
+    try {
+        const data = await context.decodeAudioData(buffer);
+        const bpm = detect(data);
+        const intervalInSeconds = 60 / bpm;
+        return { bpm, intervalInSeconds };
+    }
+    catch (err) {
+        if (err instanceof Error)
+            return err;
+        return new Error(String(err));
+    }
+    finally {
+        await context.close().catch(() => { });
+    }
+}
+function detect(buffer) {
+    const source = getLowPassSource(buffer);
+    source.start(0);
+    const channelData = source.buffer.getChannelData(0);
+    const peaks = findPeaks(channelData);
+    const intervals = identifyIntervals(peaks);
+    const tempoCounts = groupByTempo(buffer.sampleRate, intervals);
+    return getTopCandidate(tempoCounts);
+}
+function getTopCandidate(candidates) {
+    return candidates.sort((a, b) => b.count - a.count).splice(0, 5)[0].tempo;
+}
+function getLowPassSource(buffer) {
+    const { length, numberOfChannels, sampleRate } = buffer;
+    const context = new webAudioMod.OfflineAudioContext(numberOfChannels, length, sampleRate);
+    const source = context.createBufferSource();
+    source.buffer = buffer;
+    const filter = context.createBiquadFilter();
+    filter.type = 'lowpass';
+    source.connect(filter);
+    filter.connect(context.destination);
+    return source;
+}
+function findPeaks(data) {
+    let peaks = [];
+    let threshold = 0.9;
+    const minThreshold = 0.3;
+    const minPeaks = 15;
+    while (peaks.length < minPeaks && threshold >= minThreshold) {
+        peaks = findPeaksAtThreshold(data, threshold);
+        threshold -= 0.05;
+    }
+    if (peaks.length < minPeaks) {
+        throw new Error('Could not find enough samples for a reliable BPM detection.');
+    }
+    return peaks;
+}
+function findPeaksAtThreshold(data, threshold) {
+    const peaks = [];
+    for (let i = 0, l = data.length; i < l; i += 1) {
+        if (data[i] > threshold) {
+            peaks.push(i);
+            // Skip forward ~1/4s to get past this peak
+            i += 10000;
+        }
+    }
+    return peaks;
+}
+function identifyIntervals(peaks) {
+    const intervals = [];
+    peaks.forEach((peak, index) => {
+        for (let i = 0; i < 10; i += 1) {
+            const interval = peaks[index + i] - peak;
+            const foundInterval = intervals.some((ic) => {
+                if (ic.interval === interval) {
+                    ic.count += 1;
+                    return true;
+                }
+                return false;
+            });
+            if (!foundInterval) {
+                intervals.push({ interval, count: 1 });
+            }
+        }
+    });
+    return intervals;
+}
+function groupByTempo(sampleRate, intervalCounts) {
+    const tempoCounts = [];
+    intervalCounts.forEach((intervalCount) => {
+        if (intervalCount.interval !== 0) {
+            let theoreticalTempo = 60 / (intervalCount.interval / sampleRate);
+            // Adjust to fit within the 90-180 BPM range
+            while (theoreticalTempo < 90)
+                theoreticalTempo *= 2;
+            while (theoreticalTempo > 180)
+                theoreticalTempo /= 2;
+            theoreticalTempo = Math.round(theoreticalTempo);
+            const foundTempo = tempoCounts.some((tc) => {
+                if (tc.tempo === theoreticalTempo) {
+                    tc.count += intervalCount.count;
+                    return true;
+                }
+                return false;
+            });
+            if (!foundTempo) {
+                tempoCounts.push({ tempo: theoreticalTempo, count: intervalCount.count });
+            }
+        }
+    });
+    return tempoCounts;
+}

package/dist/cli/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli/cli.ts"],"names":[],"mappings":";AA0FA,QAAA,MAAM,GAAG,yBAAgB,CAAA;AA4pCzB,OAAO,EAAE,GAAG,EAAE,CAAA"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli/cli.ts"],"names":[],"mappings":";AAgGA,QAAA,MAAM,GAAG,yBAAgB,CAAA;AA2yCzB,OAAO,EAAE,GAAG,EAAE,CAAA"}

package/dist/cli/cli.js

@@ -30,6 +30,8 @@ import { DEFAULT_SPEECH_MODEL, } from './speech-models.js';
 import { DEFAULT_TRANSCRIPTION_MODEL, } from './transcription-models.js';
 import { separateAudioUncached as separateAudio, downloadStem, } from './separation-generate.js';
 import { cloneVoiceUncached as cloneVoice, } from './clone-generate.js';
+import { detectBpm, } from './bpm-detect.js';
+import { detectLoudness, } from './loudness-detect.js';
 const cli = goke('egaki');
 process.title = 'egaki';
 process.on('uncaughtException', (err) => {
@@ -654,6 +656,119 @@ cli
         }, null, 2));
     }
 });
+// ─── bpm command ─────────────────────────────────────────────────────────────
+cli
+    .command('bpm [audio]', dedent `
+      Detect the BPM (beats per minute) of an audio file.
+      Runs locally using peak detection, no API call needed.
+      Requires node-web-audio-api as an optional dependency.
+    `)
+    .option('--stdin', 'Read audio from stdin instead of a file path')
+    .option('--json', 'Output result as JSON to stdout')
+    .example('# Detect BPM of a song')
+    .example('egaki bpm song.mp3')
+    .example('# Pipe audio from another command')
+    .example('ffmpeg -i video.mp4 -f mp3 - | egaki bpm --stdin')
+    .example('# Get JSON output')
+    .example('egaki bpm track.wav --json')
+    .action(async (audioPath = '', options) => {
+    if (!options.stdin && !audioPath) {
+        console.error(pc.red('No audio provided. Pass an audio file path or use --stdin.'));
+        process.exit(1);
+    }
+    let audioData;
+    if (options.stdin) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        const buf = Buffer.concat(chunks);
+        audioData = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    }
+    else {
+        const resolved = path.resolve(audioPath);
+        if (!fs.existsSync(resolved)) {
+            console.error(pc.red(`File not found: ${resolved}`));
+            process.exit(1);
+        }
+        const buf = fs.readFileSync(resolved);
+        audioData = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    }
+    if (!options.json) {
+        console.error(pc.dim(`Audio: ${options.stdin ? 'stdin' : audioPath} (${(audioData.byteLength / 1024).toFixed(1)} KB)`));
+        console.error(pc.cyan('Detecting BPM...'));
+    }
+    const result = await detectBpm(audioData);
+    if (result instanceof Error) {
+        console.error(pc.red(result.message));
+        process.exit(1);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.error(pc.green(`BPM: ${result.bpm}`));
+        console.error(pc.dim(`Interval: ${result.intervalInSeconds.toFixed(3)}s`));
+    }
+});
+// ─── loudness command ────────────────────────────────────────────────────────
+cli
+    .command('loudness [audio]', dedent `
+      Measure the perceived loudness (LUFS) of an audio file.
+      Uses K-weighting and two-pass gating inspired by EBU R128.
+      Runs locally, no API call needed.
+      Requires node-web-audio-api as an optional dependency.
+    `)
+    .option('--stdin', 'Read audio from stdin instead of a file path')
+    .option('--json', 'Output result as JSON to stdout')
+    .example('# Measure loudness of a song')
+    .example('egaki loudness song.mp3')
+    .example('# Pipe audio from another command')
+    .example('ffmpeg -i video.mp4 -f mp3 - | egaki loudness --stdin')
+    .example('# Get JSON output')
+    .example('egaki loudness track.wav --json')
+    .action(async (audioPath = '', options) => {
+    if (!options.stdin && !audioPath) {
+        console.error(pc.red('No audio provided. Pass an audio file path or use --stdin.'));
+        process.exit(1);
+    }
+    let audioData;
+    if (options.stdin) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        const buf = Buffer.concat(chunks);
+        audioData = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    }
+    else {
+        const resolved = path.resolve(audioPath);
+        if (!fs.existsSync(resolved)) {
+            console.error(pc.red(`File not found: ${resolved}`));
+            process.exit(1);
+        }
+        const buf = fs.readFileSync(resolved);
+        audioData = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    }
+    if (!options.json) {
+        console.error(pc.dim(`Audio: ${options.stdin ? 'stdin' : audioPath} (${(audioData.byteLength / 1024).toFixed(1)} KB)`));
+        console.error(pc.cyan('Measuring loudness...'));
+    }
+    const result = await detectLoudness(audioData);
+    if (result instanceof Error) {
+        console.error(pc.red(result.message));
+        process.exit(1);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        console.error(pc.green(`Integrated: ${result.integrated.toFixed(1)} LUFS`));
+        console.error(pc.dim(`Max: ${result.max.toFixed(1)} LUFS`));
+        console.error(pc.dim(`Min: ${result.min.toFixed(1)} LUFS`));
+        console.error(pc.dim(`Range: ${result.range.toFixed(1)} LU`));
+    }
+});
 // ─── voice clone command ─────────────────────────────────────────────────────
 cli
     .command('voice clone [audio]', dedent `

package/dist/cli/loudness-detect.d.ts

@@ -0,0 +1,13 @@
+interface LoudnessResult {
+    /** Integrated loudness in LUFS (two-pass gated average). */
+    integrated: number;
+    /** Maximum momentary loudness (single 400ms block). */
+    max: number;
+    /** Minimum momentary loudness above the absolute gate. */
+    min: number;
+    /** Loudness range (max - min) in LU. */
+    range: number;
+}
+export declare function detectLoudness(buffer: ArrayBuffer): Promise<Error | LoudnessResult>;
+export {};
+//# sourceMappingURL=loudness-detect.d.ts.map

package/dist/cli/loudness-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loudness-detect.d.ts","sourceRoot":"","sources":["../../src/cli/loudness-detect.ts"],"names":[],"mappings":"AAcA,UAAU,cAAc;IACtB,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAA;IAClB,uDAAuD;IACvD,GAAG,EAAE,MAAM,CAAA;IACX,0DAA0D;IAC1D,GAAG,EAAE,MAAM,CAAA;IACX,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAA;CACd;AAMD,wBAAsB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,KAAK,GAAG,cAAc,CAAC,CAmGzF"}

package/dist/cli/loudness-detect.js

@@ -0,0 +1,96 @@
+// LUFS (Loudness Units Full Scale) measurement for audio files.
+// Ported from meltica. Uses node-web-audio-api (native NAPI Rust binding)
+// as an optional dependency. If missing, returns an Error with install instructions.
+//
+// Implements a simplified LUFS measurement inspired by EBU R128 / ITU-R BS.1770:
+// K-weighting via biquad filters (approximate, not exact BS.1770 coefficients),
+// 400ms blocks with 100ms hop, two-pass gating (absolute -70 LUFS gate, then
+// relative -10 LU gate). Energy averaging is done in the linear domain (mean
+// square) before converting to LUFS, which is the correct approach.
+//
+// The K-weighting filters are simplified (highpass 60Hz + highshelf 1500Hz)
+// rather than the exact BS.1770 pre-filter + RLB coefficients, so results
+// may differ slightly from reference implementations.
+function lufsFromMeanSquare(ms) {
+    return -0.691 + 10 * Math.log10(ms);
+}
+export async function detectLoudness(buffer) {
+    let webAudioMod;
+    try {
+        webAudioMod = await import('node-web-audio-api');
+    }
+    catch {
+        return new Error('node-web-audio-api is required for loudness measurement. Install it:\n\n' +
+            '  pnpm add node-web-audio-api\n');
+    }
+    const context = new webAudioMod.AudioContext();
+    try {
+        const audioBuffer = await context.decodeAudioData(buffer);
+        const offlineContext = new webAudioMod.OfflineAudioContext(audioBuffer.numberOfChannels, audioBuffer.length, audioBuffer.sampleRate);
+        const source = offlineContext.createBufferSource();
+        source.buffer = audioBuffer;
+        // Simplified K-weighting: high-pass at 60Hz + high-shelf boost at 1500Hz
+        const highPass = offlineContext.createBiquadFilter();
+        highPass.type = 'highpass';
+        highPass.frequency.value = 60;
+        highPass.Q.value = 0.7;
+        const highShelf = offlineContext.createBiquadFilter();
+        highShelf.type = 'highshelf';
+        highShelf.frequency.value = 1500;
+        highShelf.gain.value = 4;
+        source.connect(highPass);
+        highPass.connect(highShelf);
+        highShelf.connect(offlineContext.destination);
+        source.start(0);
+        const rendered = await offlineContext.startRendering();
+        // 400ms blocks, 100ms hop
+        const blockSize = Math.floor(0.4 * rendered.sampleRate);
+        const hopSize = Math.floor(0.1 * rendered.sampleRate);
+        if (rendered.length < blockSize) {
+            return new Error('Audio must be at least 400ms for loudness measurement.');
+        }
+        // Collect mean square energy per block
+        const blocks = [];
+        for (let i = 0; i <= rendered.length - blockSize; i += hopSize) {
+            let sumSquared = 0;
+            for (let ch = 0; ch < rendered.numberOfChannels; ch++) {
+                const data = rendered.getChannelData(ch);
+                for (let j = 0; j < blockSize; j++) {
+                    sumSquared += data[i + j] * data[i + j];
+                }
+            }
+            blocks.push(sumSquared / (blockSize * rendered.numberOfChannels));
+        }
+        // Two-pass gating per EBU R128:
+        // Pass 1: absolute gate at -70 LUFS
+        const absoluteGate = -70;
+        const absoluteGated = blocks.filter((ms) => lufsFromMeanSquare(ms) > absoluteGate);
+        if (absoluteGated.length === 0) {
+            return new Error('Audio is silent or below the -70 LUFS gate threshold.');
+        }
+        // Pass 2: relative gate at -10 LU below the absolute-gated integrated loudness
+        const preliminaryMs = absoluteGated.reduce((s, v) => s + v, 0) / absoluteGated.length;
+        const relativeGate = lufsFromMeanSquare(preliminaryMs) - 10;
+        const relativeGated = absoluteGated.filter((ms) => lufsFromMeanSquare(ms) > relativeGate);
+        if (relativeGated.length === 0) {
+            return new Error('Audio is too quiet for reliable loudness measurement.');
+        }
+        // Integrated loudness: average energy in linear domain, then convert to LUFS
+        const integratedMs = relativeGated.reduce((s, v) => s + v, 0) / relativeGated.length;
+        const integrated = lufsFromMeanSquare(integratedMs);
+        // Momentary loudness values for range calculation (from absolute-gated blocks)
+        const momentaryLufs = absoluteGated.map(lufsFromMeanSquare);
+        const max = Math.max(...momentaryLufs);
+        const min = Math.min(...momentaryLufs);
+        const range = max - min;
+        return { integrated, max, min, range };
+    }
+    catch (err) {
+        if (err instanceof Error)
+            return err;
+        return new Error(String(err));
+    }
+    finally {
+        await context.close().catch(() => { });
+    }
+}

package/dist/vite/angled-screen-shader.d.ts

@@ -0,0 +1,45 @@
+import { type CSSProperties, type ReactNode } from 'react';
+export interface AngledScreenProps {
+    children: ReactNode;
+    /** CSS perspective distance in px. Smaller = more dramatic. Default 1200. */
+    perspective?: number;
+    /** X-axis rotation in degrees (tilts top/bottom). Default 8. */
+    rotateX?: number;
+    /** Y-axis rotation in degrees (angles left/right). Default -12. */
+    rotateY?: number;
+    /** Z-axis rotation in degrees. Default 0. */
+    rotateZ?: number;
+    /** Shift the plane horizontally in px. Positive = right. Default 0. */
+    translateX?: number;
+    /** Push the plane forward/back in px. Positive = closer/larger. Default 0. */
+    translateZ?: number;
+    /** Enable depth-based bokeh blur. Default true. */
+    bokeh?: boolean;
+    /** Aperture — bigger values for shallower depth of field. Blur grows
+     *  linearly with distance from the focus plane, scaled by this.
+     *  Same semantics as Three's BokehPass. Default 0.5 (plugin value). */
+    aperture?: number;
+    /** Max blur in screen-UV units (fraction of frame size), the saturation
+     *  cap of the blur. Same as Three's `maxblur`. Default 0.12 (plugin value). */
+    maxBlur?: number;
+    /** Focus distance as a fraction of `perspective`. Default 0 = auto: focus
+     *  tracks the nearest visible point of the plane, so the near side stays
+     *  sharp and blur ramps progressively toward the far edge only. */
+    focus?: number;
+    /** Fog toward backgroundColor at the far depth (0-1). Default 0.35. */
+    fog?: number;
+    /** Film grain intensity. Default 0.02. */
+    grainIntensity?: number;
+    /** Background color behind the tilted screen. Default '#000000'. */
+    backgroundColor?: string;
+    /** Width of the inner content wrapper. Default '80%'. */
+    width?: string | number;
+    /** Height of the inner content wrapper. Default 'auto'. */
+    height?: string | number;
+    /** Render normalized depth as grayscale for debugging the DOF ramp. */
+    debug?: boolean;
+    /** Optional inline style on the outer container. */
+    style?: CSSProperties;
+}
+export declare function AngledScreen(props: AngledScreenProps): import("react").JSX.Element;
+//# sourceMappingURL=angled-screen-shader.d.ts.map

package/dist/vite/angled-screen-shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angled-screen-shader.d.ts","sourceRoot":"","sources":["../../src/vite/angled-screen-shader.tsx"],"names":[],"mappings":"AAyEA,OAAO,EAAwC,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAKhG,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,SAAS,CAAA;IAGnB,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6CAA6C;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,uEAAuE;IACvE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAA;IAGnB,mDAAmD;IACnD,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;2EAEuE;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;mFAC+E;IAC/E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;uEAEmE;IACnE,KAAK,CAAC,EAAE,MAAM,CAAA;IAGd,uEAAuE;IACvE,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,0CAA0C;IAC1C,cAAc,CAAC,EAAE,MAAM,CAAA;IAEvB,oEAAoE;IACpE,eAAe,CAAC,EAAE,MAAM,CAAA;IAGxB,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACvB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAExB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAA;IAEf,oDAAoD;IACpD,KAAK,CAAC,EAAE,aAAa,CAAA;CACtB;AAwND,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,+BAuWpD"}