@remotion/media-parser 4.0.289 → 4.0.291

package/dist/esm/node.mjs

@@ -1,7 +1,6 @@
 // src/readers/from-node.ts
 import { createReadStream, promises, statSync } from "fs";
 import { dirname, join, relative, sep } from "path";
-import { Readable } from "stream";
 var nodeReadContent = ({ src, range, controller }) => {
   if (typeof src !== "string") {
     throw new Error("src must be a string when using `nodeReader`");
@@ -16,7 +15,27 @@ var nodeReadContent = ({ src, range, controller }) => {
     ownController.abort();
   }, { once: true });
   const stats = statSync(src);
-  const reader = Readable.toWeb(stream).getReader();
+  let readerCancelled = false;
+  const reader = new ReadableStream({
+    start(c) {
+      if (readerCancelled) {
+        return;
+      }
+      stream.on("data", (chunk) => {
+        c.enqueue(chunk);
+      });
+      stream.on("end", () => {
+        c.close();
+      });
+      stream.on("error", (err) => {
+        c.error(err);
+      });
+    },
+    cancel() {
+      readerCancelled = true;
+      stream.destroy();
+    }
+  }).getReader();
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
       reader.cancel().catch(() => {});
@@ -56,7 +75,8 @@ var nodeCreateAdjacentFileSource = (relativePath, src) => {
 var nodeReader = {
   read: nodeReadContent,
   readWholeAsText: nodeReadWholeAsText,
-  createAdjacentFileSource: nodeCreateAdjacentFileSource
+  createAdjacentFileSource: nodeCreateAdjacentFileSource,
+  preload: () => {}
 };
 export {
   nodeReader,

package/dist/esm/server-worker.mjs

@@ -144,8 +144,14 @@ var deserializeError = (error) => {
       });
     case "MediaParserAbortError":
       return new MediaParserAbortError(error.errorMessage);
-    default:
+    case "Error":
+      return new Error(error.errorMessage);
+    case "AbortError":
       return new Error(error.errorMessage);
+    case "NotReadableError":
+      return new Error(error.errorMessage);
+    default:
+      throw new Error(`Unknown error name: ${error}`);
   }
 };
 
