webcodecs-utils 0.2.4 → 0.2.6

package/dist/demux/example-muxer.js

@@ -0,0 +1,40 @@
+import { BufferTarget as i, Output as o, Mp4OutputFormat as r, EncodedVideoPacketSource as s, EncodedAudioPacketSource as a, EncodedPacket as u } from "mediabunny";
+class c {
+  /**
+   * Create a new ExampleMuxer.
+   *
+   * @param type - Track type: 'video' (default) or 'audio'
+   */
+  constructor(t) {
+    this.type = t || "video", this.target = new i();
+    const e = new o({
+      format: new r(),
+      target: this.target
+    });
+    this.started = !1, this.output = e, this.source = this.type === "video" ? new s("avc") : new a("aac"), this.output.addVideoTrack(this.source), console.warn(
+      "⚠️  Demo/Learning Function: This utility is intended for demos and learning purposes only. For production use, please use a proper muxing library like MediaBunny (https://mediabunny.dev/) "
+    );
+  }
+  /**
+   * Add an encoded chunk to the MP4 file.
+   *
+   * @param chunk - EncodedVideoChunk or EncodedAudioChunk from encoder output
+   * @param meta - Optional metadata from encoder (for video, contains decoderConfig)
+   */
+  addChunk(t, e) {
+    this.started || (this.output.start(), this.started = !0), this.source.add(u.fromEncodedChunk(t), e);
+  }
+  /**
+   * Finalize the MP4 file and return the complete buffer.
+   *
+   * Call this after all chunks have been added.
+   *
+   * @returns Complete MP4 file as ArrayBuffer
+   */
+  async finish() {
+    return await this.output.finalize(), this.target.buffer;
+  }
+}
+export {
+  c as ExampleMuxer
+};

package/dist/demux/get-chunks.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Extract all video chunks from a media file.
+ *
+ * **⚠️ Demo/Learning Only**: For production use, use MediaBunny or web-demuxer directly.
+ *
+ * @param file - Media file to demux
+ * @returns Array of EncodedVideoChunk objects
+ *
+ * @example
+ * ```typescript
+ * const chunks = await getVideoChunks(file);
+ * // Returns all video chunks from the file
+ * ```
+ */
+export declare function getVideoChunks(file: File): Promise<EncodedVideoChunk[]>;
+/**
+ * Extract all audio chunks and decoder config from a media file.
+ *
+ * **⚠️ Demo/Learning Only**: For production use, use MediaBunny or web-demuxer directly.
+ *
+ * @param file - Media file to demux
+ * @returns Object containing chunks array and AudioDecoderConfig
+ *
+ * @example
+ * ```typescript
+ * const { chunks, config } = await demuxAudio(file);
+ *
+ * // Configure decoder
+ * decoder.configure(config);
+ *
+ * // Decode all chunks
+ * for (const chunk of chunks) {
+ *   decoder.decode(chunk);
+ * }
+ * ```
+ */
+export declare function demuxAudio(file: File): Promise<{
+    chunks: EncodedAudioChunk[];
+    config: AudioDecoderConfig;
+}>;
+/**
+ * Extract all video chunks and decoder config from a media file.
+ *
+ * **⚠️ Demo/Learning Only**: For production use, use MediaBunny or web-demuxer directly.
+ *
+ * @param file - Media file to demux
+ * @returns Object containing chunks array and VideoDecoderConfig
+ *
+ * @example
+ * ```typescript
+ * const { chunks, config } = await demuxVideo(file);
+ *
+ * // Configure decoder
+ * decoder.configure(config);
+ *
+ * // Decode all chunks
+ * for (const chunk of chunks) {
+ *   decoder.decode(chunk);
+ * }
+ * ```
+ */
+export declare function demuxVideo(file: File): Promise<{
+    chunks: EncodedVideoChunk[];
+    config: VideoDecoderConfig;
+}>;
+/**
+ * Extract all audio chunks from a media file.
+ *
+ * **⚠️ Demo/Learning Only**: For production use, use MediaBunny or web-demuxer directly.
+ *
+ * @param file - Media file to demux
+ * @returns Array of EncodedAudioChunk objects
+ *
+ * @example
+ * ```typescript
+ * const chunks = await getAudioChunks(file);
+ * // Returns all audio chunks from the file
+ * ```
+ */
+export declare function getAudioChunks(file: File): Promise<EncodedAudioChunk[]>;
+//# sourceMappingURL=get-chunks.d.ts.map

