@remotion/media-parser 4.0.266 → 4.0.267

package/dist/containers/flac/get-channel-count.d.ts

@@ -1,2 +1,2 @@
 import type { BufferIterator } from '../../buffer-iterator';
-export declare const getChannelCount: (iterator: BufferIterator) => 2 | 1 | 8 | 7 | 3 | 6 | 5 | 4;
+export declare const getChannelCount: (iterator: BufferIterator) => 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;

package/dist/containers/m3u/get-streams.d.ts

@@ -1,6 +1,15 @@
 import type { Dimensions } from '../../get-dimensions';
 import type { Structure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
+export type M3uStreamAudioTrack = {
+    groupId: string;
+    language: string | null;
+    name: string | null;
+    autoselect: boolean;
+    default: boolean;
+    channels: number | null;
+    url: string;
+};
 export type M3uStream = {
     url: string;
     bandwidth: number | null;
@@ -8,6 +17,7 @@ export type M3uStream = {
     resolution: Dimensions | null;
     codecs: string[] | null;
     id: number;
+    dedicatedAudioTracks: M3uStreamAudioTrack[];
 };
 export declare const isIndependentSegments: (structure: Structure | null) => boolean;
 export declare const getM3uStreams: (structure: Structure | null, originalSrc: string | null) => M3uStream[] | null;

package/dist/containers/m3u/get-streams.js

@@ -20,6 +20,25 @@ const getM3uStreams = (structure, originalSrc) => {
             if (next.type !== 'm3u-text-value') {
                 throw new Error('Expected m3u-text-value');
             }
+            const dedicatedAudioTracks = [];
+            if (str.audio) {
+                const match = structure.boxes.filter((box) => {
+                    return box.type === 'm3u-media-info' && box.groupId === str.audio;
+                });
+                for (const audioTrack of match) {
+                    dedicatedAudioTracks.push({
+                        autoselect: audioTrack.autoselect,
+                        channels: audioTrack.channels,
+                        default: audioTrack.default,
+                        groupId: audioTrack.groupId,
+                        language: audioTrack.language,
+                        name: audioTrack.name,
+                        url: originalSrc && originalSrc.startsWith('http')
+                            ? new URL(audioTrack.uri, originalSrc).href
+                            : audioTrack.uri,
+                    });
+                }
+            }
             boxes.push({
                 url: originalSrc && originalSrc.startsWith('http')
                     ? new URL(next.value, originalSrc).href
@@ -28,6 +47,7 @@ const getM3uStreams = (structure, originalSrc) => {
                 bandwidth: str.bandwidth,
                 codecs: str.codecs,
                 resolution: str.resolution,
+                dedicatedAudioTracks,
             });
         }
     }

package/dist/containers/m3u/parse-directive.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseM3uDirective = void 0;
+const parse_m3u_media_directive_1 = require("./parse-m3u-media-directive");
 const parse_stream_inf_1 = require("./parse-stream-inf");
 const parseM3uDirective = (str) => {
     const firstColon = str.indexOf(':');
@@ -20,6 +21,13 @@ const parseM3uDirective = (str) => {
             type: 'm3u-independent-segments',
         };
     }
+    if (directive === '#EXT-X-MEDIA') {
+        if (!value) {
+            throw new Error('EXT-X-MEDIA directive must have a value');
+        }
+        const parsed = (0, parse_m3u_media_directive_1.parseM3uMediaDirective)(value);
+        return parsed;
+    }
     if (directive === '#EXT-X-TARGETDURATION') {
         if (!value) {
             throw new Error('EXT-X-TARGETDURATION directive must have a value');

package/dist/containers/m3u/parse-m3u-media-directive.d.ts

@@ -0,0 +1,2 @@
+import type { M3uMediaInfo } from './types';
+export declare const parseM3uMediaDirective: (str: string) => M3uMediaInfo;

package/dist/containers/m3u/parse-m3u-media-directive.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseM3uMediaDirective = void 0;
+const parse_stream_inf_1 = require("./parse-stream-inf");
+const parseM3uMediaDirective = (str) => {
+    const quotes = (0, parse_stream_inf_1.splitRespectingQuotes)(str);
+    const map = {};
+    for (const quote of quotes) {
+        const firstColon = quote.indexOf('=');
+        const key = firstColon === -1 ? quote : quote.slice(0, firstColon);
+        const value = firstColon === -1 ? null : quote.slice(firstColon + 1);
+        if (value === null) {
+            throw new Error('Value is null');
+        }
+        const actualValue = (value === null || value === void 0 ? void 0 : value.startsWith('"')) && (value === null || value === void 0 ? void 0 : value.endsWith('"'))
+            ? value.slice(1, -1)
+            : value;
+        map[key] = actualValue;
+    }
+    return {
+        type: 'm3u-media-info',
+        autoselect: map.AUTOSELECT === 'YES',
+        channels: map.CHANNELS ? parseInt(map.CHANNELS, 10) : null,
+        default: map.DEFAULT === 'YES',
+        groupId: map['GROUP-ID'],
+        language: map.LANGUAGE || null,
+        name: map.NAME || null,
+        uri: map.URI,
+    };
+};
+exports.parseM3uMediaDirective = parseM3uMediaDirective;

package/dist/containers/m3u/parse-stream-inf.js

@@ -56,6 +56,7 @@ const parseStreamInf = (str) => {
                 height: parseInt(map.RESOLUTION.split('x')[1], 10),
             }
             : null,
+        audio: map.AUDIO || null,
     };
 };
 exports.parseStreamInf = parseStreamInf;

package/dist/containers/m3u/types.d.ts

@@ -8,6 +8,9 @@ export type M3uVersion = {
 export type M3uIndependentSegments = {
     type: 'm3u-independent-segments';
 };
+export type M3uMedia = {
+    type: 'm3u-media';
+};
 export type M3uTargetDuration = {
     type: 'm3u-target-duration';
     duration: number;
@@ -36,12 +39,23 @@ export type M3uStreamInfo = {
         width: number;
         height: number;
     } | null;
+    audio: string | null;
+};
+export type M3uMediaInfo = {
+    type: 'm3u-media-info';
+    groupId: string;
+    language: string | null;
+    name: string | null;
+    autoselect: boolean;
+    default: boolean;
+    channels: number | null;
+    uri: string;
 };
 export type M3uTextValue = {
     type: 'm3u-text-value';
     value: string;
 };
-export type M3uBox = M3uHeader | M3uPlaylist | M3uVersion | M3uIndependentSegments | M3uStreamInfo | M3uTargetDuration | M3uPlaylistType | M3uExtInf | M3uEndList | M3uTextValue;
+export type M3uBox = M3uHeader | M3uPlaylist | M3uVersion | M3uIndependentSegments | M3uStreamInfo | M3uTargetDuration | M3uPlaylistType | M3uExtInf | M3uMedia | M3uMediaInfo | M3uEndList | M3uTextValue;
 export type M3uStructure = {
     type: 'm3u';
     boxes: M3uBox[];

package/dist/esm/{from-fetch.mjs → fetch.mjs}

@@ -1,118 +1,4 @@
 // src/errors.ts
-class IsAGifError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.fileName = "IsAGifError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAGifError);
-    }
-  }
-}
-
-class IsAnImageError extends Error {
-  imageType;
-  dimensions;
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    dimensions,
-    imageType,
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.name = "IsAnImageError";
-    this.imageType = imageType;
-    this.dimensions = dimensions;
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAnImageError);
-    }
-  }
-}
-
-class IsAPdfError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.name = "IsAPdfError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAPdfError);
-    }
-  }
-}
-
-class IsAnUnsupportedFileTypeError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName
-  }) {
-    super(message);
-    this.name = "IsAnUnsupportedFileTypeError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAnUnsupportedFileTypeError);
-    }
-  }
-}
-
-class IsAnUnsupportedAudioTypeError extends Error {
-  mimeType;
-  sizeInBytes;
-  fileName;
-  audioType;
-  constructor({
-    message,
-    mimeType,
-    sizeInBytes,
-    fileName,
-    audioType
-  }) {
-    super(message);
-    this.name = "IsAnUnsupportedAudioTypeError";
-    this.mimeType = mimeType;
-    this.sizeInBytes = sizeInBytes;
-    this.fileName = fileName;
-    this.audioType = audioType;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, IsAnUnsupportedAudioTypeError);
-    }
-  }
-}
-
 class MediaParserAbortError extends Error {
   constructor(message) {
     super(message);
@@ -120,22 +6,20 @@ class MediaParserAbortError extends Error {
     this.cause = undefined;
   }
 }
-var hasBeenAborted = (error) => {
-  return error instanceof MediaParserAbortError;
-};
 
 // 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(new TextEncoder().encode(text));
+        controller.enqueue(encoded);
         controller.close();
       }
     });
     return {
-      contentLength: text.length,
+      contentLength: encoded.byteLength,
       reader: {
         reader: stream.getReader(),
         abort() {