@gjsify/webaudio 0.4.0 → 0.4.3

package/src/gst-player.ts

@@ -1,185 +0,0 @@
-// GStreamer playback pipeline: AudioBuffer PCM → audio output
-//
-// Pipeline: appsrc(F32LE) → audioconvert → volume → autoaudiosink
-// Each GstPlayer instance is single-use (matches W3C AudioBufferSourceNode).
-//
-// Reference: GStreamer 1.0 via gi://Gst
-
-import GLib from 'gi://GLib?version=2.0';
-import { ensureGstInit, Gst } from './gst-init.js';
-import type { AudioBuffer } from './audio-buffer.js';
-
-// Force GstApp typelib load
-import GstApp from 'gi://GstApp?version=1.0';
-void GstApp;
-
-export interface GstPlayerOptions {
-    audioBuffer: AudioBuffer;
-    volume: number;
-    loop: boolean;
-    offset: number;      // start offset in seconds
-    duration?: number;    // play duration in seconds (undefined = full)
-    playbackRate: number;
-    onEnded: () => void;
-}
-
-/**
- * Manages a single GStreamer playback pipeline for one AudioBufferSourceNode.start() call.
- */
-export class GstPlayer {
-    private _pipeline: any = null;
-    private _volumeElement: any = null;
-    private _busWatchId: number | null = null;
-    private _ended = false;
-    private _loop: boolean;
-    private _onEnded: () => void;
-    private _audioBuffer: AudioBuffer;
-
-    constructor(options: GstPlayerOptions) {
-        ensureGstInit();
-        this._loop = options.loop;
-        this._onEnded = options.onEnded;
-        this._audioBuffer = options.audioBuffer;
-
-        const { audioBuffer, volume, offset, duration, playbackRate } = options;
-        const sr = audioBuffer.sampleRate;
-        const ch = audioBuffer.numberOfChannels;
-
-        // Build interleaved PCM data
-        const pcmData = this._interleave(audioBuffer, offset, duration);
-        if (pcmData.length === 0) {
-            // Empty buffer — fire ended immediately
-            this._fireEnded();
-            return;
-        }
-
-        // Build pipeline — format=3 (TIME) ensures downstream gets TIME-based
-        // segments, preventing gst_segment_to_stream_time assertion failures.
-        const capsStr = `audio/x-raw,format=F32LE,rate=${sr},channels=${ch},layout=interleaved`;
-        const desc = `appsrc name=src caps="${capsStr}" format=3 ! audioconvert ! volume name=vol ! autoaudiosink`;
-        this._pipeline = Gst.parse_launch(desc);
-        this._volumeElement = this._pipeline.get_by_name('vol');
-        const appsrc = this._pipeline.get_by_name('src')!;
-
-        // Set volume
-        this._volumeElement.set_property('volume', Math.max(0, Math.min(volume, 10)));
-
-        // Set up bus watch for EOS/ERROR
-        const bus = this._pipeline.get_bus();
-        this._busWatchId = bus.add_watch(0, (_bus: any, msg: any) => {
-            if (msg.type === Gst.MessageType.EOS) {
-                if (this._loop && !this._ended) {
-                    // Restart: push data again
-                    this._restartPlayback(appsrc, pcmData);
-                } else {
-                    this._fireEnded();
-                }
-            } else if (msg.type === Gst.MessageType.ERROR) {
-                this._fireEnded();
-            }
-            return true; // keep watching
-        });
-
-        // Push PCM data with proper timestamps for TIME-format segments
-        const gstBuf = Gst.Buffer.new_wrapped(pcmData);
-        const totalFrames = pcmData.length / (4 * ch);
-        gstBuf.pts = 0;
-        gstBuf.duration = Math.floor((totalFrames / sr) * Number(Gst.SECOND));
-        appsrc.push_buffer(gstBuf);
-        appsrc.end_of_stream();
-
-        // Apply playback rate if not 1.0
-        if (playbackRate !== 1.0) {
-            this._pipeline.set_state(Gst.State.PAUSED);
-            // Seek with rate change
-            this._pipeline.seek(
-                playbackRate,
-                Gst.Format.TIME,
-                Gst.SeekFlags.FLUSH | Gst.SeekFlags.ACCURATE,
-                Gst.SeekType.SET, 0,
-                Gst.SeekType.NONE, -1
-            );
-        }
-
-        this._pipeline.set_state(Gst.State.PLAYING);
-    }
-
-    /** Update volume on a running pipeline */
-    setVolume(value: number): void {
-        if (this._volumeElement && !this._ended) {
-            this._volumeElement.set_property('volume', Math.max(0, Math.min(value, 10)));
-        }
-    }
-
-    /** Update loop flag */
-    setLoop(value: boolean): void {
-        this._loop = value;
-    }
-
-    /** Stop playback and clean up */
-    stop(): void {
-        if (this._ended) return;
-        this._fireEnded();
-    }
-
-    /** Whether playback has ended */
-    get ended(): boolean {
-        return this._ended;
-    }
-
-    private _restartPlayback(appsrc: any, pcmData: Uint8Array): void {
-        // For looping: seek pipeline to start
-        if (this._pipeline) {
-            this._pipeline.seek_simple(Gst.Format.TIME, Gst.SeekFlags.FLUSH, 0);
-        }
-    }
-
-    private _fireEnded(): void {
-        if (this._ended) return;
-        this._ended = true;
-        this._cleanup();
-        this._onEnded();
-    }
-
-    private _cleanup(): void {
-        const pipeline = this._pipeline;
-        this._pipeline = null;
-        this._volumeElement = null;
-        this._busWatchId = null;
-
-        if (pipeline) {
-            // Defer NULL-state transition to a low-priority idle so this method does not
-            // block the GLib main loop when called from within the bus-watch callback (EOS/ERROR).
-            // autoaudiosink teardown flushes the audio device, which can take several ms and
-            // causes frame drops when SFX fire frequently during gameplay.
-            GLib.idle_add(GLib.PRIORITY_LOW, () => {
-                pipeline.set_state(Gst.State.NULL);
-                return GLib.SOURCE_REMOVE;
-            });
-        }
-    }
-
-    /**
-     * Interleave AudioBuffer's per-channel Float32Arrays into a single Uint8Array.
-     * Applies offset (seconds) and optional duration (seconds).
-     */
-    private _interleave(buf: AudioBuffer, offsetSec: number, durationSec?: number): Uint8Array {
-        const ch = buf.numberOfChannels;
-        const startFrame = Math.min(Math.floor(offsetSec * buf.sampleRate), buf.length);
-        const maxFrames = buf.length - startFrame;
-        const frames = durationSec !== undefined
-            ? Math.min(Math.floor(durationSec * buf.sampleRate), maxFrames)
-            : maxFrames;
-
-        if (frames <= 0) return new Uint8Array(0);
-
-        const interleaved = new Float32Array(frames * ch);
-        for (let frame = 0; frame < frames; frame++) {
-            for (let c = 0; c < ch; c++) {
-                interleaved[frame * ch + c] = buf._channelData[c][startFrame + frame];
-            }
-        }
-
-        return new Uint8Array(interleaved.buffer);
-    }
-}