@@ -280,6 +286,7 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     if (data.type === "response-error") {
       cleanup();
       const error = deserializeError(data);
+      error.stack = data.errorStack;
       reject(error);
       if (data.errorName === "MediaParserAbortError") {
         finalSeekingHints = data.seekingHints;

package/dist/esm/universal.mjs

@@ -7,6 +7,40 @@ class MediaParserAbortError extends Error {
   }
 }
 
+// src/log.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isEqualOrBelowLogLevel = (currentLevel, level) => {
+  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+var Log = {
+  trace: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
+      return console.log(...args);
+    }
+  },
+  verbose: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
+      return console.log(...args);
+    }
+  },
+  info: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "info")) {
+      return console.log(...args);
+    }
+  },
+  warn: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
+      return console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    return console.error(...args);
+  }
+};
+
 // src/readers/fetch/get-body-and-reader.ts
 var getLengthAndReader = async ({
   canLiveWithoutContentLength,
@@ -19,10 +53,22 @@ var getLengthAndReader = async ({
   if (requestedWithoutRange || canLiveWithoutContentLength && contentLength === null) {
     const buffer = await res.arrayBuffer();
     const encoded = new Uint8Array(buffer);
+    let streamCancelled = false;
     const stream = new ReadableStream({
       start(controller) {
-        controller.enqueue(encoded);
-        controller.close();
+        if (ownController.signal.aborted) {
+          return;
+        }
+        if (streamCancelled) {
+          return;
+        }
+        try {
+          controller.enqueue(encoded);
+          controller.close();
+        } catch {}
+      },
+      cancel() {
+        streamCancelled = true;
       }
     });
     return {
@@ -98,14 +144,11 @@ var validateContentRangeAndDetectIfSupported = ({
   }
   return { supportsContentRange: true };
 };
-var fetchReadContent = async ({
-  src,
+var makeFetchRequest = async ({
   range,
+  src,
   controller
 }) => {
-  if (typeof src !== "string" && src instanceof URL === false) {
-    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://")) {
@@ -134,21 +177,83 @@ var fetchReadContent = async ({
     parsedContentRange,
     statusCode: res.status
   });
-  controller._internals.signal.addEventListener("abort", () => {
-    ownController.abort(new MediaParserAbortError("Aborted by user"));
-  }, { once: true });
+  if (controller) {
+    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 ${requestedRange}`);
+    throw new Error(`Server returned status code ${res.status} for ${resolvedUrl} and range ${requestedRange}`);
   }
   const contentDisposition = res.headers.get("content-disposition");
   const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
-  const fallbackName = src.toString().split("/").pop();
   const { contentLength, needsContentRange, reader } = await getLengthAndReader({
     canLiveWithoutContentLength,
     res,
     ownController,
     requestedWithoutRange: requestWithoutRange
   });
+  const contentType = res.headers.get("content-type");
+  return {
+    contentLength,
+    needsContentRange,
+    reader,
+    name,
+    contentType,
+    supportsContentRange
+  };
+};
+var cacheKey = ({
+  src,
+  range
+}) => {
+  return `${src}-${JSON.stringify(range)}`;
+};
+var makeFetchRequestOrGetCached = ({
+  range,
+  src,
+  controller,
+  logLevel,
+  prefetchCache
+}) => {
+  const key = cacheKey({ src, range });
+  const cached = prefetchCache.get(key);
+  if (cached) {
+    Log.verbose(logLevel, `Reading from preload cache for ${key}`);
+    return cached;
+  }
+  Log.verbose(logLevel, `Fetching ${key}`);
+  const result = makeFetchRequest({ range, src, controller });
+  prefetchCache.set(key, result);
+  return result;
+};
+var fetchReadContent = async ({
+  src,
+  range,
+  controller,
+  logLevel,
+  prefetchCache
+}) => {
+  if (typeof src !== "string" && src instanceof URL === false) {
+    throw new Error("src must be a string when using `fetchReader`");
+  }
+  const fallbackName = src.toString().split("/").pop();
+  const {
+    reader,
+    contentLength,
+    needsContentRange,
+    name,
+    supportsContentRange,
+    contentType
+  } = await makeFetchRequestOrGetCached({
+    range,
+    src,
+    controller,
+    logLevel,
+    prefetchCache
+  });
+  const key = cacheKey({ src, range });
+  prefetchCache.delete(key);
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
       reader.reader.cancel().catch(() => {});
@@ -157,12 +262,33 @@ var fetchReadContent = async ({
   return {
     reader,
     contentLength,
-    contentType: res.headers.get("content-type"),
+    contentType,
     name: name ?? fallbackName,
     supportsContentRange,
     needsContentRange
   };
 };
+var fetchPreload = ({
+  src,
+  range,
+  logLevel,
+  prefetchCache
+}) => {
+  if (typeof src !== "string" && src instanceof URL === false) {
+    throw new Error("src must be a string when using `fetchReader`");
+  }
+  const key = cacheKey({ src, range });
+  if (prefetchCache.has(key)) {
+    return prefetchCache.get(key);
+  }
+  makeFetchRequestOrGetCached({
+    range,
+    src,
+    controller: null,
+    logLevel,
+    prefetchCache
+  });
+};
 var fetchReadWholeAsText = async (src) => {
   if (typeof src !== "string" && src instanceof URL === false) {
     throw new Error("src must be a string when using `fetchReader`");
@@ -183,7 +309,6 @@ var fetchCreateAdjacentFileSource = (relativePath, src) => {
 // src/readers/from-node.ts
 import { createReadStream, promises, statSync } from "fs";
 import { dirname, join, relative, sep } from "path";
-import { Readable } from "stream";
 var nodeReadContent = ({ src, range, controller }) => {
   if (typeof src !== "string") {
     throw new Error("src must be a string when using `nodeReader`");
@@ -198,7 +323,27 @@ var nodeReadContent = ({ src, range, controller }) => {
     ownController.abort();
   }, { once: true });
   const stats = statSync(src);
-  const reader = Readable.toWeb(stream).getReader();
+  let readerCancelled = false;
+  const reader = new ReadableStream({
+    start(c) {
+      if (readerCancelled) {
+        return;
+      }
+      stream.on("data", (chunk) => {
+        c.enqueue(chunk);
+      });
+      stream.on("end", () => {
+        c.close();
+      });
+      stream.on("error", (err) => {
+        c.error(err);
+      });
+    },
+    cancel() {
+      readerCancelled = true;
+      stream.destroy();
+    }
+  }).getReader();
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
       reader.cancel().catch(() => {});
@@ -314,6 +459,14 @@ var universalReader = {
       return fetchCreateAdjacentFileSource(relativePath, src);
     }
     return nodeCreateAdjacentFileSource(relativePath, src);
+  },
+  preload: ({ src, range, logLevel, prefetchCache }) => {
+    if (src instanceof Blob) {
+      return;
+    }
+    if (src.toString().startsWith("http") || src.toString().startsWith("blob:")) {
+      return fetchPreload({ range, src, logLevel, prefetchCache });
+    }
   }
 };
 export {

package/dist/esm/web.mjs

@@ -7,6 +7,40 @@ class MediaParserAbortError extends Error {
   }
 }
 
+// src/log.ts
+var logLevels = ["trace", "verbose", "info", "warn", "error"];
+var getNumberForLogLevel = (level) => {
+  return logLevels.indexOf(level);
+};
+var isEqualOrBelowLogLevel = (currentLevel, level) => {
+  return getNumberForLogLevel(currentLevel) <= getNumberForLogLevel(level);
+};
+var Log = {
+  trace: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "trace")) {
+      return console.log(...args);
+    }
+  },
+  verbose: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "verbose")) {
+      return console.log(...args);
+    }
+  },
+  info: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "info")) {
+      return console.log(...args);
+    }
+  },
+  warn: (logLevel, ...args) => {
+    if (isEqualOrBelowLogLevel(logLevel, "warn")) {
+      return console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    return console.error(...args);
+  }
+};
+
 // src/readers/fetch/get-body-and-reader.ts
 var getLengthAndReader = async ({
   canLiveWithoutContentLength,
@@ -19,10 +53,22 @@ var getLengthAndReader = async ({
   if (requestedWithoutRange || canLiveWithoutContentLength && contentLength === null) {
     const buffer = await res.arrayBuffer();
     const encoded = new Uint8Array(buffer);
+    let streamCancelled = false;
     const stream = new ReadableStream({
       start(controller) {
-        controller.enqueue(encoded);
-        controller.close();
+        if (ownController.signal.aborted) {
+          return;
+        }
+        if (streamCancelled) {
+          return;
+        }
+        try {
+          controller.enqueue(encoded);
+          controller.close();
+        } catch {}
+      },
+      cancel() {
+        streamCancelled = true;
       }
     });
     return {
@@ -98,14 +144,11 @@ var validateContentRangeAndDetectIfSupported = ({
   }
   return { supportsContentRange: true };
 };
-var fetchReadContent = async ({
-  src,
+var makeFetchRequest = async ({
   range,
+  src,
   controller
 }) => {
-  if (typeof src !== "string" && src instanceof URL === false) {
-    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://")) {
@@ -134,21 +177,83 @@ var fetchReadContent = async ({
     parsedContentRange,
     statusCode: res.status
   });
-  controller._internals.signal.addEventListener("abort", () => {
-    ownController.abort(new MediaParserAbortError("Aborted by user"));
-  }, { once: true });
+  if (controller) {
+    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 ${requestedRange}`);
+    throw new Error(`Server returned status code ${res.status} for ${resolvedUrl} and range ${requestedRange}`);
   }
   const contentDisposition = res.headers.get("content-disposition");
   const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
-  const fallbackName = src.toString().split("/").pop();
   const { contentLength, needsContentRange, reader } = await getLengthAndReader({
     canLiveWithoutContentLength,
     res,
     ownController,
     requestedWithoutRange: requestWithoutRange
   });
+  const contentType = res.headers.get("content-type");
+  return {
+    contentLength,
+    needsContentRange,
+    reader,
+    name,
+    contentType,
+    supportsContentRange
+  };
+};
+var cacheKey = ({
+  src,
+  range
+}) => {
+  return `${src}-${JSON.stringify(range)}`;
+};
+var makeFetchRequestOrGetCached = ({
+  range,
+  src,
+  controller,
+  logLevel,
+  prefetchCache
+}) => {
+  const key = cacheKey({ src, range });
+  const cached = prefetchCache.get(key);
+  if (cached) {
+    Log.verbose(logLevel, `Reading from preload cache for ${key}`);
+    return cached;
+  }
+  Log.verbose(logLevel, `Fetching ${key}`);
+  const result = makeFetchRequest({ range, src, controller });
+  prefetchCache.set(key, result);
+  return result;
+};
+var fetchReadContent = async ({
+  src,
+  range,
+  controller,
+  logLevel,
+  prefetchCache
+}) => {
+  if (typeof src !== "string" && src instanceof URL === false) {
+    throw new Error("src must be a string when using `fetchReader`");
+  }
+  const fallbackName = src.toString().split("/").pop();
+  const {
+    reader,
+    contentLength,
+    needsContentRange,
+    name,
+    supportsContentRange,
+    contentType
+  } = await makeFetchRequestOrGetCached({
+    range,
+    src,
+    controller,
+    logLevel,
+    prefetchCache
+  });
+  const key = cacheKey({ src, range });
+  prefetchCache.delete(key);
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
       reader.reader.cancel().catch(() => {});
@@ -157,12 +262,33 @@ var fetchReadContent = async ({
   return {
     reader,
     contentLength,
-    contentType: res.headers.get("content-type"),
+    contentType,
     name: name ?? fallbackName,
     supportsContentRange,
     needsContentRange
   };
 };
+var fetchPreload = ({
+  src,
+  range,
+  logLevel,
+  prefetchCache
+}) => {
+  if (typeof src !== "string" && src instanceof URL === false) {
+    throw new Error("src must be a string when using `fetchReader`");
+  }
+  const key = cacheKey({ src, range });
+  if (prefetchCache.has(key)) {
+    return prefetchCache.get(key);
+  }
+  makeFetchRequestOrGetCached({
+    range,
+    src,
+    controller: null,
+    logLevel,
+    prefetchCache
+  });
+};
 var fetchReadWholeAsText = async (src) => {
   if (typeof src !== "string" && src instanceof URL === false) {
     throw new Error("src must be a string when using `fetchReader`");
@@ -249,6 +375,12 @@ var webReader = {
       return webFileReadWholeAsText(src);
     }
     return fetchReadWholeAsText(src);
+  },
+  preload: ({ range, src, logLevel, prefetchCache }) => {
+    if (src instanceof Blob) {
+      return;
+    }
+    return fetchPreload({ range, src, logLevel, prefetchCache });
   }
 };
 export {