package/dist/demux/get-chunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-chunks.d.ts","sourceRoot":"","sources":["../../src/demux/get-chunks.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAyB7E;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;IAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAAC,MAAM,EAAE,kBAAkB,CAAA;CAAC,CAAC,CAwC/G;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;IAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAAC,MAAM,EAAE,kBAAkB,CAAA;CAAC,CAAC,CAyC/G;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAyB7E"}

package/dist/demux/get-chunks.js

@@ -0,0 +1,88 @@
+import { WebDemuxer as u } from "web-demuxer";
+let f = !1;
+function m() {
+  f || (console.warn(
+    "⚠️  Demo/Learning Function: This utility is intended for demos and learning purposes only. For production use, please use a proper demuxing library like MediaBunny (https://mediabunny.dev/) or web-demuxer (https://github.com/bilibili/web-demuxer) directly."
+  ), f = !0);
+}
+async function p(i) {
+  m();
+  const e = new u({
+    wasmFilePath: "https://cdn.jsdelivr.net/npm/web-demuxer@latest/dist/wasm-files/web-demuxer.wasm"
+  });
+  await e.load(i);
+  const a = e.read("video", 0).getReader(), n = [];
+  return new Promise(function(d) {
+    a.read().then(async function t(o) {
+      const { done: s, value: r } = o;
+      return r && n.push(r), s ? d(n) : a.read().then(t);
+    });
+  });
+}
+async function g(i) {
+  m();
+  const e = new u({
+    wasmFilePath: "https://cdn.jsdelivr.net/npm/web-demuxer@latest/dist/wasm-files/web-demuxer.wasm"
+  });
+  await e.load(i);
+  const a = e.read("audio", 0).getReader(), n = [];
+  await new Promise(function(s) {
+    a.read().then(async function r(w) {
+      const { done: l, value: c } = w;
+      return c && n.push(c), l ? s(n) : a.read().then(r);
+    });
+  });
+  const t = (await e.getMediaInfo()).streams.filter((s) => s.codec_type_string === "audio")[0], o = {
+    codec: t.codec_string,
+    sampleRate: t.sample_rate,
+    numberOfChannels: t.channels
+  };
+  return {
+    chunks: n,
+    config: o
+  };
+}
+async function x(i) {
+  m();
+  const e = new u({
+    wasmFilePath: "https://cdn.jsdelivr.net/npm/web-demuxer@latest/dist/wasm-files/web-demuxer.wasm"
+  });
+  await e.load(i);
+  const a = e.read("video", 0).getReader(), n = [];
+  await new Promise(function(s) {
+    a.read().then(async function r(w) {
+      const { done: l, value: c } = w;
+      return c && n.push(c), l ? s(n) : a.read().then(r);
+    });
+  });
+  const t = (await e.getMediaInfo()).streams.filter((s) => s.codec_type_string === "video")[0], o = {
+    codec: t.codec_string,
+    codedWidth: t.width,
+    codedHeight: t.height,
+    description: t.extradata
+  };
+  return {
+    chunks: n,
+    config: o
+  };
+}
+async function b(i) {
+  m();
+  const e = new u({
+    wasmFilePath: "https://cdn.jsdelivr.net/npm/web-demuxer@latest/dist/wasm-files/web-demuxer.wasm"
+  });
+  await e.load(i);
+  const a = e.read("audio", 0).getReader(), n = [];
+  return new Promise(function(d) {
+    a.read().then(async function t(o) {
+      const { done: s, value: r } = o;
+      return r && n.push(r), s ? d(n) : a.read().then(t);
+    });
+  });
+}
+export {
+  g as demuxAudio,
+  x as demuxVideo,
+  b as getAudioChunks,
+  p as getVideoChunks
+};