package/src/html-audio-element.ts

@@ -1,76 +0,0 @@
-// HTMLAudioElement — format detection + basic playback via GStreamer playbin.
-// Used by Excalibur.js for canPlayType() format sniffing.
-//
-// Reference: https://developer.mozilla.org/en-US/docs/Web/API/HTMLAudioElement
-
-import { ensureGstInit, Gst } from './gst-init.js';
-
-// GStreamer-supported MIME types (common on GNOME systems)
-const SUPPORTED_TYPES = new Set([
-    'audio/mpeg',
-    'audio/mp3',
-    'audio/wav',
-    'audio/x-wav',
-    'audio/ogg',
-    'audio/webm',
-    'audio/flac',
-    'audio/x-flac',
-    'audio/aac',
-    'audio/mp4',
-]);
-
-export class HTMLAudioElement {
-    src = '';
-    volume = 1;
-    loop = false;
-    paused = true;
-    currentTime = 0;
-    duration = 0;
-    readyState = 0;
-
-    private _pipeline: any = null;
-
-    canPlayType(type: string): CanPlayTypeResult {
-        // Strip codecs parameter: "audio/ogg; codecs=vorbis" → "audio/ogg"
-        const mime = type.split(';')[0].trim().toLowerCase();
-        return SUPPORTED_TYPES.has(mime) ? 'maybe' : '';
-    }
-
-    play(): Promise<void> {
-        if (!this.src) return Promise.resolve();
-
-        ensureGstInit();
-        this._cleanup();
-
-        this._pipeline = Gst.ElementFactory.make('playbin', 'player');
-        if (!this._pipeline) return Promise.resolve();
-
-        this._pipeline.set_property('uri', this.src);
-        this._pipeline.set_property('volume', this.volume);
-        this._pipeline.set_state(Gst.State.PLAYING);
-        this.paused = false;
-
-        return Promise.resolve();
-    }
-
-    pause(): void {
-        if (this._pipeline) {
-            this._pipeline.set_state(Gst.State.PAUSED);
-            this.paused = true;
-        }
-    }
-
-    load(): void {
-        this._cleanup();
-    }
-
-    addEventListener(_type: string, _listener: any): void {}
-    removeEventListener(_type: string, _listener: any): void {}
-
-    private _cleanup(): void {
-        if (this._pipeline) {
-            this._pipeline.set_state(Gst.State.NULL);
-            this._pipeline = null;
-        }
-    }
-}

