@amazon/vinyl-util 3.0.0 → 3.1.0

package/dist/index.cjs

@@ -47,6 +47,7 @@ __export(index_exports, {
   ConsoleLogHandlerImpl: () => ConsoleLogHandlerImpl,
   DEFAULT_MAX_HISTORY: () => DEFAULT_MAX_HISTORY,
   DEFAULT_TIMEOUT_MESSAGE: () => DEFAULT_TIMEOUT_MESSAGE,
+  DEFAULT_WEBM_TIMECODE_SCALE: () => DEFAULT_WEBM_TIMECODE_SCALE,
   Deferred: () => Deferred,
   DeviceType: () => DeviceType,
   DeviceVendor: () => DeviceVendor,
@@ -227,7 +228,6 @@ __export(index_exports, {
   logDebug: () => logDebug,
   logError: () => logError,
   logInfo: () => logInfo,
-  logPatchedEvents: () => logPatchedEvents,
   logTimer: () => logTimer,
   logVerbose: () => logVerbose,
   logWarn: () => logWarn,
@@ -265,9 +265,9 @@ __export(index_exports, {
   parseTimestamp: () => parseTimestamp,
   parseUserAgent: () => parseUserAgent,
   parseVersion: () => parseVersion,
+  parseWebmCues: () => parseWebmCues,
+  parseWebmInit: () => parseWebmInit,
   patchFetch: () => patchFetch,
-  patchTarget: () => patchTarget,
-  patchTargetFromFlags: () => patchTargetFromFlags,
   persistenceRef: () => persistenceRef,
   plainObjectEqualRule: () => plainObjectEqualRule,
   plainObjectMergeRule: () => plainObjectMergeRule,
@@ -278,6 +278,7 @@ __export(index_exports, {
   promise: () => promise,
   rangeIntersects: () => rangeIntersects,
   rangesOf: () => rangesOf,
+  readResponseBody: () => readResponseBody,
   redispatchEvents: () => redispatchEvents,
   regexRule: () => regexRule,
   regexpEqualRule: () => regexpEqualRule,
@@ -4748,183 +4749,36 @@ function requestWithRetry(input, init, options) {
 function isResponseError(error) {
   return error instanceof RequestError && error.info.type === "response" /* RESPONSE */;
 }
-
-// src/patch/patchTarget.ts
-function patchTarget(target, ...patchFactories) {
-  const n = patchFactories.length;
-  if (n === 0) {
-    let disposed = false;
-    return {
-      patched: target,
-      eventFabricated: emptySignal,
-      eventSquelched: emptySignal,
-      dispose: () => {
-        if (disposed) throw new DisposedError();
-        disposed = true;
-      }
-    };
-  } else if (n === 1) {
-    return _patchTarget(target, patchFactories[0]);
-  } else {
-    const { add, dispose } = createDisposer();
-    let patched = target;
-    const eventFabricated = add(new SignalImpl());
-    const eventSquelched = add(new SignalImpl());
-    const patchedChain = [];
-    patchFactories.forEach((factory) => {
-      const next = patchTarget(patched, factory);
-      patched = next.patched;
-      patchedChain.push(next);
-      next.eventFabricated.listen(
-        (event) => eventFabricated.dispatch(event)
+async function readResponseBody(response, as) {
+  let read;
+  switch (as) {
+    case "arrayBuffer":
+      read = response.arrayBuffer();
+      break;
+    case "text":
+      read = response.text();
+      break;
+    case "json":
+      read = response.json();
+      break;
+  }
+  try {
+    return await read;
+  } catch (error) {
+    if ((error == null ? void 0 : error.name) === "AbortError")
+      throw new ReportableError(
+        "Response body read aborted",
+        ErrorOrigin.INTERNAL,
+        "silent" /* SILENT */
       );
-      next.eventSquelched.listen(
-        (event) => eventSquelched.dispatch(event)
-      );
-    });
-    for (let i = patchedChain.length - 1; i >= 0; i--) {
-      add(patchedChain[i]);
-    }
-    return {
-      patched,
-      eventFabricated,
-      eventSquelched,
-      dispose
-    };
-  }
-}
-function _patchTarget(target, patchFactory) {
-  var _a, _b, _c;
-  const { add, dispose } = createDisposer();
-  const eventFabricated = add(new SignalImpl());
-  const eventSquelched = add(new SignalImpl());
-  const patch = add(patchFactory(target));
-  const proxyEventHost = add(new EventHostImpl());
-  (_a = patch.eventFabricated) == null ? void 0 : _a.listen((event) => {
-    eventFabricated.dispatch(event);
-    proxyEventHost.dispatch(event.type, event);
-  });
-  const delegatedEvents = /* @__PURE__ */ new Set();
-  const subs = /* @__PURE__ */ new Map();
-  let addEventListener = void 0;
-  let removeEventListener = void 0;
-  if (isEventTarget(target)) {
-    if (patch.events || patch.eventFabricated) {
-      const eventPatches = (_b = patch.events) != null ? _b : {};
-      const observeTargetEvent = (type) => {
-        if (!delegatedEvents.has(type)) {
-          delegatedEvents.add(type);
-          const targetHandler = (event) => {
-            const patchedEvent = event.type in eventPatches ? eventPatches[event.type](event) : event;
-            if (patchedEvent)
-              proxyEventHost.dispatch(
-                patchedEvent.type,
-                patchedEvent
-              );
-            else eventSquelched.dispatch(event);
-          };
-          target.addEventListener(type, targetHandler);
-        }
-      };
-      addEventListener = (type, callback, options) => {
-        var _a2;
-        if (typeof callback !== "function")
-          throw new IllegalArgumentError(
-            "only function callbacks are supported"
-          );
-        observeTargetEvent(type);
-        subs.set(
-          callback,
-          proxyEventHost.on(type, callback, {
-            once: typeof options === "object" ? (_a2 = options.once) != null ? _a2 : false : false
-          })
-        );
-      };
-      removeEventListener = (_, callback) => {
-        if (typeof callback !== "function")
-          throw new IllegalArgumentError(
-            "only function callbacks are supported"
-          );
-        const sub = subs.get(callback);
-        if (sub) {
-          subs.delete(callback);
-          sub();
-        }
-      };
-      for (const eventPatchesKey in eventPatches) {
-        observeTargetEvent(eventPatchesKey);
-      }
-    } else {
-      addEventListener = target.addEventListener.bind(target);
-      removeEventListener = target.removeEventListener.bind(target);
-    }
+    const status = response.status;
+    const origin = status >= 500 && status < 600 ? ErrorOrigin.SERVICE_EXTERNAL : ErrorOrigin.SERVICE_INTERNAL;
+    throw new ReportableError(
+      `Failed to read response body: ${String(error)}`,
+      origin,
+      "fatal" /* FATAL */
+    );
   }
-  const propertyPatches = (_c = patch.properties) != null ? _c : {};
-  const patched = new Proxy(target, {
-    get(target2, p, receiver) {
-      const key = p;
-      if (key === "addEventListener") {
-        return addEventListener;
-      } else if (key === "removeEventListener") {
-        return removeEventListener;
-      }
-      const patch2 = propertyPatches[key];
-      const value = patch2 && patch2.get ? patch2.get() : target2[key];
-      if (typeof value === "function") {
-        return function(...args) {
-          return value.apply(this === receiver ? target2 : this, args);
-        };
-      }
-      return value;
-    },
-    set(target2, p, newValue) {
-      const key = p;
-      const patch2 = propertyPatches[key];
-      if (patch2 && patch2.set) patch2.set(newValue);
-      else target2[key] = newValue;
-      return true;
-    }
-  });
-  return {
-    patched,
-    eventFabricated,
-    eventSquelched,
-    // Certain supported platforms do not support Proxy.revocable, but this is not a
-    // requirement; we do not need to provide a Proxy to a consumer that needs its
-    // lifespan controlled.
-    dispose
-  };
-}
-function logPatchedEvents(pathTarget, patched) {
-  const eventSquelchedSub = patched.eventSquelched.listen(
-    (event) => logDebug(pathTarget, `'${event.type}' event squelched`)
-  );
-  const eventFabricatedSub = patched.eventFabricated.listen(
-    (event) => logDebug(pathTarget, `'${event.type}' event fabricated`)
-  );
-  return () => {
-    eventSquelchedSub();
-    eventFabricatedSub();
-  };
-}
-function isEventTarget(target) {
-  return "addEventListener" in target;
-}
-function patchTargetFromFlags(target, flags, ...patchEntries) {
-  const pathTarget = {
-    logPrefix: createLogPrefix("Patch")
-  };
-  const filtered = patchEntries.filter(([key]) => {
-    const enabled = flags[key] === true;
-    if (enabled) logDebug(pathTarget, `Applying '${String(key)}' patch`);
-    return enabled;
-  });
-  const patchedRef = patchTarget(
-    target,
-    ...filtered.map(([_, factory]) => factory)
-  );
-  logPatchedEvents(pathTarget, patchedRef);
-  return patchedRef;
 }
 
 // src/persistence/StoragePersistence.ts
@@ -6131,4 +5985,137 @@ function resolveDots(path) {
   }
   return out.join("/");
 }
+
+// src/util/webm/parseWebm.ts
+var EBML_ID = {
+  Segment: 408125543,
+  Info: 357149030,
+  TimecodeScale: 2807729,
+  Cues: 475249515,
+  CuePoint: 187,
+  CueTime: 179,
+  CueTrackPositions: 183,
+  CueClusterPosition: 241
+};
+var DEFAULT_WEBM_TIMECODE_SCALE = 1e6;
+function readVint(view, pos, keepMarker) {
+  const first2 = view.getUint8(pos);
+  let mask = 128;
+  let length = 1;
+  while (length <= 8 && (first2 & mask) === 0) {
+    mask >>= 1;
+    length++;
+  }
+  if (length > 8)
+    throw new ValidationError(
+      "invalid EBML variable-length integer",
+      ErrorOrigin.MEDIA
+    );
+  let value = keepMarker ? first2 : first2 & mask - 1;
+  let allOnes = (first2 & mask - 1) === mask - 1;
+  for (let i = 1; i < length; i++) {
+    const byte = view.getUint8(pos + i);
+    allOnes = allOnes && byte === 255;
+    value = value * 256 + byte;
+  }
+  return { value: !keepMarker && allOnes ? null : value, length };
+}
+function readElementHeader(view, pos) {
+  const { value: id, length: idLength } = readVint(view, pos, true);
+  const { value: size, length: sizeLength } = readVint(
+    view,
+    pos + idLength,
+    false
+  );
+  const contentStart = pos + idLength + sizeLength;
+  return {
+    id,
+    contentStart,
+    size,
+    end: size == null ? null : contentStart + size
+  };
+}
+function childHeaders(view, start, end) {
+  const out = [];
+  let pos = start;
+  while (pos < end) {
+    const el = readElementHeader(view, pos);
+    out.push(el);
+    if (el.end == null) break;
+    pos = el.end;
+  }
+  return out;
+}
+function readUint(view, pos, length) {
+  let value = 0;
+  for (let i = 0; i < length; i++)
+    value = value * 256 + view.getUint8(pos + i);
+  return value;
+}
+function parseWebmInit(buffer) {
+  var _a;
+  const view = new DataView(buffer);
+  const segment = childHeaders(view, 0, view.byteLength).find(
+    (el) => el.id === EBML_ID.Segment
+  );
+  if (!segment)
+    throw new ValidationError(
+      "WebM init segment missing Segment element",
+      ErrorOrigin.MEDIA
+    );
+  const segmentEnd = Math.min((_a = segment.end) != null ? _a : view.byteLength, view.byteLength);
+  const info = childHeaders(view, segment.contentStart, segmentEnd).find(
+    (el) => el.id === EBML_ID.Info && el.size != null
+  );
+  return {
+    segmentDataStart: segment.contentStart,
+    segmentSize: segment.size,
+    timecodeScale: info ? readTimecodeScale(view, info.contentStart, info.end) : DEFAULT_WEBM_TIMECODE_SCALE
+  };
+}
+function readTimecodeScale(view, start, end) {
+  const el = childHeaders(view, start, end).find(
+    (child) => child.id === EBML_ID.TimecodeScale && child.size
+  );
+  return el ? readUint(view, el.contentStart, el.size) : DEFAULT_WEBM_TIMECODE_SCALE;
+}
+function parseWebmCues(buffer) {
+  var _a;
+  const view = new DataView(buffer);
+  const cues = readElementHeader(view, 0);
+  if (cues.id !== EBML_ID.Cues)
+    throw new ValidationError(
+      `expected WebM 'Cues' element but had id: 0x${cues.id.toString(16)}`,
+      ErrorOrigin.MEDIA
+    );
+  const cuesEnd = Math.min((_a = cues.end) != null ? _a : view.byteLength, view.byteLength);
+  const cuePoints = [];
+  for (const el of childHeaders(view, cues.contentStart, cuesEnd)) {
+    if (el.id !== EBML_ID.CuePoint || el.size == null) continue;
+    const cuePoint = parseCuePoint(view, el.contentStart, el.end);
+    if (cuePoint) cuePoints.push(cuePoint);
+  }
+  return cuePoints;
+}
+function parseCuePoint(view, start, end) {
+  let time = null;
+  let clusterPosition = null;
+  for (const el of childHeaders(view, start, end)) {
+    if (el.id === EBML_ID.CueTime && el.size)
+      time = readUint(view, el.contentStart, el.size);
+    else if (el.id === EBML_ID.CueTrackPositions && el.size != null)
+      clusterPosition = readCueClusterPosition(
+        view,
+        el.contentStart,
+        el.end
+      );
+  }
+  return time != null && clusterPosition != null ? { time, clusterPosition } : null;
+}
+function readCueClusterPosition(view, start, end) {
+  const el = childHeaders(view, start, end).find(
+    (child) => child.id === EBML_ID.CueClusterPosition && child.size
+  );
+  return el ? readUint(view, el.contentStart, el.size) : null;
+}
 //# sourceMappingURL=index.cjs.map