package/dist/demux/mp4-demuxer.d.ts

@@ -0,0 +1,84 @@
+import { MP4Info } from 'mp4box';
+type MP4Info = any;
+export interface AudioTrackData {
+    codec: string;
+    sampleRate: number;
+    numberOfChannels: number;
+}
+export interface VideoTrackData {
+    codec: string;
+    codedHeight: number;
+    codedWidth: number;
+    description: Uint8Array;
+    frameRate: number;
+}
+export interface TrackData {
+    duration: number;
+    audio?: AudioTrackData;
+    video?: VideoTrackData;
+}
+/**
+ * MP4 demuxer for extracting video/audio chunks from MP4 files.
+ * Wraps MP4Box.js with a simpler API and built-in caching.
+ *
+ * @example
+ * ```typescript
+ * const demuxer = new MP4Demuxer(file);
+ * await demuxer.load();
+ *
+ * const tracks = demuxer.getTracks();
+ * const videoChunks = await demuxer.extractSegment('video', 0, 10);
+ * ```
+ */
+export declare class MP4Demuxer {
+    private file;
+    private mp4Data;
+    /**
+     * Create a new MP4Demuxer instance.
+     * @param file - The MP4 file to demux
+     * @param options - Optional configuration
+     */
+    constructor(file: File);
+    /**
+     * Load and parse the MP4 file metadata.
+     * Must be called before extracting segments.
+     */
+    load(onProgress?: (progress: number) => void): Promise<void>;
+    /**
+     * Get track information from the loaded MP4 file.
+     * @returns Track data including duration, codec info, etc.
+     * @throws Error if load() hasn't been called yet
+     */
+    getTracks(): TrackData;
+    getVideoDecoderConfig(): VideoDecoderConfig | undefined;
+    getAudioDecoderConfig(): AudioDecoderConfig | undefined;
+    /**
+     * Get video track information.
+     * @returns Video track data or undefined if no video track
+     * @throws Error if load() hasn't been called yet
+     */
+    getVideoTrack(): VideoTrackData | undefined;
+    /**
+     * Get audio track information.
+     * @returns Audio track data or undefined if no audio track
+     * @throws Error if load() hasn't been called yet
+     */
+    getAudioTrack(): AudioTrackData | undefined;
+    /**
+     * Extract encoded chunks from a specific time range.
+     * @param trackType - "audio" or "video"
+     * @param startTime - Start time in seconds
+     * @param endTime - End time in seconds
+     * @returns Array of EncodedVideoChunk or EncodedAudioChunk
+     * @throws Error if load() hasn't been called yet
+     */
+    extractSegment(trackType: "audio" | "video", startTime: number, endTime: number): Promise<EncodedVideoChunk[] | EncodedAudioChunk[]>;
+    /**
+     * Get the full MP4 info object from MP4Box.
+     * @returns MP4Info object with detailed track information
+     * @throws Error if load() hasn't been called yet
+     */
+    getInfo(): MP4Info;
+}
+export {};
+//# sourceMappingURL=mp4-demuxer.d.ts.map

