@remotion/media-parser 4.0.286 → 4.0.287

package/dist/esm/node-writer.mjs

@@ -41,8 +41,7 @@ var createContent = (filename) => {
     let writPromise = Promise.resolve();
     const remove = async () => {
       Log.verbose(logLevel, "Removing file", filename);
-      await fs.promises.unlink(filename).catch(() => {
-      });
+      await fs.promises.unlink(filename).catch(() => {});
     };
     await remove();
     if (!fs.existsSync(filename)) {

package/dist/esm/node.mjs

@@ -19,8 +19,7 @@ var nodeReadContent = ({ src, range, controller }) => {
   const reader = Readable.toWeb(stream).getReader();
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
-      reader.cancel().catch(() => {
-      });
+      reader.cancel().catch(() => {});
     }, { once: true });
   }
   return Promise.resolve({

package/dist/esm/server-worker.mjs

@@ -235,6 +235,7 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     throw new Error(`\`reader\` should not be provided to \`${apiName}\`. If you want to use it in the browser, use parseMediaOnWorker(). If you also want to read files from the file system, use parseMediaOnServerWorker().`);
   }
   post(worker, convertToWorkerPayload(params));
+  let workerTerminated = false;
   const { promise, resolve, reject } = withResolvers();
   const onAbort = () => {
     post(worker, { type: "request-abort" });
@@ -249,15 +250,48 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     post(worker, { type: "request-seek", payload: seek });
     controller?._internals.seekSignal.clearSeekIfStillSame(seek);
   };
+  const seekingHintPromises = [];
+  let finalSeekingHints = null;
+  controller?._internals.attachSeekingHintResolution(() => {
+    if (finalSeekingHints) {
+      return Promise.resolve(finalSeekingHints);
+    }
+    if (workerTerminated) {
+      return Promise.reject(new Error("Worker terminated"));
+    }
+    const prom = withResolvers();
+    post(worker, { type: "request-get-seeking-hints" });
+    seekingHintPromises.push(prom);
+    return prom.promise;
+  });
   const callbacks = {};
   function onMessage(message) {
     const data = message.data;
     if (data.type === "response-done") {
       resolve(data.payload);
+      if (data.seekingHints) {
+        finalSeekingHints = data.seekingHints;
+        for (const prom of seekingHintPromises) {
+          prom.resolve(finalSeekingHints);
+        }
+      }
+      return;
     }
     if (data.type === "response-error") {
       cleanup();
-      reject(deserializeError(data));
+      const error = deserializeError(data);
+      reject(error);
+      if (data.errorName === "MediaParserAbortError") {
+        finalSeekingHints = data.seekingHints;
+        for (const prom of seekingHintPromises) {
+          prom.resolve(finalSeekingHints);
+        }
+      } else {
+        for (const prom of seekingHintPromises) {
+          prom.reject(error);
+        }
+      }
+      return;
     }
     if (data.type === "response-on-callback-request") {
       Promise.resolve().then(async () => {
@@ -430,7 +464,17 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
           nonce: data.nonce
         });
       });
+      return;
+    }
+    if (data.type === "response-get-seeking-hints") {
+      const firstPromise = seekingHintPromises.shift();
+      if (!firstPromise) {
+        throw new Error("No seeking hint promise found");
+      }
+      firstPromise.resolve(data.payload);
+      return;
     }
+    throw new Error(`Unknown response type: ${JSON.stringify(data)}`);
   }
   worker.addEventListener("message", onMessage);
   controller?.addEventListener("abort", onAbort);
@@ -443,6 +487,7 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     controller?.removeEventListener("resume", onResume);
     controller?.removeEventListener("pause", onPause);
     controller?.removeEventListener("seek", onSeek);
+    workerTerminated = true;
     worker.terminate();
   }
   controller?._internals.markAsReadyToEmitEvents();

package/dist/esm/universal.mjs

@@ -151,8 +151,7 @@ var fetchReadContent = async ({
   });
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
-      reader.reader.cancel().catch(() => {
-      });
+      reader.reader.cancel().catch(() => {});
     }, { once: true });
   }
   return {
@@ -202,8 +201,7 @@ var nodeReadContent = ({ src, range, controller }) => {
   const reader = Readable.toWeb(stream).getReader();
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
-      reader.cancel().catch(() => {
-      });
+      reader.cancel().catch(() => {});
     }, { once: true });
   }
   return Promise.resolve({

package/dist/esm/web.mjs

@@ -151,8 +151,7 @@ var fetchReadContent = async ({
   });
   if (controller) {
     controller._internals.signal.addEventListener("abort", () => {
-      reader.reader.cancel().catch(() => {
-      });
+      reader.reader.cancel().catch(() => {});
     }, { once: true });
   }
   return {