package/src/index.ts

@@ -1,14 +0,0 @@
-// Web Audio API for GJS — backed by GStreamer 1.0.
-//
-// This module has no side effects. Importing @gjsify/webaudio gives
-// named access to Web Audio classes but does NOT register globals.
-// Use @gjsify/webaudio/register to set globalThis.AudioContext, etc.
-
-export { AudioContext } from './audio-context.js';
-export { AudioBuffer } from './audio-buffer.js';
-export { AudioNode } from './audio-node.js';
-export { AudioDestinationNode } from './audio-destination-node.js';
-export { AudioBufferSourceNode } from './audio-buffer-source-node.js';
-export { GainNode } from './gain-node.js';
-export { AudioParam } from './audio-param.js';
-export { HTMLAudioElement } from './html-audio-element.js';

package/src/register.ts

@@ -1,17 +0,0 @@
-// Side-effect module: registers Web Audio API globals on GJS.
-// On Node.js the alias layer routes this to @gjsify/empty.
-
-import { AudioContext, HTMLAudioElement } from './index.js';
-
-if (typeof (globalThis as any).AudioContext === 'undefined') {
-    (globalThis as any).AudioContext = AudioContext;
-}
-if (typeof (globalThis as any).webkitAudioContext === 'undefined') {
-    (globalThis as any).webkitAudioContext = AudioContext;
-}
-if (typeof (globalThis as any).Audio === 'undefined') {
-    (globalThis as any).Audio = HTMLAudioElement;
-}
-if (typeof (globalThis as any).HTMLAudioElement === 'undefined') {
-    (globalThis as any).HTMLAudioElement = HTMLAudioElement;
-}

package/src/test.mts

@@ -1,5 +0,0 @@
-import webaudioSpec from './webaudio.spec.js';
-
-const results = {
-    webaudio: await webaudioSpec(),
-};

package/src/webaudio.spec.ts