package/dist/demux/mp4-demuxer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mp4-demuxer.d.ts","sourceRoot":"","sources":["../../src/demux/mp4-demuxer.ts"],"names":[],"mappings":"AACA,OAAe,EAAU,OAAO,EAAiE,MAAM,QAAQ,CAAA;AAK/G,KAAK,OAAO,GAAG,GAAG,CAAC;AAMnB,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,UAAU,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,KAAK,CAAC,EAAE,cAAc,CAAC;CACxB;AAqSD;;;;;;;;;;;;GAYG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,IAAI,CAAO;IACnB,OAAO,CAAC,OAAO,CAAwB;IAEvC;;;;OAIG;gBACS,IAAI,EAAE,IAAI;IAItB;;;OAGG;IACG,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlE;;;;OAIG;IACH,SAAS,IAAI,SAAS;IAStB,qBAAqB,IAAI,kBAAkB,GAAG,SAAS;IAIvD,qBAAqB,IAAI,kBAAkB,GAAG,SAAS;IAMvD;;;;OAIG;IACH,aAAa,IAAI,cAAc,GAAG,SAAS;IAI3C;;;;OAIG;IACH,aAAa,IAAI,cAAc,GAAG,SAAS;IAI3C;;;;;;;OAOG;IACG,cAAc,CAClB,SAAS,EAAE,OAAO,GAAG,OAAO,EAC5B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,iBAAiB,EAAE,GAAG,iBAAiB,EAAE,CAAC;IAOrD;;;;OAIG;IACH,OAAO,IAAI,OAAO;CAMnB"}

package/dist/demux/mp4-demuxer.js

