@remotion/media-parser 4.0.209 → 4.0.211

package/dist/esm/from-fetch.mjs

@@ -0,0 +1,107 @@
+// 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) => {
+  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, signal) => {
+    if (typeof src !== "string") {
+      throw new Error("src must be a string when using `fetchReader`");
+    }
+    const resolvedUrl = typeof window !== "undefined" && typeof window.location !== "undefined" ? new URL(src, window.location.origin).toString() : src;
+    if (!resolvedUrl.startsWith("https://") && !resolvedUrl.startsWith("blob:") && !resolvedUrl.startsWith("http://")) {
+      return Promise.reject(new Error(resolvedUrl + " 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 controller = new AbortController;
+    const cache = typeof navigator !== "undefined" && navigator.userAgent.includes("Cloudflare-Workers") ? undefined : "no-store";
+    const actualRange = range === null ? 0 : range;
+    const res = await fetch(resolvedUrl, {
+      headers: typeof actualRange === "number" ? {
+        Range: `bytes=${actualRange}-`
+      } : {
+        Range: `bytes=${`${actualRange[0]}-${actualRange[1]}`}`
+      },
+      signal: controller.signal,
+      cache
+    });
+    const contentRange = res.headers.get("content-range");
+    const parsedContentRange = contentRange ? parseContentRange(contentRange) : null;
+    const { supportsContentRange } = validateContentRangeAndDetectIfSupported(actualRange, parsedContentRange);
+    signal?.addEventListener("abort", () => {
+      controller.abort();
+    }, { 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}`);
+    }
+    if (!res.body) {
+      throw new Error("No body");
+    }
+    const length = res.headers.get("content-length");
+    const contentLength = length === null ? null : parseInt(length, 10);
+    const contentDisposition = res.headers.get("content-disposition");
+    const name = contentDisposition?.match(/filename="([^"]+)"/)?.[1];
+    const fallbackName = src.split("/").pop();
+    const reader = res.body.getReader();
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        reader.cancel().catch(() => {
+        });
+      }, { once: true });
+    }
+    return {
+      reader: {
+        reader,
+        abort: () => {
+          controller.abort();
+        }
+      },
+      contentLength,
+      name: name ?? fallbackName,
+      supportsContentRange
+    };
+  },
+  getLength: async (src) => {
+    if (typeof src !== "string") {
+      throw new Error("src must be a string when using `fetchReader`");
+    }
+    const res = await fetch(src, {
+      method: "HEAD"
+    });
+    if (!res.body) {
+      throw new Error("No body");
+    }
+    const length = res.headers.get("content-length");
+    if (!length) {
+      throw new Error("No content-length");
+    }
+    return parseInt(length, 10);
+  }
+};
+export {
+  parseContentRange,
+  fetchReader
+};

package/dist/esm/from-node.mjs

@@ -0,0 +1,49 @@
+// src/readers/from-node.ts
+import {createReadStream} from "fs";
+import {stat} from "node:fs/promises";
+import {Readable} from "stream";
+var nodeReader = {
+  read: async (src, range, signal) => {
+    if (typeof src !== "string") {
+      throw new Error("src must be a string when using `nodeReader`");
+    }
+    const controller = new AbortController;
+    const stream = createReadStream(src, {
+      start: range === null ? 0 : typeof range === "number" ? range : range[0],
+      end: range === null ? Infinity : typeof range === "number" ? Infinity : range[1],
+      signal: controller.signal
+    });
+    signal?.addEventListener("abort", () => {
+      controller.abort();
+    }, { once: true });
+    const stats = await stat(src);
+    const reader = Readable.toWeb(stream).getReader();
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        reader.cancel().catch(() => {
+        });
+      }, { once: true });
+    }
+    return {
+      reader: {
+        reader,
+        abort: () => {
+          controller.abort();
+        }
+      },
+      contentLength: stats.size,
+      name: src.split("/").pop(),
+      supportsContentRange: true
+    };
+  },
+  getLength: async (src) => {
+    if (typeof src !== "string") {
+      throw new Error("src must be a string when using `nodeReader`");
+    }
+    const stats = await stat(src);
+    return stats.size;
+  }
+};
+export {
+  nodeReader
+};

package/dist/esm/from-web-file.mjs

@@ -0,0 +1,49 @@
+// src/readers/from-web-file.ts
+var webFileReader = {
+  read: (file, range, signal) => {
+    if (typeof file === "string") {
+      throw new Error("`inputTypeFileReader` only supports `File` objects");
+    }
+    const part = range === null ? file : typeof range === "number" ? file.slice(range) : file.slice(range[0], range[1]);
+    const reader = new FileReader;
+    reader.readAsArrayBuffer(file);
+    const controller = new AbortController;
+    if (controller) {
+      controller.signal.addEventListener("abort", () => {
+        reader.abort();
+      }, { once: true });
+    }
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        controller.abort();
+      }, { once: true });
+    }
+    return new Promise((resolve, reject) => {
+      reader.onload = () => {
+        resolve({
+          reader: {
+            reader: part.stream().getReader(),
+            abort() {
+              controller.abort();
+            }
+          },
+          contentLength: file.size,
+          name: file.name,
+          supportsContentRange: true
+        });
+      };
+      reader.onerror = (error) => {
+        reject(error);
+      };
+    });
+  },
+  getLength: (src) => {
+    if (typeof src === "string") {
+      throw new Error("`inputTypeFileReader` only supports `File` objects");
+    }
+    return Promise.resolve(src.size);
+  }
+};
+export {
+  webFileReader
+};