mediabunny 1.0.2 → 1.0.4

package/dist/modules/source.d.ts

@@ -0,0 +1,76 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+/**
+ * The source base class, representing a resource from which bytes can be read.
+ * @public
+ */
+export declare abstract class Source {
+    /**
+     * Resolves with the total size of the file in bytes. This function is memoized, meaning only the first call
+     * will retrieve the size.
+     */
+    getSize(): Promise<number>;
+    /** Called each time data is requested from the source. */
+    onread: ((start: number, end: number) => unknown) | null;
+}
+/**
+ * A source backed by an ArrayBuffer or ArrayBufferView, with the entire file held in memory.
+ * @public
+ */
+export declare class BufferSource extends Source {
+    constructor(buffer: ArrayBuffer | Uint8Array);
+}
+/**
+ * Options for defining a StreamSource.
+ * @public
+ */
+export type StreamSourceOptions = {
+    /** Called when data is requested. Should return or resolve to the bytes from the specified byte range. */
+    read: (start: number, end: number) => Uint8Array | Promise<Uint8Array>;
+    /** Called when the size of the entire file is requested. Should return or resolve to the size in bytes. */
+    getSize: () => number | Promise<number>;
+};
+/**
+ * A general-purpose, callback-driven source that can get its data from anywhere.
+ * @public
+ */
+export declare class StreamSource extends Source {
+    constructor(options: StreamSourceOptions);
+}
+/**
+ * A source backed by a Blob. Since Files are also Blobs, this is the source to use when reading files off the disk.
+ * @public
+ */
+export declare class BlobSource extends Source {
+    constructor(blob: Blob);
+}
+/**
+ * Options for UrlSource.
+ * @public
+ */
+export type UrlSourceOptions = {
+    /**
+     * The RequestInit used by the Fetch API. Can be used to further control the requests, such as setting
+     * custom headers.
+     */
+    requestInit?: RequestInit;
+    /**
+     * A function that returns the delay (in seconds) before retrying a failed request. The function is called
+     * with the number of previous, unsuccessful attempts. If the function returns `null`, no more retries will be made.
+     */
+    getRetryDelay?: (previousAttempts: number) => number | null;
+};
+/**
+ * A source backed by a URL. This is useful for reading data from the network. Be careful using this source however,
+ * as it typically comes with increased latency.
+ * @beta
+ */
+export declare class UrlSource extends Source {
+    constructor(url: string | URL, options?: UrlSourceOptions);
+}
+//# sourceMappingURL=source.d.ts.map

package/dist/modules/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/source.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;GAGG;AACH,8BAAsB,MAAM;IAS3B;;;OAGG;IACH,OAAO;IAIP,0DAA0D;IAC1D,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,IAAI,CAAQ;CAChE;AAED;;;GAGG;AACH,qBAAa,YAAa,SAAQ,MAAM;gBAI3B,MAAM,EAAE,WAAW,GAAG,UAAU;CAmB5C;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG;IACjC,0GAA0G;IAC1G,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACvE,2GAA2G;IAC3G,OAAO,EAAE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACxC,CAAC;AAEF;;;GAGG;AACH,qBAAa,YAAa,SAAQ,MAAM;gBAI3B,OAAO,EAAE,mBAAmB;CAyBxC;AAED;;;GAGG;AACH,qBAAa,UAAW,SAAQ,MAAM;gBAIzB,IAAI,EAAE,IAAI;CAqBtB;AAED;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC9B;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;;OAGG;IACH,aAAa,CAAC,EAAE,CAAC,gBAAgB,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CAC5D,CAAC;AAEF;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,MAAM;gBASnC,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,OAAO,GAAE,gBAAqB;CAwG/B"}

package/dist/modules/source.js