@@ -0,0 +1,215 @@
+import M, { DataStream as x } from "mp4box";
+const S = 100, y = 0.5, R = 0.1;
+function I(s, e) {
+  const o = s.getTrackById(e.id);
+  for (const r of o.mdia.minf.stbl.stsd.entries) {
+    const c = r.avcC || r.hvcC || r.vpcC || r.av1C;
+    if (c) {
+      const t = new x(void 0, 0, x.BIG_ENDIAN);
+      return c.write(t), new Uint8Array(t.buffer, 8);
+    }
+  }
+  throw new Error(
+    "Codec description box (avcC, hvcC, vpcC, or av1C) not found"
+  );
+}
+function _(s, e) {
+  var r, c;
+  const o = {
+    duration: e.duration / e.timescale
+  };
+  if (e.videoTracks.length > 0) {
+    const t = e.videoTracks[0], a = t.samples_duration / t.timescale;
+    o.video = {
+      codec: t.codec,
+      codedHeight: t.video.height,
+      codedWidth: t.video.width,
+      description: I(s, t),
+      frameRate: t.nb_samples / a
+    };
+  }
+  if (e.audioTracks.length > 0) {
+    const t = e.audioTracks[0], a = ((r = t.audio) == null ? void 0 : r.sample_rate) ?? t.timescale, d = ((c = t.audio) == null ? void 0 : c.channel_count) ?? 2;
+    o.audio = {
+      codec: t.codec,
+      sampleRate: a,
+      numberOfChannels: d
+    };
+  }
+  return o;
+}
+function P(s, e) {
+  return new Promise((o, r) => {
+    const c = s.stream().getReader();
+    let t = 0;
+    const a = M.createFile(!1);
+    let d = !1;
+    a.onReady = (n) => {
+      d = !0;
+      const u = _(a, n);
+      o({ info: n, trackData: u, mp4: a });
+    }, a.onError = (n) => {
+      r(
+        new Error(
+          `MP4Box parsing error: ${n instanceof Error ? n.message : String(n)}`
+        )
+      );
+    };
+    const h = async () => {
+      try {
+        const { done: n, value: u } = await c.read();
+        if (n) {
+          if (!d)
+            throw new Error("Invalid MP4 file: metadata not available");
+          a.flush();
+          return;
+        }
+        if (d) {
+          c.releaseLock(), a.flush();
+          return;
+        }
+        const m = u.buffer;
+        if (m.fileStart = t, t += u.length, e && e(t / s.size), a.appendBuffer(m), t < s.size)
+          return h();
+        if (a.flush(), !d)
+          throw new Error("Invalid MP4 file: metadata not available");
+      } catch (n) {
+        r(n);
+      }
+    };
+    h().catch(r);
+  });
+}
+function A(s, e, o, r, c) {
+  const { mp4: t, info: a } = e;
+  return new Promise((d, h) => {
+    let n = 0, u = !1, m = 0;
+    const b = o === "audio" ? EncodedAudioChunk : EncodedVideoChunk, k = [], D = o === "audio" ? a.audioTracks[0] ?? null : a.videoTracks[0] ?? null;
+    if (!D) {
+      d([]);
+      return;
+    }
+    m = D.id;
+    const w = a.duration / a.timescale - R, E = Math.min(c || w, w);
+    for (const i in a.tracks) {
+      const p = a.tracks[i];
+      t.unsetExtractionOptions(p.id);
+    }
+    t.onSamples = (i, p, l) => {
+      for (const f of l) {
+        const g = f.cts / f.timescale;
+        g < E && k.push(
+          new b({
+            type: f.is_sync ? "key" : "delta",
+            timestamp: Math.round(1e6 * g),
+            duration: Math.round(
+              1e6 * (f.duration / f.timescale)
+            ),
+            data: f.data
+          })
+        );
+      }
+      if (l.length > 0 && t.releaseUsedSamples(m, l[l.length - 1].number), k.length > 0) {
+        const g = k[k.length - 1].timestamp / 1e6;
+        (Math.abs(g - E) < y || g > E) && (u = !0, t.stop(), t.flush(), d(k));
+      }
+    }, t.onError = (i) => {
+      h(
+        new Error(
+          `Extraction error: ${i instanceof Error ? i.message : String(i)}`
+        )
+      );
+    }, t.setExtractionOptions(m, null, { nbSamples: S });
+    const T = t.seek(r, !0), v = s.slice(T.offset).stream().getReader();
+    n = T.offset;
+    const C = async () => {
+      try {
+        const { done: i, value: p } = await v.read();
+        if (i || u) {
+          v.releaseLock(), t.flush();
+          return;
+        }
+        const l = p.buffer;
+        return l.fileStart = n, n += p.length, t.appendBuffer(l), C();
+      } catch (i) {
+        h(i);
+      }
+    };
+    t.start(), C().catch(h);
+  });
+}
+class N {
+  /**
+   * Create a new MP4Demuxer instance.
+   * @param file - The MP4 file to demux
+   * @param options - Optional configuration
+   */
+  constructor(e) {
+    this.mp4Data = null, this.file = e;
+  }
+  /**
+   * Load and parse the MP4 file metadata.
+   * Must be called before extracting segments.
+   */
+  async load(e) {
+    this.mp4Data = await P(this.file, e);
+  }
+  /**
+   * Get track information from the loaded MP4 file.
+   * @returns Track data including duration, codec info, etc.
+   * @throws Error if load() hasn't been called yet
+   */
+  getTracks() {
+    if (!this.mp4Data)
+      throw new Error("MP4Demuxer: Must call load() before getTracks()");
+    return this.mp4Data.trackData;
+  }
+  getVideoDecoderConfig() {
+    return this.getVideoTrack();
+  }
+  getAudioDecoderConfig() {
+    return this.getAudioTrack();
+  }
+  /**
+   * Get video track information.
+   * @returns Video track data or undefined if no video track
+   * @throws Error if load() hasn't been called yet
+   */
+  getVideoTrack() {
+    return this.getTracks().video;
+  }
+  /**
+   * Get audio track information.
+   * @returns Audio track data or undefined if no audio track
+   * @throws Error if load() hasn't been called yet
+   */
+  getAudioTrack() {
+    return this.getTracks().audio;
+  }
+  /**
+   * Extract encoded chunks from a specific time range.
+   * @param trackType - "audio" or "video"
+   * @param startTime - Start time in seconds
+   * @param endTime - End time in seconds
+   * @returns Array of EncodedVideoChunk or EncodedAudioChunk
+   * @throws Error if load() hasn't been called yet
+   */
+  async extractSegment(e, o, r) {
+    if (!this.mp4Data)
+      throw new Error("MP4Demuxer: Must call load() before extractSegment()");
+    return A(this.file, this.mp4Data, e, o, r);
+  }
+  /**
+   * Get the full MP4 info object from MP4Box.
+   * @returns MP4Info object with detailed track information
+   * @throws Error if load() hasn't been called yet
+   */
+  getInfo() {
+    if (!this.mp4Data)
+      throw new Error("MP4Demuxer: Must call load() before getInfo()");
+    return this.mp4Data.info;
+  }
+}
+export {
+  N as MP4Demuxer
+};

