@remotion/media-parser 4.0.265 → 4.0.267

package/dist/containers/transport-stream/parse-stream-packet.js

@@ -6,34 +6,32 @@ const adts_header_1 = require("./adts-header");
 const discard_rest_of_packet_1 = require("./discard-rest-of-packet");
 const find_separator_1 = require("./find-separator");
 const process_stream_buffers_1 = require("./process-stream-buffers");
-const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, state, structure, offset, }) => {
+const parseAdtsStream = async ({ transportStreamEntry, state, structure, offset, }) => {
     var _a, _b;
     const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
-    const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-    if (!streamBuffer) {
-        streamBuffers.set(transportStreamEntry.pid, {
-            buffer: restOfPacket,
-            pesHeader: nextPesHeader.getNextPesHeader(),
-            offset,
-        });
-        return;
-    }
-    const expectedLength = (_b = (_a = (0, adts_header_1.readAdtsHeader)(streamBuffer.buffer)) === null || _a === void 0 ? void 0 : _a.frameLength) !== null && _b !== void 0 ? _b : null;
-    const bytesToTake = expectedLength
-        ? Math.min(restOfPacket.length, expectedLength - streamBuffer.buffer.byteLength)
-        : restOfPacket.length;
-    streamBuffer.buffer = (0, combine_uint8_arrays_1.combineUint8Arrays)([
-        streamBuffer.buffer,
-        restOfPacket.slice(0, bytesToTake),
-    ]);
-    if (expectedLength === streamBuffer.buffer.byteLength) {
+    while (true) {
+        const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+        if (!streamBuffer) {
+            throw new Error('Stream buffer not found');
+        }
+        const expectedLength = (_b = (_a = (0, adts_header_1.readAdtsHeader)(streamBuffer.buffer)) === null || _a === void 0 ? void 0 : _a.frameLength) !== null && _b !== void 0 ? _b : null;
+        if (expectedLength === null) {
+            break;
+        }
+        if (expectedLength > streamBuffer.buffer.length) {
+            break;
+        }
         await (0, process_stream_buffers_1.processStreamBuffer)({
-            streamBuffer,
+            streamBuffer: {
+                buffer: streamBuffer.buffer.slice(0, expectedLength),
+                offset,
+                pesHeader: streamBuffer.pesHeader,
+            },
             programId: transportStreamEntry.pid,
             state,
             structure,
         });
-        const rest = restOfPacket.slice(bytesToTake);
+        const rest = streamBuffer.buffer.slice(expectedLength);
         streamBuffers.set(transportStreamEntry.pid, {
             buffer: rest,
             pesHeader: nextPesHeader.getNextPesHeader(),
@@ -41,71 +39,85 @@ const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, state, stru
         });
     }
 };
-const parseAvcStream = async ({ restOfPacket, transportStreamEntry, programId, state, structure, offset, }) => {
-    const indexOfSeparator = (0, find_separator_1.findNextSeparator)(restOfPacket, transportStreamEntry);
-    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
-    const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-    if (indexOfSeparator === -1) {
-        if (streamBuffer) {
+const parseAvcStream = async ({ programId, state, structure, streamBuffer, }) => {
+    const indexOfSeparator = (0, find_separator_1.findNthSubarrayIndex)(streamBuffer.buffer, new Uint8Array([0, 0, 1, 9]), 2);
+    if (indexOfSeparator === -1 || indexOfSeparator === 0) {
+        return null;
+    }
+    const packet = streamBuffer.buffer.slice(0, indexOfSeparator);
+    const rest = streamBuffer.buffer.slice(indexOfSeparator);
+    await (0, process_stream_buffers_1.processStreamBuffer)({
+        state,
+        streamBuffer: {
+            offset: streamBuffer.offset,
+            pesHeader: streamBuffer.pesHeader,
+            // Replace the regular 0x00000001 with 0x00000002 to avoid confusion with other 0x00000001 (?)
+            buffer: packet,
+        },
+        programId,
+        structure,
+    });
+    return rest;
+};
+const parseStream = async ({ transportStreamEntry, state, programId, structure, }) => {
+    const { iterator } = state;
+    let restOfPacket = (0, discard_rest_of_packet_1.getRestOfPacket)(iterator);
+    const offset = iterator.counter.getOffset();
+    if (transportStreamEntry.streamType === 27) {
+        const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
+        while (true) {
+            if (!streamBuffers.has(transportStreamEntry.pid)) {
+                streamBuffers.set(programId, {
+                    pesHeader: nextPesHeader.getNextPesHeader(),
+                    buffer: new Uint8Array([]),
+                    offset,
+                });
+            }
+            const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
             streamBuffer.buffer = (0, combine_uint8_arrays_1.combineUint8Arrays)([
                 streamBuffer.buffer,
                 restOfPacket,
             ]);
-            return;
+            const rest = await parseAvcStream({
+                state,
+                programId,
+                structure,
+                streamBuffer: streamBuffers.get(transportStreamEntry.pid),
+            });
+            if (rest !== null) {
+                streamBuffers.delete(transportStreamEntry.pid);
+                if (rest.length === 0) {
+                    break;
+                }
+                restOfPacket = rest;
+            }
+            else {
+                break;
+            }
         }
-        streamBuffers.set(programId, {
-            pesHeader: nextPesHeader.getNextPesHeader(),
-            buffer: restOfPacket,
-            offset,
-        });
         return;
     }
-    if (streamBuffer) {
-        const packet = restOfPacket.slice(0, indexOfSeparator);
-        streamBuffer.buffer = (0, combine_uint8_arrays_1.combineUint8Arrays)([streamBuffer.buffer, packet]);
-        await (0, process_stream_buffers_1.processStreamBuffer)({
-            state,
-            streamBuffer,
-            programId,
-            structure,
-        });
-        const rest = restOfPacket.slice(indexOfSeparator);
-        streamBuffers.set(programId, {
-            pesHeader: nextPesHeader.getNextPesHeader(),
-            buffer: rest,
-            offset,
-        });
-        return;
-    }
-    if (indexOfSeparator !== 0) {
-        throw new Error('No stream buffer found but new separator is not at the beginning');
-    }
-    streamBuffers.set(programId, {
-        pesHeader: nextPesHeader.getNextPesHeader(),
-        buffer: restOfPacket.slice(indexOfSeparator),
-        offset,
-    });
-};
-const parseStream = ({ transportStreamEntry, state, programId, structure, }) => {
-    const { iterator } = state;
-    const restOfPacket = (0, discard_rest_of_packet_1.getRestOfPacket)(iterator);
-    if (transportStreamEntry.streamType === 27) {
-        return parseAvcStream({
-            restOfPacket,
-            transportStreamEntry,
-            state,
-            programId,
-            structure,
-            offset: iterator.counter.getOffset(),
-        });
-    }
     if (transportStreamEntry.streamType === 15) {
+        const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
+        const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+        if (!streamBuffer) {
+            streamBuffers.set(transportStreamEntry.pid, {
+                buffer: restOfPacket,
+                pesHeader: nextPesHeader.getNextPesHeader(),
+                offset,
+            });
+        }
+        else {
+            streamBuffer.buffer = (0, combine_uint8_arrays_1.combineUint8Arrays)([
+                streamBuffer.buffer,
+                restOfPacket,
+            ]);
+        }
         return parseAdtsStream({
-            restOfPacket,
             transportStreamEntry,
             state,
             structure,
-            offset: iterator.counter.getOffset(),
+            offset,
         });
     }
     throw new Error(`Unsupported stream type ${transportStreamEntry.streamType}`);

package/dist/containers/wav/parse-fmt.js

@@ -34,7 +34,7 @@ const parseFmt = async ({ state, }) => {
         type: 'wav-fmt',
     };
     state.getWavStructure().boxes.push(wavHeader);
-    await (0, register_track_1.registerTrack)({
+    await (0, register_track_1.registerAudioTrack)({
         state,
         track: {
             type: 'audio',

package/dist/containers/webm/parse-ebml.js

@@ -119,8 +119,15 @@ const postprocessEbml = async ({ offset, ebml, state, }) => {
             track: ebml,
             timescale: state.webm.getTimescale(),
         });
-        if (track) {
-            await (0, register_track_1.registerTrack)({
+        if (track && track.type === 'audio') {
+            await (0, register_track_1.registerAudioTrack)({
+                state,
+                track,
+                container: 'webm',
+            });
+        }
+        if (track && track.type === 'video') {
+            await (0, register_track_1.registerVideoTrack)({
                 state,
                 track,
                 container: 'webm',

package/dist/download-and-parse-media.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadAndParseMedia = void 0;
+const select_stream_1 = require("./containers/m3u/select-stream");
 const internal_parse_media_1 = require("./internal-parse-media");
 const log_1 = require("./log");
 const from_fetch_1 = require("./readers/from-fetch");
 const downloadAndParseMedia = async (options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10;
     const logLevel = (_a = options.logLevel) !== null && _a !== void 0 ? _a : 'info';
     const content = await options.writer.createContent({
         filename: 'hmm',
@@ -20,38 +21,40 @@ const downloadAndParseMedia = async (options) => {
         onAudioTrack: null,
         onContainer: (_d = options.onContainer) !== null && _d !== void 0 ? _d : null,
         onDimensions: (_e = options.onDimensions) !== null && _e !== void 0 ? _e : null,
+        selectM3uStream: (_f = options.selectM3uStream) !== null && _f !== void 0 ? _f : select_stream_1.defaultSelectM3uStreamFn,
         onDiscardedData: async (data) => {
             await content.write(data);
         },
-        onDurationInSeconds: (_f = options.onDurationInSeconds) !== null && _f !== void 0 ? _f : null,
-        onFps: (_g = options.onFps) !== null && _g !== void 0 ? _g : null,
-        onImages: (_h = options.onImages) !== null && _h !== void 0 ? _h : null,
-        onInternalStats: (_j = options.onInternalStats) !== null && _j !== void 0 ? _j : null,
-        onIsHdr: (_k = options.onIsHdr) !== null && _k !== void 0 ? _k : null,
-        onKeyframes: (_l = options.onKeyframes) !== null && _l !== void 0 ? _l : null,
-        onLocation: (_m = options.onLocation) !== null && _m !== void 0 ? _m : null,
-        onMetadata: (_o = options.onMetadata) !== null && _o !== void 0 ? _o : null,
-        onMimeType: (_p = options.onMimeType) !== null && _p !== void 0 ? _p : null,
-        onName: (_q = options.onName) !== null && _q !== void 0 ? _q : null,
-        onNumberOfAudioChannels: (_r = options.onNumberOfAudioChannels) !== null && _r !== void 0 ? _r : null,
-        onParseProgress: (_s = options.onParseProgress) !== null && _s !== void 0 ? _s : null,
-        onRotation: (_t = options.onRotation) !== null && _t !== void 0 ? _t : null,
-        onSampleRate: (_u = options.onSampleRate) !== null && _u !== void 0 ? _u : null,
-        onSize: (_v = options.onSize) !== null && _v !== void 0 ? _v : null,
-        onSlowAudioBitrate: (_w = options.onSlowAudioBitrate) !== null && _w !== void 0 ? _w : null,
-        onSlowDurationInSeconds: (_x = options.onSlowDurationInSeconds) !== null && _x !== void 0 ? _x : null,
-        onSlowFps: (_y = options.onSlowFps) !== null && _y !== void 0 ? _y : null,
-        onSlowKeyframes: (_z = options.onSlowKeyframes) !== null && _z !== void 0 ? _z : null,
-        onSlowNumberOfFrames: (_0 = options.onSlowNumberOfFrames) !== null && _0 !== void 0 ? _0 : null,
-        onSlowVideoBitrate: (_1 = options.onSlowVideoBitrate) !== null && _1 !== void 0 ? _1 : null,
-        onStructure: (_2 = options.onStructure) !== null && _2 !== void 0 ? _2 : null,
-        onTracks: (_3 = options.onTracks) !== null && _3 !== void 0 ? _3 : null,
-        onUnrotatedDimensions: (_4 = options.onUnrotatedDimensions) !== null && _4 !== void 0 ? _4 : null,
-        onVideoCodec: (_5 = options.onVideoCodec) !== null && _5 !== void 0 ? _5 : null,
+        onDurationInSeconds: (_g = options.onDurationInSeconds) !== null && _g !== void 0 ? _g : null,
+        onFps: (_h = options.onFps) !== null && _h !== void 0 ? _h : null,
+        onImages: (_j = options.onImages) !== null && _j !== void 0 ? _j : null,
+        onInternalStats: (_k = options.onInternalStats) !== null && _k !== void 0 ? _k : null,
+        onIsHdr: (_l = options.onIsHdr) !== null && _l !== void 0 ? _l : null,
+        onKeyframes: (_m = options.onKeyframes) !== null && _m !== void 0 ? _m : null,
+        onLocation: (_o = options.onLocation) !== null && _o !== void 0 ? _o : null,
+        onMetadata: (_p = options.onMetadata) !== null && _p !== void 0 ? _p : null,
+        onMimeType: (_q = options.onMimeType) !== null && _q !== void 0 ? _q : null,
+        onName: (_r = options.onName) !== null && _r !== void 0 ? _r : null,
+        onNumberOfAudioChannels: (_s = options.onNumberOfAudioChannels) !== null && _s !== void 0 ? _s : null,
+        onParseProgress: (_t = options.onParseProgress) !== null && _t !== void 0 ? _t : null,
+        onRotation: (_u = options.onRotation) !== null && _u !== void 0 ? _u : null,
+        onSampleRate: (_v = options.onSampleRate) !== null && _v !== void 0 ? _v : null,
+        onSize: (_w = options.onSize) !== null && _w !== void 0 ? _w : null,
+        onSlowAudioBitrate: (_x = options.onSlowAudioBitrate) !== null && _x !== void 0 ? _x : null,
+        onSlowDurationInSeconds: (_y = options.onSlowDurationInSeconds) !== null && _y !== void 0 ? _y : null,
+        onSlowFps: (_z = options.onSlowFps) !== null && _z !== void 0 ? _z : null,
+        onSlowKeyframes: (_0 = options.onSlowKeyframes) !== null && _0 !== void 0 ? _0 : null,
+        onSlowNumberOfFrames: (_1 = options.onSlowNumberOfFrames) !== null && _1 !== void 0 ? _1 : null,
+        onSlowVideoBitrate: (_2 = options.onSlowVideoBitrate) !== null && _2 !== void 0 ? _2 : null,
+        onStructure: (_3 = options.onStructure) !== null && _3 !== void 0 ? _3 : null,
+        onM3uStreams: (_4 = options.onM3uStreams) !== null && _4 !== void 0 ? _4 : null,
+        onTracks: (_5 = options.onTracks) !== null && _5 !== void 0 ? _5 : null,
+        onUnrotatedDimensions: (_6 = options.onUnrotatedDimensions) !== null && _6 !== void 0 ? _6 : null,
+        onVideoCodec: (_7 = options.onVideoCodec) !== null && _7 !== void 0 ? _7 : null,
         onVideoTrack: null,
-        progressIntervalInMs: (_6 = options.progressIntervalInMs) !== null && _6 !== void 0 ? _6 : null,
-        reader: (_7 = options.reader) !== null && _7 !== void 0 ? _7 : from_fetch_1.fetchReader,
-        controller: (_8 = options.controller) !== null && _8 !== void 0 ? _8 : undefined,
+        progressIntervalInMs: (_8 = options.progressIntervalInMs) !== null && _8 !== void 0 ? _8 : null,
+        reader: (_9 = options.reader) !== null && _9 !== void 0 ? _9 : from_fetch_1.fetchReader,
+        controller: (_10 = options.controller) !== null && _10 !== void 0 ? _10 : undefined,
         src: options.src,
         onError: async (err) => {
             var _a, _b;

package/dist/emit-available-info.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitAvailableInfo = void 0;
+const get_streams_1 = require("./containers/m3u/get-streams");
 const get_audio_codec_1 = require("./get-audio-codec");
 const get_container_1 = require("./get-container");
 const get_dimensions_1 = require("./get-dimensions");
@@ -15,7 +16,7 @@ const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
 const get_metadata_1 = require("./metadata/get-metadata");
 const emitAvailableInfo = async ({ hasInfo, callbacks, state, returnValue, name, mimeType, fieldsInReturnValue, }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
     const keys = Object.keys(hasInfo);
     const { emittedFields } = state;
     for (const key of keys) {
@@ -339,6 +340,17 @@ const emitAvailableInfo = async ({ hasInfo, callbacks, state, returnValue, name,
             }
             continue;
         }
+        if (key === 'm3uStreams') {
+            if (!emittedFields.m3uStreams && hasInfo.m3uStreams) {
+                const streams = (0, get_streams_1.getM3uStreams)(state.getStructureOrNull(), typeof state.src === 'string' ? state.src : null);
+                await ((_5 = callbacks.onM3uStreams) === null || _5 === void 0 ? void 0 : _5.call(callbacks, streams));
+                if (fieldsInReturnValue.m3uStreams) {
+                    returnValue.m3uStreams = streams;
+                }
+                emittedFields.m3uStreams = true;
+            }
+            continue;
+        }
         throw new Error(`Unhandled key: ${key}`);
     }
 };

package/dist/emitter.d.ts

@@ -1,6 +1,9 @@
 type MediaParserEventMap = {
     pause: undefined;
     resume: undefined;
+    abort: {
+        reason?: unknown;
+    };
 };
 export type MediaParserEventTypes = keyof MediaParserEventMap;
 export type CallbackListener<T extends MediaParserEventTypes> = (data: {
@@ -16,5 +19,6 @@ export declare class MediaParserEmitter {
     private dispatchEvent;
     dispatchPause: () => void;
     dispatchResume: () => void;
+    dispatchAbort: (reason?: unknown) => void;
 }
 export {};

package/dist/emitter.js

@@ -6,6 +6,7 @@ class MediaParserEmitter {
         this.listeners = {
             pause: [],
             resume: [],
+            abort: [],
         };
         this.addEventListener = (name, callback) => {
             this.listeners[name].push(callback);
@@ -19,6 +20,9 @@ class MediaParserEmitter {
         this.dispatchResume = () => {
             this.dispatchEvent('resume', undefined);
         };
+        this.dispatchAbort = (reason) => {
+            this.dispatchEvent('abort', { reason });
+        };
     }
     dispatchEvent(dispatchName, context) {
         this.listeners[dispatchName].forEach((callback) => {

package/dist/esm/fetch.mjs

@@ -0,0 +1,148 @@
+// src/errors.ts
+class MediaParserAbortError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MediaParserAbortError";
+    this.cause = undefined;
+  }
+}
+
+// src/readers/fetch/get-body-and-reader.ts
+var getLengthAndReader = async (endsWithM3u8, res, ownController) => {
+  if (endsWithM3u8) {
+    const text = await res.text();
+    const encoded = new TextEncoder().encode(text);
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoded);
+        controller.close();
+      }
+    });
+    return {
+      contentLength: encoded.byteLength,
+      reader: {
+        reader: stream.getReader(),
+        abort() {
+          ownController.abort();
+        }
+      },
+      needsContentRange: false
+    };
+  }
+  const length = res.headers.get("content-length");
+  const contentLength = length === null ? null : parseInt(length, 10);
+  if (!res.body) {
+    throw new Error("No body");
+  }
+  const reader = res.body.getReader();
+  return {
+    reader: {
+      reader,
+      abort: () => {
+        ownController.abort();
+      }
+    },
+    contentLength,
+    needsContentRange: true
+  };
+};
+
+// src/readers/fetch/resolve-url.ts
+var resolveUrl = (src) => {
+  try {
+    const resolvedUrl = typeof window !== "undefined" && typeof window.location !== "undefined" ? new URL(src, window.location.origin) : new URL(src);
+    return resolvedUrl;
+  } catch {
+    return src;
+  }
+};
+
+// src/readers/from-fetch.ts
+function parseContentRange(input) {
+  const matches = input.match(/^(\w+) ((\d+)-(\d+)|\*)\/(\d+|\*)$/);
+  if (!matches)
+    return null;
+  const [, unit, , start, end, size] = matches;
+  const range = {
+    unit,
+    start: start != null ? Number(start) : null,
+    end: end != null ? Number(end) : null,
+    size: size === "*" ? null : Number(size)
+  };
+  if (range.start === null && range.end === null && range.size === null) {
+    return null;
+  }
+  return range;
+}
+var validateContentRangeAndDetectIfSupported = (actualRange, parsedContentRange, statusCode) => {
+  if (statusCode === 206) {
+    return { supportsContentRange: true };
+  }
+  if (typeof actualRange === "number" && parsedContentRange?.start !== actualRange) {
+    if (actualRange === 0) {
+      return { supportsContentRange: false };
+    }
+    throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange?.start})`);
+  }
+  if (actualRange !== null && typeof actualRange !== "number" && (parsedContentRange?.start !== actualRange[0] || parsedContentRange?.end !== actualRange[1])) {
+    throw new Error(`Range header (${actualRange}) does not match content-range header (${parsedContentRange?.start})`);
+  }
+  return { supportsContentRange: true };
+};
+var fetchReader = {
+  read: async ({ src, range, controller }) => {
+    if (typeof src !== "string") {
+      throw new Error("src must be a string when using `fetchReader`");
+    }
+    const resolvedUrl = resolveUrl(src);
+    const resolvedUrlString = resolvedUrl.toString();
+    if (!resolvedUrlString.startsWith("https://") && !resolvedUrlString.startsWith("blob:") && !resolvedUrlString.startsWith("http://")) {
+      return Promise.reject(new Error(`${resolvedUrlString} is not a URL - needs to start with http:// or https:// or blob:. If you want to read a local file, pass \`reader: nodeReader\` to parseMedia().`));
+    }
+    const ownController = new AbortController;
+    const cache = typeof navigator !== "undefined" && navigator.userAgent.includes("Cloudflare-Workers") ? undefined : "no-store";
+    const actualRange = range === null ? 0 : range;
+    const endsWithM3u8 = (typeof resolvedUrl === "string" ? resolvedUrl : resolvedUrl.pathname).endsWith(".m3u8");
+    const headers = actualRange === 0 && endsWithM3u8 ? {} : typeof actualRange === "number" ? {
+      Range: `bytes=${actualRange}-`
+    } : {
+      Range: `bytes=${`${actualRange[0]}-${actualRange[1]}`}`
+    };
+    const res = await fetch(resolvedUrl, {
+      headers,
+      signal: ownController.signal,
+      cache
+    });
+    const contentRange = res.headers.get("content-range");
+    const parsedContentRange = contentRange ? parseContentRange(contentRange) : null;
+    const { supportsContentRange } = validateContentRangeAndDetectIfSupported(actualRange, parsedContentRange, res.status);
+    controller._internals.signal.addEventListener("abort", () => {
+      ownController.abort(new MediaParserAbortError("Aborted by user"));
+    }, { once: true });
+    if (res.status.toString().startsWith("4") || res.status.toString().startsWith("5")) {
+      throw new Error(`Server returned status code ${res.status} for ${src} and range ${actualRange}`);
+    }
+    const contentDisposition = res.headers.get("content-disposition");
+    const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
+    const fallbackName = src.split("/").pop();
+    const { contentLength, needsContentRange, reader } = await getLengthAndReader(endsWithM3u8, res, ownController);
+    if (controller) {
+      controller._internals.signal.addEventListener("abort", () => {
+        reader.reader.cancel().catch(() => {
+        });
+      }, { once: true });
+    }
+    return {
+      reader,
+      contentLength,
+      contentType: res.headers.get("content-type"),
+      name: name ?? fallbackName,
+      supportsContentRange,
+      needsContentRange
+    };
+  }
+};
+export {
+  parseContentRange,
+  fetchReader
+};