@amazon/vinyl-util 3.2.2 → 3.2.3-next.20261001143710

package/dist/index.cjs

@@ -105,6 +105,7 @@ __export(index_exports, {
   arrayEqualRule: () => arrayEqualRule,
   arrayMergeRule: () => arrayMergeRule,
   base64ToByteArray: () => base64ToByteArray,
+  bufferToArrayBuffer: () => bufferToArrayBuffer,
   bufferToBase64: () => bufferToBase64,
   bufferToByteArray: () => bufferToByteArray,
   bufferToByteStr: () => bufferToByteStr,
@@ -278,6 +279,7 @@ __export(index_exports, {
   promise: () => promise,
   rangeIntersects: () => rangeIntersects,
   rangesOf: () => rangesOf,
+  rateLimit: () => rateLimit,
   readResponseBody: () => readResponseBody,
   redispatchEvents: () => redispatchEvents,
   regexRule: () => regexRule,
@@ -1546,7 +1548,8 @@ var LruCache = class {
     return true;
   }
   /**
-   * Executes a provided function once per each key/value pair in the Map, in insertion order.
+   * Executes a provided function once per each key/value pair in the Map,
+   * ordered from least recently used to most.
    *
    * @param callback A callback to invoke for every element in the cache.
    * @param thisArg Value to use as this when executing callback
@@ -1591,8 +1594,8 @@ function memoize(inner, keyProvider, capacity = 500) {
     let value = void 0;
     const memoized = () => {
       if (!cached) {
-        cached = true;
         value = inner();
+        cached = true;
       }
       return value;
     };
@@ -1621,9 +1624,9 @@ function memoize(inner, keyProvider, capacity = 500) {
     const memoized = (...args) => {
       const key = keyProvider(...args);
       if (!hasValue || cachedKey !== key) {
-        hasValue = true;
-        cachedKey = key;
         cachedValue = inner(...args);
+        cachedKey = key;
+        hasValue = true;
       }
       return cachedValue;
     };
@@ -1686,7 +1689,8 @@ function isWhitespaceChar(charCode) {
   charCode === 13 || // '\r' (carriage return)
   charCode === 10;
 }
-var encodedEntitiesRegex = /&(#(\d+)|\w+);/gi;
+var encodedEntitiesRegex = /&(?:#(?:x([\da-f]+)|(\d+))|(\w+));/gi;
+var MAX_CODE_POINT = 1114111;
 var predefinedDecodeEntities = /* @__PURE__ */ new Map([
   ["apos", "'"],
   ["amp", "&"],
@@ -1695,20 +1699,22 @@ var predefinedDecodeEntities = /* @__PURE__ */ new Map([
   ["quot", '"']
 ]);
 function decodeEntities(str, namedEntities = predefinedDecodeEntities) {
-  if (encodedEntitiesRegex.test(str)) {
-    return str.replace(
-      encodedEntitiesRegex,
-      (substring, entityName, codePoint) => {
-        if (codePoint !== void 0)
-          return String.fromCharCode(parseInt(codePoint));
-        const entityValue = namedEntities.get(entityName.toLowerCase());
-        if (!entityValue) return substring;
-        return entityValue;
+  return str.replace(
+    encodedEntitiesRegex,
+    (substring, hex, decimal, entityName) => {
+      var _a;
+      if (hex == null && decimal == null) {
+        return (_a = namedEntities.get(entityName.toLowerCase())) != null ? _a : substring;
       }
-    );
-  } else {
-    return str;
-  }
+      const codePoint = hex != null ? parseInt(hex, 16) : parseInt(decimal, 10);
+      if (codePoint > MAX_CODE_POINT || isSurrogate(codePoint))
+        return substring;
+      return String.fromCodePoint(codePoint);
+    }
+  );
+}
+function isSurrogate(codePoint) {
+  return codePoint >= 55296 && codePoint <= 57343;
 }
 var standardEntityValueToNames = /* @__PURE__ */ flipMap(predefinedDecodeEntities);
 var entitiesRegex = /['&<>"]/g;
@@ -3991,7 +3997,11 @@ var NetworkMetricsControllerImpl = class extends EventHostImpl {
     __publicField(this, "onDownloadSpeedChange", () => {
       var _a;
       const downlink = (_a = this.deps.networkInformation) == null ? void 0 : _a.downlink;
-      const estimatedSpeed = downlink ? downlink * 1024 * 1024 : this.options.unknownDownlinkBandwidthEstimate;
+      const estimatedSpeed = downlink ? (
+        // Megabits are decimal, matching the measured `bytes * 8 / seconds`
+        // this estimate is averaged with.
+        downlink * 1e6
+      ) : this.options.unknownDownlinkBandwidthEstimate;
       updateStatMetrics(
         this._metrics.estimatedDownlinkBandwidth,
         estimatedSpeed,
@@ -4499,38 +4509,41 @@ var RequesterImpl = class extends EventHostImpl {
     this.dispatch("request", { requestInfo });
     let lastResult = null;
     let currentTry = 0;
-    do {
-      ++currentTry;
-      const attemptInfo = {
-        currentTry,
-        timestamp: Date.now()
-      };
-      this.dispatch("requestAttemptStart", {
-        requestInfo,
-        attemptInfo
-      });
-      lastResult = await this.doRequest(
-        requestInfo,
-        requestOptions,
-        attemptInfo,
-        timeoutController
-      ).catch((reason) => {
-        var _a2;
-        const completeInfo = {
-          ok: false,
-          type: ((_a2 = requestOptions.abort) == null ? void 0 : _a2.aborted()) ? "abort" /* ABORT */ : "internal" /* INTERNAL */,
-          requestInfo,
-          reason,
-          willRetry: false,
-          timestamp: Date.now(),
-          retryAfter: null
+    try {
+      do {
+        ++currentTry;
+        const attemptInfo = {
+          currentTry,
+          timestamp: Date.now()
         };
-        return { info: completeInfo, response: null };
-      });
+        this.dispatch("requestAttemptStart", {
+          requestInfo,
+          attemptInfo
+        });
+        lastResult = await this.doRequest(
+          requestInfo,
+          requestOptions,
+          attemptInfo,
+          timeoutController
+        ).catch((reason) => {
+          var _a2;
+          const completeInfo = {
+            ok: false,
+            type: ((_a2 = requestOptions.abort) == null ? void 0 : _a2.aborted()) ? "abort" /* ABORT */ : "internal" /* INTERNAL */,
+            requestInfo,
+            reason,
+            willRetry: false,
+            timestamp: Date.now(),
+            retryAfter: null
+          };
+          return { info: completeInfo, response: null };
+        });
+        this.reportMetricsEntry(lastResult.info);
+        this.dispatch("requestAttemptComplete", lastResult.info);
+      } while (!lastResult.info.ok && lastResult.info.willRetry);
+    } finally {
       timeoutController.dispose();
-      this.reportMetricsEntry(lastResult.info);
-      this.dispatch("requestAttemptComplete", lastResult.info);
-    } while (!lastResult.info.ok && lastResult.info.willRetry);
+    }
     this.dispatch("requestComplete", lastResult.info);
     if (lastResult.info.ok) return lastResult.response;
     else throw new RequestError(lastResult.response, lastResult.info);
@@ -4991,6 +5004,13 @@ function utf16ToUint16Array(str) {
 function bufferToByteArray(buffer) {
   return buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
 }
+function bufferToArrayBuffer(buffer) {
+  if (buffer instanceof ArrayBuffer) return buffer;
+  return buffer.buffer.slice(
+    buffer.byteOffset,
+    buffer.byteOffset + buffer.byteLength
+  );
+}
 function buffersEqual(bufferA, bufferB) {
   if (bufferA === bufferB) return true;
   if (!bufferA && !bufferB) return true;
@@ -5395,6 +5415,64 @@ function flowRightAsync(...fns) {
   };
 }
 
+// src/util/fun/rateLimit.ts
+function rateLimit(inner, options) {
+  const { capacity, interval } = options;
+  if (capacity < 1)
+    throw new IllegalArgumentError("capacity must be at least 1.");
+  if (interval <= 0)
+    throw new IllegalArgumentError("interval must be greater than 0.");
+  const intervalMs = interval * 1e3;
+  let tokens = capacity;
+  let lastRefillMs = Date.now();
+  let pending = 0;
+  const timeout2 = new TimeoutSlot();
+  let disposed = false;
+  const refill = () => {
+    const now = Date.now();
+    const refilled = Math.floor((now - lastRefillMs) / intervalMs);
+    if (refilled > 0) {
+      tokens = Math.min(capacity, tokens + refilled);
+      lastRefillMs += refilled * intervalMs;
+    }
+    if (tokens === capacity) lastRefillMs = now;
+  };
+  const drain = () => {
+    refill();
+    while (pending > 0 && tokens >= 1) {
+      tokens -= 1;
+      pending -= 1;
+      inner();
+    }
+    if (pending > 0 && !timeout2.active) {
+      const nextTokenMs = intervalMs - (Date.now() - lastRefillMs);
+      timeout2.set(drain, nextTokenMs / 1e3);
+    }
+  };
+  return Object.assign(
+    () => {
+      if (disposed) throw new DisposedError();
+      pending += 1;
+      drain();
+    },
+    {
+      reset() {
+        tokens = capacity;
+        lastRefillMs = Date.now();
+        if (timeout2.active) timeout2.clear();
+        while (pending > 0) {
+          pending -= 1;
+          inner();
+        }
+      },
+      dispose() {
+        disposed = true;
+        timeout2.dispose();
+      }
+    }
+  );
+}
+
 // src/util/mpeg/parseSidxBox.ts
 function parseSidxBox(buffer) {
   const reader = new BufferReader(buffer);