package/dist/demux/simple-demuxer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Simple wrapper around web-demuxer for easier usage
+ * Provides streaming and batch access to encoded chunks
+ *
+ * **⚠️ Demo/Learning Only**: For production use, use web-demuxer or MediaBunny directly.
+ */
+export declare class SimpleDemuxer {
+    private demuxer;
+    private file;
+    private loaded;
+    constructor(file: File, options?: {
+        wasmFilePath?: string;
+    });
+    /**
+     * Load and parse the media file
+     */
+    load(): Promise<void>;
+    /**
+     * Get a ReadableStream of video chunks from start time (default: 0)
+     * @param startTime Start time in seconds (default: 0)
+     */
+    videoStream(startTime?: number): ReadableStream<EncodedVideoChunk>;
+    /**
+     * Get a ReadableStream of audio chunks from start time (default: 0)
+     * @param startTime Start time in seconds (default: 0)
+     */
+    audioStream(startTime?: number): ReadableStream<EncodedAudioChunk>;
+    /**
+     * Get video decoder configuration
+     */
+    getVideoDecoderConfig(): Promise<VideoDecoderConfig>;
+    /**
+     * Get audio decoder configuration
+     */
+    getAudioDecoderConfig(): Promise<AudioDecoderConfig>;
+    /**
+     * Get a segment of encoded chunks as an array
+     * @param type Track type ('video' or 'audio')
+     * @param start Start time in seconds
+     * @param end End time in seconds
+     * @returns Array of encoded chunks
+     */
+    getSegment(type: 'video' | 'audio', start: number, end: number): Promise<EncodedVideoChunk[] | EncodedAudioChunk[]>;
+    /**
+     * Get media information (tracks, duration, etc.)
+     */
+    getMediaInfo(): Promise<import("web-demuxer").WebMediaInfo>;
+}
+//# sourceMappingURL=simple-demuxer.d.ts.map

package/dist/demux/simple-demuxer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-demuxer.d.ts","sourceRoot":"","sources":["../../src/demux/simple-demuxer.ts"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,IAAI,CAAO;IACnB,OAAO,CAAC,MAAM,CAAS;gBAEX,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE;IAS3D;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B;;;OAGG;IACH,WAAW,CAAC,SAAS,GAAE,MAAU,GAAG,cAAc,CAAC,iBAAiB,CAAC;IAOrE;;;OAGG;IACH,WAAW,CAAC,SAAS,GAAE,MAAU,GAAG,cAAc,CAAC,iBAAiB,CAAC;IAOrE;;OAEG;IACG,qBAAqB,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAO1D;;OAEG;IACG,qBAAqB,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAO1D;;;;;;OAMG;IACG,UAAU,CACd,IAAI,EAAE,OAAO,GAAG,OAAO,EACvB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,iBAAiB,EAAE,GAAG,iBAAiB,EAAE,CAAC;IAsBrD;;OAEG;IACG,YAAY;CAMnB"}

package/dist/demux/simple-demuxer.js

