@poe-platform/safe-bash 0.1.812 → 0.1.814

package/dist/safe-bash/command-chunks/{chunk-2JSDKQ4J.js → chunk-LAPOMHGY.js}

@@ -332830,15 +332830,85 @@ function* decodeH264Samples(samples, descriptions, width, height, timescale) {
   if (decoded !== samples.length) throw new Error("H.264 stream did not decode every picture");
 }
 
-// packages/mp4-ast/src/work.ts
-function drainWork(work) {
-  let step = work.next();
-  while (!step.done) step = work.next();
-  return step.value;
+// packages/mp4-ast/src/mp4-sample-source.ts
+function* mp4SampleTableSteps(size, tables, options = {}) {
+  function* read(table, offset, length) {
+    if (!table || offset >= table.payloadSize) return new BinaryReader(new Uint8Array());
+    const bytes = yield { kind: "read", table, offset: table.payloadOffset + offset, length: Math.min(length, table.payloadSize - offset) };
+    return new BinaryReader(bytes);
+  }
+  function* info(table, width, headerSize = 8) {
+    const header = yield* read(table && table.payloadSize >= headerSize ? table : void 0, 0, headerSize);
+    const count = header.bytes.length ? new BinaryReader(header.bytes, headerSize - 4).readU32BE() : 0;
+    return { ...table ? { table } : {}, count: Math.min(count, Math.max(0, Math.ceil(((table?.payloadSize ?? 0) - headerSize) / width))), header, width, headerSize };
+  }
+  function* entry(table, index) {
+    return yield* read(index < table.count ? table.table : void 0, table.headerSize + index * table.width, table.width);
+  }
+  const timing = yield* info(tables.stts, 8), composition = yield* info(tables.ctts, 8), mapping = yield* info(tables.stsc, 12);
+  const sizes = yield* info(tables.stsz, 4, 12);
+  sizes.header.skip(4);
+  const uniformSize = sizes.header.readU32BE(), sampleCount = sizes.header.readU32BE();
+  if (tables.stsz && tables.stsz.payloadSize >= 12) options.budget?.checkSamples(sampleCount);
+  const chunks = yield* info(tables.stco && tables.stco.payloadSize >= 8 ? tables.stco : tables.co64, tables.stco && tables.stco.payloadSize >= 8 ? 4 : 8);
+  const sync = yield* info(tables.stss, 4);
+  for (let i = 0; i < sync.count; i++) yield { kind: "sync-add", sample: (yield* entry(sync, i)).readU32BE() };
+  if (!sampleCount || !chunks.count || !mapping.count) return;
+  let timingIndex = 0, compositionIndex = 0, mappingIndex = 0, sampleIndex = 0, dts = 0;
+  let timingEntry = yield* entry(timing, 0), timingLeft = timingEntry.readU32BE(), delta = timing.count ? timingEntry.readU32BE() : 1024;
+  let compositionEntry = yield* entry(composition, 0), compositionLeft = compositionEntry.readU32BE();
+  const signed = composition.header.bytes[0] === 1;
+  let cts = signed ? compositionEntry.readI32BE() : compositionEntry.readU32BE();
+  function* nextMapping() {
+    const row = yield* entry(mapping, mappingIndex);
+    return { first: row.readU32BE(), count: row.readU32BE(), description: row.readU32BE() || 1 };
+  }
+  let next = yield* nextMapping(), current = next;
+  for (let chunkIndex = 0; chunkIndex < chunks.count && sampleIndex < sampleCount; chunkIndex++) {
+    while (mappingIndex < mapping.count && next.first <= chunkIndex + 1) {
+      current = next;
+      mappingIndex++;
+      if (mappingIndex < mapping.count) next = yield* nextMapping();
+    }
+    const chunk = yield* entry(chunks, chunkIndex);
+    let cursor = chunks.width === 4 ? chunk.readU32BE() : chunk.readU64BE();
+    for (let within = 0; within < current.count && sampleIndex < sampleCount; within++) {
+      options.budget?.checkCpu();
+      const declared = uniformSize || (yield* entry(sizes, sampleIndex)).readU32BE();
+      while (timingLeft <= 0 && timingIndex + 1 < timing.count) {
+        timingEntry = yield* entry(timing, ++timingIndex);
+        timingLeft = timingEntry.readU32BE();
+        delta = timingEntry.readU32BE();
+      }
+      if (timingLeft > 0) timingLeft--;
+      while (compositionLeft <= 0 && compositionIndex + 1 < composition.count) {
+        compositionEntry = yield* entry(composition, ++compositionIndex);
+        compositionLeft = compositionEntry.readU32BE();
+        cts = signed ? compositionEntry.readI32BE() : compositionEntry.readU32BE();
+      }
+      if (compositionLeft > 0) compositionLeft--;
+      const isKeyframe = !tables.stss ? true : !sync.count ? sampleIndex === 0 : Boolean(yield { kind: "sync-has", sample: sampleIndex + 1 });
+      let offset = Math.max(0, Math.min(size, cursor)), length = Math.max(0, Math.min(size - offset, declared));
+      const time = dts;
+      dts += delta;
+      cursor += declared;
+      sampleIndex++;
+      if (options.type === "subtitle" && length >= 2) {
+        const bytes = yield { kind: "read", offset, length: 2 };
+        const textLength = new BinaryReader(bytes).readU16BE();
+        if (!textLength) continue;
+        if (textLength + 2 <= length) {
+          offset += 2;
+          length = textLength;
+        }
+      }
+      yield { kind: "sample", sample: { offset, size: length, dts: time, pts: time + cts, cts, duration: delta, isKeyframe, sampleDescriptionIndex: current.description } };
+    }
+  }
 }
 
-// packages/mp4-ast/src/mp4.ts
-var CONTAINER_BOXES = /* @__PURE__ */ new Set([
+// packages/mp4-ast/src/mp4-box-layout.ts
+var containers = /* @__PURE__ */ new Set([
   "moov",
   "trak",
   "edts",
@@ -332857,6 +332927,37 @@ var CONTAINER_BOXES = /* @__PURE__ */ new Set([
   "tref",
   "gmhd"
 ]);
+function mp4BoxLayout(prefix, remaining) {
+  if (prefix.length < 8) return void 0;
+  const view = new DataView(prefix.buffer, prefix.byteOffset, prefix.length);
+  let size = view.getUint32(0), headerSize = 8;
+  const type = decodeFourCC(prefix, 4);
+  if (size === 1) {
+    if (prefix.length < 16) return void 0;
+    size = view.getUint32(8) * 4294967296 + view.getUint32(12);
+    headerSize = 16;
+  } else if (size === 0) size = remaining;
+  if (size < headerSize || size > remaining) {
+    size = remaining;
+    if (size < headerSize) return void 0;
+  }
+  if (type === "uuid" && headerSize + 16 <= size) return { type, size, headerSize: headerSize + 16, uuidOffset: headerSize };
+  return { type, size, headerSize };
+}
+function mp4BoxChildrenOffset(type, payloadSize, metaChildType) {
+  if (containers.has(type)) return 0;
+  if (type !== "meta" || payloadSize < 12) return void 0;
+  return metaChildType === "hdlr" || metaChildType === "ilst" || metaChildType === "keys" || metaChildType === "free" ? 4 : 0;
+}
+
+// packages/mp4-ast/src/work.ts
+function drainWork(work) {
+  let step = work.next();
+  while (!step.done) step = work.next();
+  return step.value;
+}
+
+// packages/mp4-ast/src/mp4.ts
 function isMp4Signature(bytes) {
   if (bytes.byteLength < 8) return false;
   const type = decodeFourCC(bytes, 4);
@@ -332868,47 +332969,13 @@ function parseMp4Boxes(bytes, baseOffset = 0, depth = 0, budget) {
   let offset = 0;
   while (offset + 8 <= bytes.byteLength) {
     budget?.checkCpu();
-    const view = new DataView(bytes.buffer, bytes.byteOffset + offset, bytes.byteLength - offset);
-    let size = view.getUint32(0, false);
-    const type = decodeFourCC(bytes, offset + 4);
-    let headerSize = 8;
-    if (size === 1) {
-      if (offset + 16 > bytes.byteLength) break;
-      const hi = view.getUint32(8, false);
-      const lo = view.getUint32(12, false);
-      size = hi * 4294967296 + lo;
-      headerSize = 16;
-    } else if (size === 0) {
-      size = bytes.byteLength - offset;
-    }
-    if (size < headerSize || offset + size > bytes.byteLength) {
-      size = bytes.byteLength - offset;
-      if (size < headerSize) break;
-    }
-    let uuid;
-    if (type === "uuid" && headerSize + 16 <= size) {
-      uuid = bytes.subarray(offset + headerSize, offset + headerSize + 16);
-      headerSize += 16;
-    }
+    const layout = mp4BoxLayout(bytes.subarray(offset, offset + 16), bytes.byteLength - offset);
+    if (!layout) break;
+    const { type, size, headerSize, uuidOffset } = layout;
+    const uuid = uuidOffset === void 0 ? void 0 : bytes.subarray(offset + uuidOffset, offset + uuidOffset + 16);
     const payload = bytes.subarray(offset + headerSize, offset + size);
-    let children;
-    if (CONTAINER_BOXES.has(type)) {
-      children = parseMp4Boxes(payload, baseOffset + offset + headerSize, depth + 1, budget);
-    } else if (type === "meta") {
-      if (payload.byteLength >= 12) {
-        const maybeChildType = decodeFourCC(payload, 8);
-        if (maybeChildType === "hdlr" || maybeChildType === "ilst" || maybeChildType === "keys" || maybeChildType === "free") {
-          children = parseMp4Boxes(
-            payload.subarray(4),
-            baseOffset + offset + headerSize + 4,
-            depth + 1,
-            budget
-          );
-        } else {
-          children = parseMp4Boxes(payload, baseOffset + offset + headerSize, depth + 1, budget);
-        }
-      }
-    }
+    const childOffset = mp4BoxChildrenOffset(type, payload.length, type === "meta" && payload.length >= 12 ? decodeFourCC(payload, 8) : void 0);
+    const children = childOffset === void 0 ? void 0 : parseMp4Boxes(payload.subarray(childOffset), baseOffset + offset + headerSize + childOffset, depth + 1, budget);
     boxes.push({
       type,
       offset: baseOffset + offset,
@@ -333360,155 +333427,25 @@ function parseMp4(bytes, options = {}) {
     if (firstCodec?.width && !width) width = firstCodec.width;
     if (firstCodec?.height && !height) height = firstCodec.height;
     const type = handlerType === "vide" ? "video" : handlerType === "soun" ? "audio" : handlerType === "sbtl" || handlerType === "text" || handlerType === "subp" ? "subtitle" : "data";
-    const sttsBox = findBox(stbl?.children, "stts");
-    const sttsEntries = [];
-    if (sttsBox && sttsBox.payload.byteLength >= 8) {
-      const r = new BinaryReader(sttsBox.payload);
-      r.skip(4);
-      const count = r.readU32BE();
-      for (let i = 0; i < count && !r.eof; i++) {
-        sttsEntries.push({ count: r.readU32BE(), delta: r.readU32BE() });
-      }
-    }
-    const cttsBox = findBox(stbl?.children, "ctts");
-    const cttsEntries = [];
-    if (cttsBox && cttsBox.payload.byteLength >= 8) {
-      const r = new BinaryReader(cttsBox.payload);
-      const version = r.readU8();
-      r.skip(3);
-      const count = r.readU32BE();
-      for (let i = 0; i < count && !r.eof; i++) {
-        const sampleCount2 = r.readU32BE();
-        const sampleOffset = version === 1 ? r.readI32BE() : r.readU32BE();
-        cttsEntries.push({ count: sampleCount2, offset: sampleOffset });
-      }
-    }
-    const stscBox = findBox(stbl?.children, "stsc");
-    const stscEntries = [];
-    if (stscBox && stscBox.payload.byteLength >= 8) {
-      const r = new BinaryReader(stscBox.payload);
-      r.skip(4);
-      const count = r.readU32BE();
-      for (let i = 0; i < count && !r.eof; i++) {
-        stscEntries.push({
-          firstChunk: r.readU32BE(),
-          samplesPerChunk: r.readU32BE(),
-          sampleDescriptionIndex: r.readU32BE() || 1
-        });
-      }
-    }
-    const stszBox = findBox(stbl?.children, "stsz");
-    let uniformSampleSize = 0;
-    let sampleCount = 0;
-    const sampleSizes = [];
-    if (stszBox && stszBox.payload.byteLength >= 12) {
-      const r = new BinaryReader(stszBox.payload);
-      r.skip(4);
-      uniformSampleSize = r.readU32BE();
-      sampleCount = r.readU32BE();
-      budget.checkSamples(sampleCount);
-      if (uniformSampleSize === 0) {
-        for (let i = 0; i < sampleCount && !r.eof; i++) {
-          sampleSizes.push(r.readU32BE());
-        }
-      }
+    const tables = {};
+    for (const name of ["stts", "ctts", "stsc", "stsz", "stco", "co64", "stss"]) {
+      const box = findBox(stbl?.children, name);
+      if (box) tables[name] = { payloadOffset: box.offset + box.headerSize, payloadSize: box.payload.length };
     }
-    const stcoBox = findBox(stbl?.children, "stco");
-    const co64Box = findBox(stbl?.children, "co64");
-    const chunkOffsets = [];
-    if (stcoBox && stcoBox.payload.byteLength >= 8) {
-      const r = new BinaryReader(stcoBox.payload);
-      r.skip(4);
-      const count = r.readU32BE();
-      for (let i = 0; i < count && !r.eof; i++) {
-        chunkOffsets.push(r.readU32BE());
-      }
-    } else if (co64Box && co64Box.payload.byteLength >= 8) {
-      const r = new BinaryReader(co64Box.payload);
-      r.skip(4);
-      const count = r.readU32BE();
-      for (let i = 0; i < count && !r.eof; i++) {
-        chunkOffsets.push(r.readU64BE());
-      }
-    }
-    const stssBox = findBox(stbl?.children, "stss");
-    const syncSamples = /* @__PURE__ */ new Set();
-    if (stssBox && stssBox.payload.byteLength >= 8) {
-      const r = new BinaryReader(stssBox.payload);
-      r.skip(4);
-      const count = r.readU32BE();
-      for (let i = 0; i < count && !r.eof; i++) {
-        syncSamples.add(r.readU32BE());
-      }
-    }
-    const samples = [];
-    if (sampleCount > 0 && chunkOffsets.length > 0 && stscEntries.length > 0) {
-      let sttsIdx = 0;
-      let sttsRem = sttsEntries[0]?.count ?? 0;
-      let cttsIdx = 0;
-      let cttsRem = cttsEntries[0]?.count ?? 0;
-      let currentDts = 0;
-      let sampleIdx = 0;
-      for (let chunkIdx = 0; chunkIdx < chunkOffsets.length && sampleIdx < sampleCount; chunkIdx++) {
-        const chunkNumber = chunkIdx + 1;
-        let stscEntry = stscEntries[0];
-        for (let s = 0; s < stscEntries.length; s++) {
-          if (stscEntries[s].firstChunk <= chunkNumber) {
-            stscEntry = stscEntries[s];
-          } else {
-            break;
-          }
-        }
-        let byteCursor = chunkOffsets[chunkIdx];
-        for (let sInChunk = 0; sInChunk < stscEntry.samplesPerChunk && sampleIdx < sampleCount; sInChunk++) {
-          const size = uniformSampleSize > 0 ? uniformSampleSize : sampleSizes[sampleIdx] ?? 0;
-          while (sttsRem <= 0 && sttsIdx + 1 < sttsEntries.length) {
-            sttsIdx++;
-            sttsRem = sttsEntries[sttsIdx].count;
-          }
-          const delta = sttsEntries[sttsIdx]?.delta ?? 1024;
-          if (sttsRem > 0) sttsRem--;
-          let cts = 0;
-          if (cttsEntries.length > 0) {
-            while (cttsRem <= 0 && cttsIdx + 1 < cttsEntries.length) {
-              cttsIdx++;
-              cttsRem = cttsEntries[cttsIdx].count;
-            }
-            cts = cttsEntries[cttsIdx]?.offset ?? 0;
-            if (cttsRem > 0) cttsRem--;
-          }
-          const dts = currentDts;
-          const pts = dts + cts;
-          currentDts += delta;
-          const sampleOneBased = sampleIdx + 1;
-          const isKeyframe = stssBox === void 0 ? true : syncSamples.size === 0 ? sampleOneBased === 1 : syncSamples.has(sampleOneBased);
-          const safeStart = Math.max(0, Math.min(bytes.byteLength, byteCursor));
-          const safeEnd = Math.max(safeStart, Math.min(bytes.byteLength, safeStart + size));
-          let samplePayload = bytes.subarray(safeStart, safeEnd);
-          if (type === "subtitle" && samplePayload.byteLength >= 2) {
-            const textLen = samplePayload[0] << 8 | samplePayload[1];
-            if (textLen === 0) {
-              byteCursor += size;
-              sampleIdx++;
-              continue;
-            }
-            if (2 + textLen <= samplePayload.byteLength) {
-              samplePayload = samplePayload.subarray(2, 2 + textLen);
-            }
-          }
-          samples.push({
-            data: samplePayload,
-            dts,
-            pts,
-            cts,
-            duration: delta,
-            size: samplePayload.byteLength,
-            isKeyframe,
-            sampleDescriptionIndex: stscEntry.sampleDescriptionIndex
-          });
-          byteCursor += size;
-          sampleIdx++;
-        }
+    const samples = [], syncSamples = /* @__PURE__ */ new Set();
+    const steps = mp4SampleTableSteps(bytes.length, tables, { type, budget });
+    let answer;
+    for (; ; ) {
+      const next = steps.next(answer);
+      if (next.done) break;
+      const step = next.value;
+      answer = void 0;
+      if (step.kind === "read") answer = bytes.subarray(step.offset, step.offset + step.length);
+      else if (step.kind === "sync-add") syncSamples.add(step.sample);
+      else if (step.kind === "sync-has") answer = syncSamples.has(step.sample);
+      else {
+        const { offset, ...sample } = step.sample;
+        samples.push({ ...sample, data: bytes.subarray(offset, offset + sample.size) });
       }
     }
     if (moofBoxes.length > 0) {
@@ -336129,10 +336066,9 @@ function serializeOggFlac(doc) {
   }
   return concatBytes(pages);
 }
-function oggCrc(bytes) {
-  let crc2 = 0;
+function oggCrc(bytes, crc2 = 0, offset = 0) {
   for (let i = 0; i < bytes.length; i++) {
-    const byte = i >= 22 && i < 26 ? 0 : bytes[i];
+    const byte = offset + i >= 22 && offset + i < 26 ? 0 : bytes[i];
     crc2 ^= byte << 24;
     for (let bit = 0; bit < 8; bit++) crc2 = crc2 << 1 ^ (crc2 & 2147483648 ? 79764919 : 0);
   }
@@ -336192,6 +336128,68 @@ function serializeOgg(doc, options = {}) {
   }
   return concatBytes(pages);
 }
+async function readOggFlacHeader(source, options = {}) {
+  options.signal?.throwIfAborted();
+  if (!Number.isSafeInteger(source.size) || source.size < 0) throw new RangeError("Invalid Ogg source size");
+  const identification = new Uint8Array(51);
+  let offset = 0, packetSize = 0, firstSize = -1, payloadSize = 0, mapped = false;
+  const read = async (length) => {
+    if (length > source.size - offset) throw new Error("Truncated Ogg page");
+    const bytes = new Uint8Array(length);
+    for (let used = 0; used < length; ) {
+      options.signal?.throwIfAborted();
+      const chunk = await source.read(offset, length - used);
+      options.signal?.throwIfAborted();
+      if (!chunk.length) throw new Error("Truncated Ogg page");
+      if (chunk.length > length - used) throw new Error("Ogg source returned more bytes than requested");
+      bytes.set(chunk, used);
+      used += chunk.length;
+      offset += chunk.length;
+    }
+    await options.checkpoint?.();
+    options.signal?.throwIfAborted();
+    return bytes;
+  };
+  while (offset < source.size) {
+    const start = offset, header = await read(27);
+    if (header[0] !== 79 || header[1] !== 103 || header[2] !== 103 || header[3] !== 83) throw new Error("Invalid Ogg page");
+    const lacing = await read(header[26]);
+    let checksum = oggCrc(lacing, oggCrc(header), 27);
+    const continuation = Boolean(header[5] & 1) !== packetSize > 0;
+    let remaining = 0, chunk = new Uint8Array(), used = 0;
+    for (const length of lacing) remaining += length;
+    for (const length of lacing) {
+      for (let pending = length; pending; ) {
+        if (used === chunk.length) {
+          chunk = await read(Math.min(16384, remaining));
+          used = 0;
+          checksum = oggCrc(chunk, checksum, offset - start - chunk.length);
+          remaining -= chunk.length;
+        }
+        const take = Math.min(pending, chunk.length - used);
+        if (firstSize < 0 && packetSize < identification.length) identification.set(chunk.subarray(used, used + Math.min(take, identification.length - packetSize)), packetSize);
+        packetSize += take;
+        payloadSize += take;
+        used += take;
+        pending -= take;
+      }
+      if (length < 255) {
+        if (firstSize < 0) {
+          firstSize = packetSize;
+          mapped = firstSize >= 5 && identification[0] === 127 && identification[1] === 70 && identification[2] === 76 && identification[3] === 65 && identification[4] === 67;
+        }
+        packetSize = 0;
+      }
+    }
+    if (checksum !== new DataView(header.buffer).getUint32(22, true)) throw new Error("Ogg CRC mismatch");
+    if (continuation) throw new Error("Invalid Ogg packet continuation");
+    if (firstSize >= 0 && !mapped) return void 0;
+  }
+  if (packetSize) throw new Error("Truncated Ogg packet");
+  if (firstSize < 0) return void 0;
+  if (firstSize !== 51 || identification[5] !== 1) throw new Error("Unsupported Ogg FLAC mapping");
+  return { header: identification.subarray(9), size: payloadSize - 9 };
+}
 
 // packages/mp4-ast/src/containers/adapters.ts
 import { decodeImage, encodeImage } from "../../image-ast/portable.js";
@@ -338566,6 +338564,58 @@ function flacAst() {
     }
   };
 }
+function oggDocument(stream, size, data = new Uint8Array()) {
+  const { sampleRate, channels, samples: totalSamples, codec } = stream;
+  return {
+    containerFormat: "ogg",
+    timescale: sampleRate,
+    duration: totalSamples,
+    durationSeconds: stream.duration,
+    tracks: [
+      {
+        id: 1,
+        type: "audio",
+        handlerType: "soun",
+        timescale: sampleRate,
+        duration: totalSamples,
+        language: "und",
+        enabled: true,
+        codecDescriptions: [
+          {
+            formatFourCC: codec === "opus" ? "Opus" : "vorb",
+            codecName: codec,
+            sampleRate,
+            channels,
+            bitsPerSample: 16
+          }
+        ],
+        samples: [
+          {
+            data,
+            dts: 0,
+            pts: 0,
+            cts: 0,
+            duration: totalSamples,
+            size,
+            isKeyframe: true,
+            sampleDescriptionIndex: 1
+          }
+        ]
+      }
+    ],
+    metadata: {},
+    byteLength: size
+  };
+}
+function probeOggStreamMetadata(stream, size, options = {}) {
+  return buildProbeResultFromDoc(oggDocument(stream, size), size, options.filename ?? "input.ogg", { ...options, formatName: "ogg", formatLongName: "Ogg" });
+}
+async function probeOggFlacSource(source, options = {}) {
+  const metadata = await readOggFlacHeader(source, options);
+  if (!metadata) return void 0;
+  const doc = { ...flacDocument(metadata.header, metadata.size), containerFormat: "ogg", byteLength: source.size };
+  return buildProbeResultFromDoc(doc, source.size, options.filename ?? "input.ogg", { ...options, formatName: "ogg", formatLongName: "Ogg" });
+}
 function oggAst() {
   return {
     id: "ogg",
@@ -338590,47 +338640,7 @@ function oggAst() {
       const parsed = parseAudio(bytes);
       const stream = parsed.streams[0];
       if (!stream) throw new Error("Ogg input contains no audio stream");
-      const { sampleRate, channels, samples: totalSamples, codec } = stream;
-      return {
-        containerFormat: "ogg",
-        timescale: sampleRate,
-        duration: totalSamples,
-        durationSeconds: stream.duration,
-        tracks: [
-          {
-            id: 1,
-            type: "audio",
-            handlerType: "soun",
-            timescale: sampleRate,
-            duration: totalSamples,
-            language: "und",
-            enabled: true,
-            codecDescriptions: [
-              {
-                formatFourCC: codec === "opus" ? "Opus" : "vorb",
-                codecName: codec,
-                sampleRate,
-                channels,
-                bitsPerSample: 16
-              }
-            ],
-            samples: [
-              {
-                data: bytes,
-                dts: 0,
-                pts: 0,
-                cts: 0,
-                duration: totalSamples,
-                size: bytes.byteLength,
-                isKeyframe: true,
-                sampleDescriptionIndex: 1
-              }
-            ]
-          }
-        ],
-        metadata: {},
-        byteLength: bytes.byteLength
-      };
+      return oggDocument(stream, bytes.byteLength, bytes);
     },
     serialize: serializeOgg,
     probe(bytes, options) {
@@ -339420,6 +339430,8 @@ export {
   createSyntheticMp4,
   parseStreamingManifest,
   serializeDashDocument,
+  probeOggStreamMetadata,
+  probeOggFlacSource,
   parseSubtitleDocument,
   srtAst,
   webvttAst,

package/dist/safe-bash/command-chunks/{chunk-ENT3IV2G.js → chunk-LDW3RF7Y.js}

@@ -1,41 +1,41 @@
 import {
   remapCopiedXml
-} from "./chunk-MPUHH2KR.js";
+} from "./chunk-F762XDNG.js";
 import {
   prepareCommentImport
-} from "./chunk-TVH4JORU.js";
+} from "./chunk-6LPSKLLD.js";
 import {
   writePackageArchive
-} from "./chunk-DM2CPMB4.js";
+} from "./chunk-KBAQHE5Y.js";
 import {
   diagramContentTypes,
   diagramRelationshipKinds
-} from "./chunk-X7FA7ZD5.js";
+} from "./chunk-W3ZSWK76.js";
 import {
   readPackage
-} from "./chunk-XPD636C4.js";
+} from "./chunk-IWHNRYER.js";
 import {
   readBinary
-} from "./chunk-PNGDJA6M.js";
+} from "./chunk-NFII726L.js";
 import {
   validatePresentation
-} from "./chunk-RNSKXOG3.js";
+} from "./chunk-3GRMU7TM.js";
 import {
   parseXmlPart
-} from "./chunk-554Z6IKP.js";
+} from "./chunk-DBLQUZGN.js";
 import {
   parseContentTypes
-} from "./chunk-WJCN2IXI.js";
+} from "./chunk-ZQM37BGE.js";
 import {
   readRelationshipGraph
-} from "./chunk-ZMHEGDU2.js";
+} from "./chunk-LNTEV56A.js";
 import {
   asciiKey,
   relativePartReference
-} from "./chunk-36XGIPOG.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/slide-import.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-U27XPNLP.js → chunk-LEO4VRIN.js}

@@ -1,7 +1,7 @@
 import {
   bareAutolink,
   filterGfmHtml
-} from "./chunk-IK6K2HCG.js";
+} from "./chunk-JWORWL72.js";
 import {
   unicodePunctuation,
   unicodeWhitespace
@@ -18,7 +18,7 @@ import {
   readLabel,
   readTitle,
   whitespace
-} from "./chunk-7ZWACKCG.js";
+} from "./chunk-T6OXG7QQ.js";
 
 // packages/safe-bash-markdown-engine/src/commonmark-inlines.ts
 function attr() {

package/dist/safe-bash/command-chunks/{chunk-GZ3VIWNN.js → chunk-LKGTH2Q7.js}

@@ -1,20 +1,20 @@
 import {
   openDocumentLocations,
   resolveDocxSelection
-} from "./chunk-UZL7G57V.js";
-import {
-  validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   pathContains,
   tableGridCount
-} from "./chunk-MTWZEPAR.js";
+} from "./chunk-47IAU25U.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DZH54L3F.js";
 import {
   tableRows
-} from "./chunk-ML5R5JML.js";
+} from "./chunk-KY4LCHUF.js";
 import {
   UnsupportedEditError
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   MarkupCompatibility,
   documentCompatibilityProfile

package/dist/safe-bash/command-chunks/{chunk-ZMHEGDU2.js → chunk-LNTEV56A.js}

@@ -4,11 +4,11 @@ import {
   partName,
   relativePartReference,
   resolvePartReference
-} from "./chunk-36XGIPOG.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError,
   resolveOfficeResources
-} from "./chunk-Q73EMLLZ.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/relationship-owner.ts
 function relationshipOwner(name) {