mediabunny 1.56.2 → 1.56.3

package/dist/bundles/mediabunny.cjs

@@ -312,6 +312,139 @@ var Mediabunny = (() => {
       return new DataView(source);
     }
   };
+  var TextEncoder = typeof globalThis.TextEncoder !== "undefined" ? globalThis.TextEncoder : class TextEncoder2 {
+    constructor() {
+      this.encoding = "utf-8";
+    }
+    encode(input = "") {
+      const bytes2 = new Uint8Array(3 * input.length);
+      let n = 0;
+      for (let i = 0; i < input.length; i++) {
+        let c = input.charCodeAt(i);
+        if (c < 128) {
+          bytes2[n++] = c;
+        } else if (c < 2048) {
+          bytes2[n++] = 192 | c >> 6;
+          bytes2[n++] = 128 | c & 63;
+        } else if (c < 55296 || c > 57343) {
+          bytes2[n++] = 224 | c >> 12;
+          bytes2[n++] = 128 | c >> 6 & 63;
+          bytes2[n++] = 128 | c & 63;
+        } else {
+          const next = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
+          if (c < 56320 && next >= 56320 && next <= 57343) {
+            c = 65536 + (c - 55296 << 10) + (next - 56320);
+            i++;
+            bytes2[n++] = 240 | c >> 18;
+            bytes2[n++] = 128 | c >> 12 & 63;
+            bytes2[n++] = 128 | c >> 6 & 63;
+            bytes2[n++] = 128 | c & 63;
+          } else {
+            bytes2[n++] = 239;
+            bytes2[n++] = 191;
+            bytes2[n++] = 189;
+          }
+        }
+      }
+      return bytes2.slice(0, n);
+    }
+  };
+  var TextDecoder = typeof globalThis.TextDecoder !== "undefined" ? globalThis.TextDecoder : class TextDecoder2 {
+    constructor(label = "utf-8") {
+      const normalized = label.trim().toLowerCase();
+      if (normalized === "utf-8" || normalized === "utf8" || normalized === "unicode-1-1-utf-8") {
+        this.encoding = "utf-8";
+      } else if (normalized === "utf-16le" || normalized === "utf-16") {
+        this.encoding = "utf-16le";
+      } else if (normalized === "utf-16be") {
+        this.encoding = "utf-16be";
+      } else {
+        throw new RangeError(`The encoding label provided ('${label}') is invalid.`);
+      }
+    }
+    decode(input) {
+      const bytes2 = input ? toUint8Array(input) : new Uint8Array(0);
+      const units = [];
+      if (this.encoding === "utf-8") {
+        let i = bytes2.length >= 3 && bytes2[0] === 239 && bytes2[1] === 187 && bytes2[2] === 191 ? 3 : 0;
+        while (i < bytes2.length) {
+          const lead = bytes2[i];
+          if (lead < 128) {
+            units.push(lead);
+            i++;
+            continue;
+          }
+          let continuationCount;
+          let codePoint;
+          if (lead >= 194 && lead < 224) {
+            continuationCount = 1;
+            codePoint = lead & 31;
+          } else if (lead >= 224 && lead < 240) {
+            continuationCount = 2;
+            codePoint = lead & 15;
+          } else if (lead >= 240 && lead < 245) {
+            continuationCount = 3;
+            codePoint = lead & 7;
+          } else {
+            units.push(65533);
+            i++;
+            continue;
+          }
+          let lowerBound = lead === 224 ? 160 : lead === 240 ? 144 : 128;
+          let upperBound = lead === 237 ? 159 : lead === 244 ? 143 : 191;
+          let j = 1;
+          for (; j <= continuationCount; j++) {
+            const byte = i + j < bytes2.length ? bytes2[i + j] : 0;
+            if (byte < lowerBound || byte > upperBound) {
+              break;
+            }
+            codePoint = codePoint << 6 | byte & 63;
+            lowerBound = 128;
+            upperBound = 191;
+          }
+          i += j;
+          if (j <= continuationCount) {
+            units.push(65533);
+          } else if (codePoint >= 65536) {
+            codePoint -= 65536;
+            units.push(55296 | codePoint >> 10, 56320 | codePoint & 1023);
+          } else {
+            units.push(codePoint);
+          }
+        }
+      } else {
+        const littleEndian = this.encoding === "utf-16le";
+        const bomLow = littleEndian ? 255 : 254;
+        const bomHigh = littleEndian ? 254 : 255;
+        let i = bytes2.length >= 2 && bytes2[0] === bomLow && bytes2[1] === bomHigh ? 2 : 0;
+        while (i + 1 < bytes2.length) {
+          const unit = littleEndian ? bytes2[i] | bytes2[i + 1] << 8 : bytes2[i] << 8 | bytes2[i + 1];
+          i += 2;
+          if (unit >= 55296 && unit <= 56319) {
+            const next = i + 1 < bytes2.length ? littleEndian ? bytes2[i] | bytes2[i + 1] << 8 : bytes2[i] << 8 | bytes2[i + 1] : -1;
+            if (next >= 56320 && next <= 57343) {
+              units.push(unit, next);
+              i += 2;
+            } else {
+              units.push(65533);
+            }
+          } else if (unit >= 56320 && unit <= 57343) {
+            units.push(65533);
+          } else {
+            units.push(unit);
+          }
+        }
+        if (i < bytes2.length) {
+          units.push(65533);
+        }
+      }
+      let result = "";
+      for (let i = 0; i < units.length; i += 8192) {
+        result += String.fromCharCode(...units.slice(i, i + 8192));
+      }
+      return result;
+    }
+  };
   var textDecoder = /* @__PURE__ */ new TextDecoder();
   var textEncoder = /* @__PURE__ */ new TextEncoder();
   var isIso88591Compatible = (text) => {
@@ -17752,6 +17885,8 @@ var Mediabunny = (() => {
         );
       }
       super();
+      /** @internal */
+      this._readers = /* @__PURE__ */ new Set();
       this._options = options;
       this._orchestrator = new ReadOrchestrator({
         maxCacheSize: options.maxCacheSize ?? 8 * 2 ** 20,
@@ -17796,6 +17931,9 @@ var Mediabunny = (() => {
         let data = this._options.read(worker.currentPos, originalTargetPos);
         if (isThenable(data)) data = await data;
         if (worker.aborted) {
+          if (data instanceof ReadableStream) {
+            await data.cancel();
+          }
           break;
         }
         if (data instanceof Uint8Array) {
@@ -17809,25 +17947,33 @@ var Mediabunny = (() => {
           this._orchestrator.supplyWorkerData(worker, data);
         } else if (data instanceof ReadableStream) {
           const reader = data.getReader();
-          while (worker.currentPos < originalTargetPos && !worker.aborted) {
-            const { done, value } = await reader.read();
-            if (done) {
-              if (worker.currentPos < originalTargetPos) {
-                throw new Error(
-                  `ReadableStream returned by options.read ended before supplying enough data. Requested ${originalTargetPos - originalCurrentPos} bytes, but got ${worker.currentPos - originalCurrentPos}`
+          this._readers.add(reader);
+          try {
+            while (worker.currentPos < originalTargetPos && !worker.aborted) {
+              const { done, value } = await reader.read();
+              if (done) {
+                if (worker.currentPos < originalTargetPos) {
+                  throw new Error(
+                    `ReadableStream returned by options.read ended before supplying enough data. Requested ${originalTargetPos - originalCurrentPos} bytes, but got ${worker.currentPos - originalCurrentPos}`
+                  );
+                }
+                break;
+              }
+              if (!(value instanceof Uint8Array)) {
+                throw new TypeError(
+                  "ReadableStream returned by options.read must yield Uint8Array chunks."
                 );
               }
-              break;
-            }
-            if (!(value instanceof Uint8Array)) {
-              throw new TypeError("ReadableStream returned by options.read must yield Uint8Array chunks.");
-            }
-            if (worker.aborted) {
-              break;
+              if (worker.aborted) {
+                break;
+              }
+              const data2 = toUint8Array(value);
+              this._dispatchRead(worker.currentPos, worker.currentPos + data2.length);
+              this._orchestrator.supplyWorkerData(worker, data2);
             }
-            const data2 = toUint8Array(value);
-            this._dispatchRead(worker.currentPos, worker.currentPos + data2.length);
-            this._orchestrator.supplyWorkerData(worker, data2);
+          } finally {
+            this._readers.delete(reader);
+            reader.releaseLock();
           }
         } else {
           throw new TypeError("options.read must return or resolve to a Uint8Array or a ReadableStream.");
@@ -17838,6 +17984,11 @@ var Mediabunny = (() => {
     /** @internal */
     _dispose() {
       this._orchestrator.dispose();
+      for (const reader of this._readers) {
+        void reader.cancel().catch(() => {
+        });
+      }
+      this._readers.clear();
       this._options.dispose?.();
     }
   };
@@ -34213,7 +34364,7 @@ ${cue.notes ?? ""}`;
       this.writer.write(this.helper);
     }
     writeAscii(text) {
-      this.writer.write(new TextEncoder().encode(text));
+      this.writer.write(textEncoder.encode(text));
     }
   };