@@ -0,0 +1,87 @@
+import { WebDemuxer as l } from "web-demuxer";
+let a = !1;
+function u() {
+  a || (console.warn(
+    "⚠️  Demo/Learning Function: SimpleDemuxer is intended for demos and learning purposes only. For production use, please use web-demuxer directly (https://github.com/bilibili/web-demuxer) or MediaBunny (https://mediabunny.dev/) for more features."
+  ), a = !0);
+}
+class h {
+  constructor(e, r) {
+    this.loaded = !1, u(), this.file = e, this.demuxer = new l({
+      wasmFilePath: (r == null ? void 0 : r.wasmFilePath) || "https://cdn.jsdelivr.net/npm/web-demuxer@latest/dist/wasm-files/web-demuxer.wasm"
+    });
+  }
+  /**
+   * Load and parse the media file
+   */
+  async load() {
+    await this.demuxer.load(this.file), this.loaded = !0;
+  }
+  /**
+   * Get a ReadableStream of video chunks from start time (default: 0)
+   * @param startTime Start time in seconds (default: 0)
+   */
+  videoStream(e = 0) {
+    if (!this.loaded)
+      throw new Error("SimpleDemuxer: Must call load() before accessing streams");
+    return this.demuxer.read("video", e);
+  }
+  /**
+   * Get a ReadableStream of audio chunks from start time (default: 0)
+   * @param startTime Start time in seconds (default: 0)
+   */
+  audioStream(e = 0) {
+    if (!this.loaded)
+      throw new Error("SimpleDemuxer: Must call load() before accessing streams");
+    return this.demuxer.read("audio", e);
+  }
+  /**
+   * Get video decoder configuration
+   */
+  async getVideoDecoderConfig() {
+    if (!this.loaded)
+      throw new Error("SimpleDemuxer: Must call load() before getting config");
+    return await this.demuxer.getDecoderConfig("video");
+  }
+  /**
+   * Get audio decoder configuration
+   */
+  async getAudioDecoderConfig() {
+    if (!this.loaded)
+      throw new Error("SimpleDemuxer: Must call load() before getting config");
+    return await this.demuxer.getDecoderConfig("audio");
+  }
+  /**
+   * Get a segment of encoded chunks as an array
+   * @param type Track type ('video' or 'audio')
+   * @param start Start time in seconds
+   * @param end End time in seconds
+   * @returns Array of encoded chunks
+   */
+  async getSegment(e, r, o) {
+    if (!this.loaded)
+      throw new Error("SimpleDemuxer: Must call load() before getting segments");
+    const d = this.demuxer.read(e, r, o), t = [], i = d.getReader();
+    try {
+      for (; ; ) {
+        const { done: s, value: n } = await i.read();
+        if (s) break;
+        t.push(n);
+      }
+    } finally {
+      i.releaseLock();
+    }
+    return t;
+  }
+  /**
+   * Get media information (tracks, duration, etc.)
+   */
+  async getMediaInfo() {
+    if (!this.loaded)
+      throw new Error("SimpleDemuxer: Must call load() before getting media info");
+    return await this.demuxer.getMediaInfo();
+  }
+}
+export {
+  h as SimpleDemuxer
+};

package/dist/in-memory-storage.d.ts

@@ -0,0 +1,30 @@
+/**
+ * In-memory storage system that stores data in fixed-size chunks
+ * and efficiently handles overlapping writes.
+ */
+export declare class InMemoryStorage {
+    private chunks;
+    private _chunkSize;
+    private _size;
+    /**
+     * Create a new InMemoryStorage instance
+     * @param chunkSize Size of each chunk in bytes (default: 10MB)
+     */
+    constructor(chunkSize?: number);
+    /**
+     * Write data to storage, handling overlaps efficiently
+     * @param data Data to write
+     * @param position Position to write at
+     */
+    write(data: Uint8Array, position: number): void;
+    /**
+     * Get the total size of data written
+     */
+    get size(): number;
+    /**
+     * Convert all stored chunks to a single Blob
+     * @param type MIME type for the Blob
+     */
+    toBlob(type?: string): Blob;
+}
+//# sourceMappingURL=in-memory-storage.d.ts.map

package/dist/in-memory-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-storage.d.ts","sourceRoot":"","sources":["../src/in-memory-storage.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,eAAe;IACxB,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,KAAK,CAAK;IAElB;;;OAGG;gBACS,SAAS,GAAE,MAAyB;IAIhD;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IA2C/C;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;OAGG;IACH,MAAM,CAAC,IAAI,GAAE,MAAmC,GAAG,IAAI;CAgC1D"}