@@ -1,351 +0,0 @@
-// Web Audio API tests — GJS only (requires GStreamer)
-//
-// Ported from W3C Web Audio API spec behavior.
-// Reference: https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API
-
-import { describe, it, expect } from '@gjsify/unit';
-import { AudioContext } from './audio-context.js';
-import { AudioBuffer } from './audio-buffer.js';
-import { AudioParam } from './audio-param.js';
-import { AudioNode } from './audio-node.js';
-import { GainNode } from './gain-node.js';
-import { AudioBufferSourceNode } from './audio-buffer-source-node.js';
-import { AudioDestinationNode } from './audio-destination-node.js';
-import { HTMLAudioElement } from './html-audio-element.js';
-
-/** Generate a minimal WAV ArrayBuffer (mono, 16-bit PCM, 440Hz sine) */
-function createTestWav(durationSec = 0.1, sampleRate = 44100): ArrayBuffer {
-    const numSamples = Math.floor(durationSec * sampleRate);
-    const bitsPerSample = 16;
-    const numChannels = 1;
-    const dataSize = numSamples * numChannels * (bitsPerSample / 8);
-    const buf = new ArrayBuffer(44 + dataSize);
-    const view = new DataView(buf);
-    const writeStr = (offset: number, str: string) => {
-        for (let i = 0; i < str.length; i++) view.setUint8(offset + i, str.charCodeAt(i));
-    };
-    writeStr(0, 'RIFF');
-    view.setUint32(4, 36 + dataSize, true);
-    writeStr(8, 'WAVE');
-    writeStr(12, 'fmt ');
-    view.setUint32(16, 16, true);
-    view.setUint16(20, 1, true);
-    view.setUint16(22, numChannels, true);
-    view.setUint32(24, sampleRate, true);
-    view.setUint32(28, sampleRate * numChannels * bitsPerSample / 8, true);
-    view.setUint16(32, numChannels * bitsPerSample / 8, true);
-    view.setUint16(34, bitsPerSample, true);
-    writeStr(36, 'data');
-    view.setUint32(40, dataSize, true);
-    for (let i = 0; i < numSamples; i++) {
-        const sample = Math.sin(2 * Math.PI * 440 * i / sampleRate);
-        view.setInt16(44 + i * 2, Math.round(sample * 32767), true);
-    }
-    return buf;
-}
-
-export default async () => {
-    await describe('AudioContext', async () => {
-        await it('should start in suspended state', async () => {
-            const ctx = new AudioContext();
-            expect(ctx.state).toBe('suspended');
-        });
-
-        await it('should transition to running on resume', async () => {
-            const ctx = new AudioContext();
-            await ctx.resume();
-            expect(ctx.state).toBe('running');
-        });
-
-        await it('should transition to suspended on suspend', async () => {
-            const ctx = new AudioContext();
-            await ctx.resume();
-            await ctx.suspend();
-            expect(ctx.state).toBe('suspended');
-        });
-
-        await it('should transition to closed on close', async () => {
-            const ctx = new AudioContext();
-            await ctx.close();
-            expect(ctx.state).toBe('closed');
-        });
-
-        await it('should have sampleRate of 44100', async () => {
-            const ctx = new AudioContext();
-            expect(ctx.sampleRate).toBe(44100);
-        });
-
-        await it('should have a destination node', async () => {
-            const ctx = new AudioContext();
-            expect(ctx.destination).toBeDefined();
-            expect(ctx.destination instanceof AudioDestinationNode).toBe(true);
-        });
-    });
-
-    await describe('AudioContext.currentTime', async () => {
-        await it('should be a number >= 0', async () => {
-            const ctx = new AudioContext();
-            expect(typeof ctx.currentTime).toBe('number');
-            expect(ctx.currentTime >= 0).toBe(true);
-        });
-
-        await it('should increase monotonically', async () => {
-            const ctx = new AudioContext();
-            const t1 = ctx.currentTime;
-            // Small busy-wait to ensure time passes
-            const start = Date.now();
-            while (Date.now() - start < 5) { /* busy wait */ }
-            const t2 = ctx.currentTime;
-            expect(t2 > t1).toBe(true);
-        });
-    });
-
-    await describe('AudioContext.createBuffer', async () => {
-        await it('should create a buffer with correct properties', async () => {
-            const ctx = new AudioContext();
-            const buf = ctx.createBuffer(2, 44100, 44100);
-            expect(buf.numberOfChannels).toBe(2);
-            expect(buf.length).toBe(44100);
-            expect(buf.sampleRate).toBe(44100);
-            expect(buf.duration).toBe(1);
-        });
-    });
-
-    await describe('AudioBuffer', async () => {
-        await it('should return Float32Array from getChannelData', async () => {
-            const buf = new AudioBuffer({ numberOfChannels: 2, length: 100, sampleRate: 44100 });
-            const ch0 = buf.getChannelData(0);
-            expect(ch0 instanceof Float32Array).toBe(true);
-            expect(ch0.length).toBe(100);
-        });
-
-        await it('should throw on invalid channel index', async () => {
-            const buf = new AudioBuffer({ numberOfChannels: 1, length: 10, sampleRate: 44100 });
-            expect(() => buf.getChannelData(1)).toThrow();
-        });
-
-        await it('should support copyFromChannel/copyToChannel round-trip', async () => {
-            const buf = new AudioBuffer({ numberOfChannels: 1, length: 4, sampleRate: 44100 });
-            const src = new Float32Array([0.1, 0.2, 0.3, 0.4]);
-            buf.copyToChannel(src, 0);
-            const dst = new Float32Array(4);
-            buf.copyFromChannel(dst, 0);
-            expect(dst[0]).toBe(src[0]);
-            expect(dst[3]).toBe(src[3]);
-        });
-
-        await it('should calculate duration correctly', async () => {
-            const buf = new AudioBuffer({ numberOfChannels: 1, length: 22050, sampleRate: 44100 });
-            expect(buf.duration).toBe(0.5);
-        });
-    });
-
-    await describe('AudioContext.decodeAudioData', async () => {
-        await it('should decode a WAV file', async () => {
-            const ctx = new AudioContext();
-            const wav = createTestWav(0.1, 44100);
-            const buf = await ctx.decodeAudioData(wav);
-            expect(buf instanceof AudioBuffer).toBe(true);
-            expect(buf.sampleRate).toBe(44100);
-            expect(buf.numberOfChannels).toBe(1);
-            // Duration should be approximately 0.1s (allow some tolerance for decoder)
-            expect(buf.duration > 0.09).toBe(true);
-            expect(buf.duration < 0.15).toBe(true);
-        });
-
-        await it('should produce non-zero PCM data', async () => {
-            const ctx = new AudioContext();
-            const wav = createTestWav(0.1, 44100);
-            const buf = await ctx.decodeAudioData(wav);
-            const data = buf.getChannelData(0);
-            let nonZero = 0;
-            for (let i = 0; i < data.length; i++) {
-                if (data[i] !== 0) nonZero++;
-            }
-            expect(nonZero > data.length * 0.9).toBe(true);
-        });
-
-        await it('should call success callback', async () => {
-            const ctx = new AudioContext();
-            const wav = createTestWav(0.05);
-            let callbackResult: AudioBuffer | null = null;
-            await ctx.decodeAudioData(wav, (buf) => { callbackResult = buf; });
-            expect(callbackResult).toBeDefined();
-            expect(callbackResult!.numberOfChannels).toBe(1);
-        });
-
-        await it('should reject invalid data', async () => {
-            const ctx = new AudioContext();
-            const invalid = new ArrayBuffer(10);
-            let rejected = false;
-            try {
-                await ctx.decodeAudioData(invalid);
-            } catch {
-                rejected = true;
-            }
-            expect(rejected).toBe(true);
-        });
-    });
-
-    await describe('AudioNode', async () => {
-        await it('should connect and disconnect', async () => {
-            const a = new AudioNode();
-            const b = new AudioNode();
-            a.connect(b);
-            expect(a._outputs.has(b)).toBe(true);
-            expect(b._inputs.has(a)).toBe(true);
-            a.disconnect(b);
-            expect(a._outputs.has(b)).toBe(false);
-            expect(b._inputs.has(a)).toBe(false);
-        });
-
-        await it('should return destination from connect()', async () => {
-            const a = new AudioNode();
-            const b = new AudioNode();
-            const result = a.connect(b);
-            expect(result).toBe(b);
-        });
-
-        await it('should disconnect all on disconnect()', async () => {
-            const a = new AudioNode();
-            const b = new AudioNode();
-            const c = new AudioNode();
-            a.connect(b);
-            a.connect(c);
-            a.disconnect();
-            expect(a._outputs.size).toBe(0);
-        });
-    });
-
-    await describe('GainNode', async () => {
-        await it('should have gain AudioParam with default 1', async () => {
-            const gain = new GainNode();
-            expect(gain.gain instanceof AudioParam).toBe(true);
-            expect(gain.gain.value).toBe(1);
-        });
-
-        await it('should allow setting gain value', async () => {
-            const gain = new GainNode();
-            gain.gain.value = 0.5;
-            expect(gain.gain.value).toBe(0.5);
-        });
-    });
-
-    await describe('AudioParam', async () => {
-        await it('should have correct default value', async () => {
-            const param = new AudioParam(0.75);
-            expect(param.value).toBe(0.75);
-            expect(param.defaultValue).toBe(0.75);
-        });
-
-        await it('should clamp to min/max', async () => {
-            const param = new AudioParam(0, 0, 1);
-            param.value = 2;
-            expect(param.value).toBe(1);
-            param.value = -1;
-            expect(param.value).toBe(0);
-        });
-
-        await it('should call onChange callback', async () => {
-            const param = new AudioParam(0);
-            let called = false;
-            param._onChange = () => { called = true; };
-            param.value = 0.5;
-            expect(called).toBe(true);
-        });
-    });
-
-    await describe('AudioBufferSourceNode', async () => {
-        await it('should have default properties', async () => {
-            const node = new AudioBufferSourceNode();
-            expect(node.buffer).toBeNull();
-            expect(node.loop).toBe(false);
-            expect(node.playbackRate.value).toBe(1);
-        });
-
-        await it('should throw if started twice', async () => {
-            const node = new AudioBufferSourceNode();
-            node.buffer = new AudioBuffer({ numberOfChannels: 1, length: 100, sampleRate: 44100 });
-            const gain = new GainNode();
-            const dest = new AudioDestinationNode();
-            node.connect(gain).connect(dest);
-            node.start();
-            expect(() => node.start()).toThrow();
-        });
-
-        await it('should fire onended after playback completes', async () => {
-            const ctx = new AudioContext();
-            const wav = createTestWav(0.05, 44100); // 50ms
-            const buf = await ctx.decodeAudioData(wav);
-
-            const source = ctx.createBufferSource();
-            const gain = ctx.createGain();
-            gain.gain.value = 0; // silent
-            source.buffer = buf;
-            source.connect(gain).connect(ctx.destination);
-
-            let ended = false;
-            source.onended = () => { ended = true; };
-            source.start();
-
-            // Wait for playback to finish (50ms buffer + margin)
-            await new Promise<void>(resolve => setTimeout(resolve, 500));
-            expect(ended).toBe(true);
-        });
-
-        await it('should not fire onended while looping', async () => {
-            const ctx = new AudioContext();
-            const wav = createTestWav(0.05, 44100); // 50ms
-            const buf = await ctx.decodeAudioData(wav);
-
-            const source = ctx.createBufferSource();
-            const gain = ctx.createGain();
-            gain.gain.value = 0; // silent
-            source.buffer = buf;
-            source.loop = true;
-            source.connect(gain).connect(ctx.destination);
-
-            let ended = false;
-            source.onended = () => { ended = true; };
-            source.start();
-
-            // Wait longer than one full play cycle
-            await new Promise<void>(resolve => setTimeout(resolve, 300));
-            expect(ended).toBe(false);
-
-            // Explicitly stop — should fire onended
-            source.stop();
-            expect(ended).toBe(true);
-        });
-
-        await it('should support connect chain source→gain→destination', async () => {
-            const ctx = new AudioContext();
-            const source = ctx.createBufferSource();
-            const gain = ctx.createGain();
-            const result = source.connect(gain).connect(ctx.destination);
-            expect(result).toBe(ctx.destination);
-            expect(source._outputs.has(gain)).toBe(true);
-            expect(gain._outputs.has(ctx.destination)).toBe(true);
-        });
-    });
-
-    await describe('HTMLAudioElement', async () => {
-        await it('should return maybe for supported types', async () => {
-            const audio = new HTMLAudioElement();
-            expect(audio.canPlayType('audio/mpeg')).toBe('maybe');
-            expect(audio.canPlayType('audio/wav')).toBe('maybe');
-            expect(audio.canPlayType('audio/ogg')).toBe('maybe');
-        });
-
-        await it('should return empty for unsupported types', async () => {
-            const audio = new HTMLAudioElement();
-            expect(audio.canPlayType('audio/unknown')).toBe('');
-            expect(audio.canPlayType('video/mp4')).toBe('');
-        });
-
-        await it('should handle codecs parameter', async () => {
-            const audio = new HTMLAudioElement();
-            expect(audio.canPlayType('audio/ogg; codecs=vorbis')).toBe('maybe');
-        });
-    });
-};

package/tsconfig.json

@@ -1,36 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "ESNext",
-    "types": [
-      "node",
-      "@girs/gjs",
-      "@girs/gst-1.0",
-      "@girs/gstapp-1.0",
-      "@girs/gstaudio-1.0",
-      "@girs/gstbase-1.0",
-      "@girs/glib-2.0"
-    ],
-    "target": "ESNext",
-    "experimentalDecorators": true,
-    "emitDeclarationOnly": true,
-    "declaration": true,
-    "outDir": "lib",
-    "rootDir": "src",
-    "declarationDir": "lib/types",
-    "composite": true,
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "skipLibCheck": true,
-    "allowJs": true,
-    "checkJs": false,
-    "strict": false
-  },
-  "reflection": false,
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "src/test.ts",
-    "src/test.mts"
-  ]
-}