@@ -0,0 +1,183 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { mergeObjectsDeeply, retriedFetch } from './misc.js';
+/**
+ * The source base class, representing a resource from which bytes can be read.
+ * @public
+ */
+export class Source {
+    constructor() {
+        /** @internal */
+        this._sizePromise = null;
+        /** Called each time data is requested from the source. */
+        this.onread = null;
+    }
+    /**
+     * Resolves with the total size of the file in bytes. This function is memoized, meaning only the first call
+     * will retrieve the size.
+     */
+    getSize() {
+        return this._sizePromise ??= this._retrieveSize();
+    }
+}
+/**
+ * A source backed by an ArrayBuffer or ArrayBufferView, with the entire file held in memory.
+ * @public
+ */
+export class BufferSource extends Source {
+    constructor(buffer) {
+        if (!(buffer instanceof ArrayBuffer) && !(buffer instanceof Uint8Array)) {
+            throw new TypeError('buffer must be an ArrayBuffer or Uint8Array.');
+        }
+        super();
+        this._bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    }
+    /** @internal */
+    async _read(start, end) {
+        return this._bytes.subarray(start, end);
+    }
+    /** @internal */
+    async _retrieveSize() {
+        return this._bytes.byteLength;
+    }
+}
+/**
+ * A general-purpose, callback-driven source that can get its data from anywhere.
+ * @public
+ */
+export class StreamSource extends Source {
+    constructor(options) {
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('options must be an object.');
+        }
+        if (typeof options.read !== 'function') {
+            throw new TypeError('options.read must be a function.');
+        }
+        if (typeof options.getSize !== 'function') {
+            throw new TypeError('options.getSize must be a function.');
+        }
+        super();
+        this._options = options;
+    }
+    /** @internal */
+    async _read(start, end) {
+        return this._options.read(start, end);
+    }
+    /** @internal */
+    async _retrieveSize() {
+        return this._options.getSize();
+    }
+}
+/**
+ * A source backed by a Blob. Since Files are also Blobs, this is the source to use when reading files off the disk.
+ * @public
+ */
+export class BlobSource extends Source {
+    constructor(blob) {
+        if (!(blob instanceof Blob)) {
+            throw new TypeError('blob must be a Blob.');
+        }
+        super();
+        this._blob = blob;
+    }
+    /** @internal */
+    async _read(start, end) {
+        const slice = this._blob.slice(start, end);
+        const buffer = await slice.arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+    /** @internal */
+    async _retrieveSize() {
+        return this._blob.size;
+    }
+}
+/**
+ * A source backed by a URL. This is useful for reading data from the network. Be careful using this source however,
+ * as it typically comes with increased latency.
+ * @beta
+ */
+export class UrlSource extends Source {
+    constructor(url, options = {}) {
+        if (typeof url !== 'string' && !(url instanceof URL)) {
+            throw new TypeError('url must be a string or URL.');
+        }
+        if (!options || typeof options !== 'object') {
+            throw new TypeError('options must be an object.');
+        }
+        if (options.requestInit !== undefined && (!options.requestInit || typeof options.requestInit !== 'object')) {
+            throw new TypeError('options.requestInit, when provided, must be an object.');
+        }
+        if (options.getRetryDelay !== undefined && typeof options.getRetryDelay !== 'function') {
+            throw new TypeError('options.getRetryDelay, when provided, must be a function.');
+        }
+        super();
+        /** @internal */
+        this._fullData = null;
+        this._url = url;
+        this._options = options;
+    }
+    /** @internal */
+    async _makeRequest(range) {
+        const headers = {};
+        if (range) {
+            headers['Range'] = `bytes=${range.start}-${range.end - 1}`;
+        }
+        const response = await retriedFetch(this._url, mergeObjectsDeeply(this._options.requestInit ?? {}, {
+            method: 'GET',
+            headers,
+        }), this._options.getRetryDelay ?? (() => null));
+        if (!response.ok) {
+            throw new Error(`Error fetching ${this._url}: ${response.status} ${response.statusText}`);
+        }
+        const buffer = await response.arrayBuffer();
+        if (!range) {
+            this._fullData = buffer;
+        }
+        return {
+            response: buffer,
+            statusCode: response.status,
+        };
+    }
+    /** @internal */
+    async _read(start, end) {
+        if (this._fullData) {
+            return new Uint8Array(this._fullData, start, end - start);
+        }
+        const { response, statusCode } = await this._makeRequest({ start, end });
+        // If server doesn't support range requests, it will return 200 instead of 206. In that case, let's manually
+        // slice the response.
+        if (statusCode === 200) {
+            const fullData = new Uint8Array(response);
+            return fullData.subarray(start, end);
+        }
+        return new Uint8Array(response);
+    }
+    /** @internal */
+    async _retrieveSize() {
+        if (this._fullData) {
+            return this._fullData.byteLength;
+        }
+        // Try a range request to get the Content-Range header
+        const rangeResponse = await retriedFetch(this._url, mergeObjectsDeeply(this._options.requestInit ?? {}, {
+            method: 'GET',
+            headers: { Range: 'bytes=0-0' },
+        }), this._options.getRetryDelay ?? (() => null));
+        if (rangeResponse.status === 206) {
+            const contentRange = rangeResponse.headers.get('Content-Range');
+            if (contentRange) {
+                const match = contentRange.match(/bytes \d+-\d+\/(\d+)/);
+                if (match && match[1]) {
+                    return parseInt(match[1], 10);
+                }
+            }
+        }
+        // If the range request didn't provide the size, make a full GET request
+        const { response } = await this._makeRequest();
+        return response.byteLength;
+    }
+}

package/dist/modules/subtitles.d.ts

@@ -0,0 +1,37 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export type SubtitleCue = {
+    timestamp: number;
+    duration: number;
+    text: string;
+    identifier?: string;
+    settings?: string;
+    notes?: string;
+};
+export type SubtitleConfig = {
+    description: string;
+};
+export type SubtitleMetadata = {
+    config?: SubtitleConfig;
+};
+type SubtitleParserOptions = {
+    codec: 'webvtt';
+    output: (cue: SubtitleCue, metadata: SubtitleMetadata) => unknown;
+};
+export declare const inlineTimestampRegex: RegExp;
+export declare class SubtitleParser {
+    private options;
+    private preambleText;
+    private preambleEmitted;
+    constructor(options: SubtitleParserOptions);
+    parse(text: string): void;
+}
+export declare const parseSubtitleTimestamp: (string: string) => number;
+export declare const formatSubtitleTimestamp: (timestamp: number) => string;
+export {};
+//# sourceMappingURL=subtitles.d.ts.map

package/dist/modules/subtitles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtitles.d.ts","sourceRoot":"","sources":["../../src/subtitles.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,WAAW,GAAG;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC5B,WAAW,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC9B,MAAM,CAAC,EAAE,cAAc,CAAC;CACxB,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC5B,KAAK,EAAE,QAAQ,CAAC;IAChB,MAAM,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,gBAAgB,KAAK,OAAO,CAAC;CAClE,CAAC;AAIF,eAAO,MAAM,oBAAoB,QAA4C,CAAC;AAE9E,qBAAa,cAAc;IAC1B,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,eAAe,CAAS;gBAEpB,OAAO,EAAE,qBAAqB;IAI1C,KAAK,CAAC,IAAI,EAAE,MAAM;CAgElB;AAGD,eAAO,MAAM,sBAAsB,GAAI,QAAQ,MAAM,WAQpD,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,WAAW,MAAM,WAUxD,CAAC"}

package/dist/modules/subtitles.js

@@ -0,0 +1,89 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+const cueBlockHeaderRegex = /(?:(.+?)\n)?((?:\d{2}:)?\d{2}:\d{2}.\d{3})\s+-->\s+((?:\d{2}:)?\d{2}:\d{2}.\d{3})/g;
+const preambleStartRegex = /^WEBVTT(.|\n)*?\n{2}/;
+export const inlineTimestampRegex = /<(?:(\d{2}):)?(\d{2}):(\d{2}).(\d{3})>/g;
+export class SubtitleParser {
+    constructor(options) {
+        this.preambleText = null;
+        this.preambleEmitted = false;
+        this.options = options;
+    }
+    parse(text) {
+        text = text.replaceAll('\r\n', '\n').replaceAll('\r', '\n');
+        cueBlockHeaderRegex.lastIndex = 0;
+        let match;
+        if (!this.preambleText) {
+            if (!preambleStartRegex.test(text)) {
+                throw new Error('WebVTT preamble incorrect.');
+            }
+            match = cueBlockHeaderRegex.exec(text);
+            const preamble = text.slice(0, match?.index ?? text.length).trimEnd();
+            if (!preamble) {
+                throw new Error('No WebVTT preamble provided.');
+            }
+            this.preambleText = preamble;
+            if (match) {
+                text = text.slice(match.index);
+                cueBlockHeaderRegex.lastIndex = 0;
+            }
+        }
+        while ((match = cueBlockHeaderRegex.exec(text))) {
+            const notes = text.slice(0, match.index);
+            const cueIdentifier = match[1];
+            const matchEnd = match.index + match[0].length;
+            const bodyStart = text.indexOf('\n', matchEnd) + 1;
+            const cueSettings = text.slice(matchEnd, bodyStart).trim();
+            let bodyEnd = text.indexOf('\n\n', matchEnd);
+            if (bodyEnd === -1)
+                bodyEnd = text.length;
+            const startTime = parseSubtitleTimestamp(match[2]);
+            const endTime = parseSubtitleTimestamp(match[3]);
+            const duration = endTime - startTime;
+            const body = text.slice(bodyStart, bodyEnd).trim();
+            text = text.slice(bodyEnd).trimStart();
+            cueBlockHeaderRegex.lastIndex = 0;
+            const cue = {
+                timestamp: startTime / 1000,
+                duration: duration / 1000,
+                text: body,
+                identifier: cueIdentifier,
+                settings: cueSettings,
+                notes,
+            };
+            const meta = {};
+            if (!this.preambleEmitted) {
+                meta.config = {
+                    description: this.preambleText,
+                };
+                this.preambleEmitted = true;
+            }
+            this.options.output(cue, meta);
+        }
+    }
+}
+const timestampRegex = /(?:(\d{2}):)?(\d{2}):(\d{2}).(\d{3})/;
+export const parseSubtitleTimestamp = (string) => {
+    const match = timestampRegex.exec(string);
+    if (!match)
+        throw new Error('Expected match.');
+    return 60 * 60 * 1000 * Number(match[1] || '0')
+        + 60 * 1000 * Number(match[2])
+        + 1000 * Number(match[3])
+        + Number(match[4]);
+};
+export const formatSubtitleTimestamp = (timestamp) => {
+    const hours = Math.floor(timestamp / (60 * 60 * 1000));
+    const minutes = Math.floor((timestamp % (60 * 60 * 1000)) / (60 * 1000));
+    const seconds = Math.floor((timestamp % (60 * 1000)) / 1000);
+    const milliseconds = timestamp % 1000;
+    return hours.toString().padStart(2, '0') + ':'
+        + minutes.toString().padStart(2, '0') + ':'
+        + seconds.toString().padStart(2, '0') + '.'
+        + milliseconds.toString().padStart(3, '0');
+};

package/dist/modules/target.d.ts

@@ -0,0 +1,58 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+/**
+ * Base class for targets, specifying where output files are written.
+ * @public
+ */
+export declare abstract class Target {
+}
+/**
+ * A target that writes data directly into an ArrayBuffer in memory. Great for performance, but not suitable for very
+ * large files. The buffer will be available once the output has been finalized.
+ * @public
+ */
+export declare class BufferTarget extends Target {
+    /** Stores the final output buffer. Until the output is finalized, this will be null. */
+    buffer: ArrayBuffer | null;
+}
+/**
+ * A data chunk for StreamTarget.
+ * @public
+ */
+export type StreamTargetChunk = {
+    /** The operation type. */
+    type: 'write';
+    /** The data to write. */
+    data: Uint8Array;
+    /** The byte offset in the output file at which to write the data. */
+    position: number;
+};
+/**
+ * Options for StreamTarget.
+ * @public
+ */
+export type StreamTargetOptions = {
+    /**
+     * When setting this to true, data created by the output will first be accumulated and only written out
+     * once it has reached sufficient size, using a default chunk size of 16 MiB. This is useful for reducing the total
+     * amount of writes, at the cost of latency.
+     */
+    chunked?: boolean;
+    /** When using `chunked: true`, this specifies the maximum size of each chunk. Defaults to 16 MiB. */
+    chunkSize?: number;
+};
+/**
+ * This target writes data to a WritableStream, making it a general-purpose target for writing data anywhere. It is
+ * also compatible with FileSystemWritableFileStream for use with the File System Access API. The WritableStream can
+ * also apply backpressure, which will propagate to the output and throttle the encoders.
+ * @public
+ */
+export declare class StreamTarget extends Target {
+    constructor(writable: WritableStream<StreamTargetChunk>, options?: StreamTargetOptions);
+}
+//# sourceMappingURL=target.d.ts.map

package/dist/modules/target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../src/target.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH;;;GAGG;AACH,8BAAsB,MAAM;CAM3B;AAED;;;;GAIG;AACH,qBAAa,YAAa,SAAQ,MAAM;IACvC,wFAAwF;IACxF,MAAM,EAAE,WAAW,GAAG,IAAI,CAAQ;CAMlC;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B,0BAA0B;IAC1B,IAAI,EAAE,OAAO,CAAC;IACd,yBAAyB;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG;IACjC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,qGAAqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,MAAM;gBAOtC,QAAQ,EAAE,cAAc,CAAC,iBAAiB,CAAC,EAC3C,OAAO,GAAE,mBAAwB;CAyBlC"}

package/dist/modules/target.js

@@ -0,0 +1,63 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { BufferTargetWriter, StreamTargetWriter } from './writer.js';
+/**
+ * Base class for targets, specifying where output files are written.
+ * @public
+ */
+export class Target {
+    constructor() {
+        /** @internal */
+        this._output = null;
+    }
+}
+/**
+ * A target that writes data directly into an ArrayBuffer in memory. Great for performance, but not suitable for very
+ * large files. The buffer will be available once the output has been finalized.
+ * @public
+ */
+export class BufferTarget extends Target {
+    constructor() {
+        super(...arguments);
+        /** Stores the final output buffer. Until the output is finalized, this will be null. */
+        this.buffer = null;
+    }
+    /** @internal */
+    _createWriter() {
+        return new BufferTargetWriter(this);
+    }
+}
+/**
+ * This target writes data to a WritableStream, making it a general-purpose target for writing data anywhere. It is
+ * also compatible with FileSystemWritableFileStream for use with the File System Access API. The WritableStream can
+ * also apply backpressure, which will propagate to the output and throttle the encoders.
+ * @public
+ */
+export class StreamTarget extends Target {
+    constructor(writable, options = {}) {
+        super();
+        if (!(writable instanceof WritableStream)) {
+            throw new TypeError('StreamTarget requires a WritableStream instance.');
+        }
+        if (options != null && typeof options !== 'object') {
+            throw new TypeError('StreamTarget options, when provided, must be an object.');
+        }
+        if (options.chunked !== undefined && typeof options.chunked !== 'boolean') {
+            throw new TypeError('options.chunked, when provided, must be a boolean.');
+        }
+        if (options.chunkSize !== undefined && (!Number.isInteger(options.chunkSize) || options.chunkSize < 1024)) {
+            throw new TypeError('options.chunkSize, when provided, must be an integer and not smaller than 1024.');
+        }
+        this._writable = writable;
+        this._options = options;
+    }
+    /** @internal */
+    _createWriter() {
+        return new StreamTargetWriter(this);
+    }
+}

package/dist/modules/wave/riff-reader.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { Reader } from '../reader';
+export declare class RiffReader {
+    reader: Reader;
+    pos: number;
+    littleEndian: boolean;
+    constructor(reader: Reader);
+    readBytes(length: number): Uint8Array<ArrayBufferLike>;
+    readU16(): number;
+    readU32(): number;
+    readAscii(length: number): string;
+}
+//# sourceMappingURL=riff-reader.d.ts.map

package/dist/modules/wave/riff-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"riff-reader.d.ts","sourceRoot":"","sources":["../../../src/wave/riff-reader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,qBAAa,UAAU;IAIH,MAAM,EAAE,MAAM;IAHjC,GAAG,SAAK;IACR,YAAY,UAAQ;gBAED,MAAM,EAAE,MAAM;IAEjC,SAAS,CAAC,MAAM,EAAE,MAAM;IAOxB,OAAO;IAOP,OAAO;IAOP,SAAS,CAAC,MAAM,EAAE,MAAM;CAUxB"}

package/dist/modules/wave/riff-reader.js

@@ -0,0 +1,38 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export class RiffReader {
+    constructor(reader) {
+        this.reader = reader;
+        this.pos = 0;
+        this.littleEndian = true;
+    }
+    readBytes(length) {
+        const { view, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
+        this.pos += length;
+        return new Uint8Array(view.buffer, offset, length);
+    }
+    readU16() {
+        const { view, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 2);
+        this.pos += 2;
+        return view.getUint16(offset, this.littleEndian);
+    }
+    readU32() {
+        const { view, offset } = this.reader.getViewAndOffset(this.pos, this.pos + 4);
+        this.pos += 4;
+        return view.getUint32(offset, this.littleEndian);
+    }
+    readAscii(length) {
+        const { view, offset } = this.reader.getViewAndOffset(this.pos, this.pos + length);
+        this.pos += length;
+        let str = '';
+        for (let i = 0; i < length; i++) {
+            str += String.fromCharCode(view.getUint8(offset + i));
+        }
+        return str;
+    }
+}

package/dist/modules/wave/riff-writer.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { Writer } from '../writer';
+export declare class RiffWriter {
+    private writer;
+    private helper;
+    private helperView;
+    constructor(writer: Writer);
+    writeU32(value: number): void;
+    writeU16(value: number): void;
+    writeAscii(text: string): void;
+}
+//# sourceMappingURL=riff-writer.d.ts.map

package/dist/modules/wave/riff-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"riff-writer.d.ts","sourceRoot":"","sources":["../../../src/wave/riff-writer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC,qBAAa,UAAU;IAIV,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,UAAU,CAAoC;gBAElC,MAAM,EAAE,MAAM;IAElC,QAAQ,CAAC,KAAK,EAAE,MAAM;IAKtB,QAAQ,CAAC,KAAK,EAAE,MAAM;IAKtB,UAAU,CAAC,IAAI,EAAE,MAAM;CAGvB"}

package/dist/modules/wave/riff-writer.js

@@ -0,0 +1,25 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+export class RiffWriter {
+    constructor(writer) {
+        this.writer = writer;
+        this.helper = new Uint8Array(8);
+        this.helperView = new DataView(this.helper.buffer);
+    }
+    writeU32(value) {
+        this.helperView.setUint32(0, value, true);
+        this.writer.write(this.helper.subarray(0, 4));
+    }
+    writeU16(value) {
+        this.helperView.setUint16(0, value, true);
+        this.writer.write(this.helper.subarray(0, 2));
+    }
+    writeAscii(text) {
+        this.writer.write(new TextEncoder().encode(text));
+    }
+}

package/dist/modules/wave/wave-demuxer.d.ts

@@ -0,0 +1,42 @@
+/*!
+ * Copyright (c) 2025-present, Vanilagy and contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { AudioCodec } from '../codec';
+import { Demuxer } from '../demuxer';
+import { Input } from '../input';
+import { InputAudioTrack } from '../input-track';
+import { RiffReader } from './riff-reader';
+export declare enum WaveFormat {
+    PCM = 1,
+    IEEE_FLOAT = 3,
+    ALAW = 6,
+    MULAW = 7,
+    EXTENSIBLE = 65534
+}
+export declare class WaveDemuxer extends Demuxer {
+    metadataReader: RiffReader;
+    chunkReader: RiffReader;
+    metadataPromise: Promise<void> | null;
+    dataStart: number;
+    dataSize: number;
+    audioInfo: {
+        format: number;
+        numberOfChannels: number;
+        sampleRate: number;
+        sampleSizeInBytes: number;
+        blockSizeInBytes: number;
+    } | null;
+    tracks: InputAudioTrack[];
+    constructor(input: Input);
+    readMetadata(): Promise<void>;
+    private parseFmtChunk;
+    getCodec(): AudioCodec | null;
+    getMimeType(): Promise<string>;
+    computeDuration(): Promise<number>;
+    getTracks(): Promise<InputAudioTrack[]>;
+}
+//# sourceMappingURL=wave-demuxer.d.ts.map