@poe-platform/safe-bash 0.1.813 → 0.1.815

package/dist/safe-bash/command-chunks/{chunk-TY4WDAHM.js → chunk-MYZ46FQL.js}

@@ -1,6 +1,6 @@
 import {
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   documentDialects
 } from "./chunk-WLANDWNW.js";

package/dist/safe-bash/command-chunks/{chunk-TBAIMDGL.js → chunk-N4MUBJCT.js}

@@ -1,7 +1,7 @@
 import {
   DocumentXmlEditor,
   UnsupportedEditError
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   commentExtensionParts,
   dialectForNamespace,

package/dist/safe-bash/command-chunks/{chunk-NPLVFAD6.js → chunk-N6G3345Q.js}

@@ -1,27 +1,27 @@
 import {
   openDocumentLocations,
   resolveDocxSelection
-} from "./chunk-UZL7G57V.js";
-import {
-  validateDocxInvocation
-} from "./chunk-GXLXWZWH.js";
+} from "./chunk-CKEMZUE3.js";
 import {
   hyperlinkHistory
 } from "./chunk-DGBQ7QDE.js";
 import {
   paragraphTextRun
-} from "./chunk-CU4DLVME.js";
+} from "./chunk-BLIFGBIO.js";
 import {
   findRelationshipPart
 } from "./chunk-UIX3CASN.js";
 import {
   LocationIndex,
   addressKey
-} from "./chunk-MTWZEPAR.js";
+} from "./chunk-47IAU25U.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DZH54L3F.js";
 import {
   assertDocumentEditable,
   publishDocumentArchive
-} from "./chunk-PZMU3Z4L.js";
+} from "./chunk-EVYKV3QI.js";
 import {
   DocumentPackage
 } from "./chunk-5BUL25DF.js";
@@ -32,7 +32,7 @@ import {
   editActiveRelationshipXml,
   runElementOpen,
   xmlValue
-} from "./chunk-4H3TYOVC.js";
+} from "./chunk-Y7AXMCFV.js";
 import {
   relationshipXmlIds,
   relationshipXmlRows

package/dist/safe-bash/command-chunks/{chunk-4PBNMKAT.js → chunk-NEMUPUUB.js}

@@ -1,26 +1,26 @@
 import {
   readShape
-} from "./chunk-HVW53ARH.js";
+} from "./chunk-TKCUGMRZ.js";
 import {
   projectShapePoint
-} from "./chunk-3Y4XZB24.js";
+} from "./chunk-RTNI47C5.js";
 import {
   Length
-} from "./chunk-6SRHWVEB.js";
+} from "./chunk-2VVJRVYM.js";
 import {
   attr,
   child,
   required
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   parseXmlPart
-} from "./chunk-7PRL6RJ6.js";
+} from "./chunk-DBLQUZGN.js";
 import {
   ValueError
-} from "./chunk-D55REQA3.js";
+} from "./chunk-JUHOL5KB.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/connectors.ts
 var connectorValues = { STRAIGHT: 1, ELBOW: 2, CURVE: 3, MIXED: -2 };

package/dist/safe-bash/command-chunks/{chunk-MUUWBZIC.js → chunk-NEVQWOU6.js}

@@ -2,39 +2,39 @@ import {
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-EJTNVXWF.js";
+} from "./chunk-MVLVIMJ6.js";
 import {
   readShape
-} from "./chunk-HVW53ARH.js";
+} from "./chunk-TKCUGMRZ.js";
 import {
   applyDrawingUpdate,
   readDrawingFormat,
   validateDrawingUpdate
-} from "./chunk-BEHUSUOY.js";
+} from "./chunk-PLMF35XK.js";
 import {
   readShapeGeometry
-} from "./chunk-3Y4XZB24.js";
+} from "./chunk-RTNI47C5.js";
 import {
   escape,
   loadShared,
   nextRel,
   relPart
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   SelectionError
-} from "./chunk-O675URF4.js";
+} from "./chunk-W3ZSWK76.js";
 import {
   readBinary
-} from "./chunk-LD7BONZY.js";
+} from "./chunk-NFII726L.js";
 import {
   parseXmlPart
-} from "./chunk-7PRL6RJ6.js";
+} from "./chunk-DBLQUZGN.js";
 import {
   relativePartReference
-} from "./chunk-U5TWQFZY.js";
+} from "./chunk-WTVJLHMG.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 import {
   crc32
 } from "./chunk-IOEUZ4EA.js";

package/dist/safe-bash/command-chunks/{chunk-7NXTEWPR.js → chunk-NEYITAAO.js}

@@ -332830,15 +332830,8 @@ 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.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 +332850,163 @@ 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/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-fragment-source.ts
+function mp4FragmentHeader(bytes, options) {
+  if (bytes.length < 8) return;
+  const reader = new BinaryReader(bytes);
+  reader.readU8();
+  const flags = reader.readU24BE(), trackId = reader.readU32BE();
+  if (trackId !== options.trackId) return;
+  return {
+    baseDataOffset: flags & 1 ? reader.readU64BE() : options.moofOffset,
+    defaultSampleDescriptionIndex: flags & 2 ? reader.readU32BE() : options.defaults.defaultSampleDescriptionIndex,
+    defaultSampleDuration: flags & 8 ? reader.readU32BE() : options.defaults.defaultSampleDuration,
+    defaultSampleSize: flags & 16 ? reader.readU32BE() : options.defaults.defaultSampleSize,
+    defaultSampleFlags: flags & 32 ? reader.readU32BE() : options.defaults.defaultSampleFlags
+  };
+}
+function mp4FragmentTime(bytes, fallback) {
+  if (bytes.length < 8) return fallback;
+  const reader = new BinaryReader(bytes), version = reader.readU8();
+  reader.skip(3);
+  return version === 1 ? reader.readU64BE() : reader.readU32BE();
+}
+function* mp4FragmentRunSteps(size, table, header, state, options) {
+  if (table.payloadSize < 8) return state;
+  function* read(offset, length) {
+    if (offset >= table.payloadSize || !length) return new BinaryReader(new Uint8Array());
+    return new BinaryReader(yield { kind: "read", table, offset: table.payloadOffset + offset, length: Math.min(length, table.payloadSize - offset) });
+  }
+  const reader = yield* read(0, 16), version = reader.readU8(), flags = reader.readU24BE(), count = reader.readU32BE();
+  options.budget?.checkSamples(state.sampleCount + count);
+  let cursor = header.baseDataOffset + (flags & 1 ? reader.readI32BE() : 0);
+  const firstFlags = flags & 4 ? reader.readU32BE() : void 0, start = reader.offset;
+  const width = [256, 512, 1024, 2048].reduce((n, bit) => n + (flags & bit ? 4 : 0), 0);
+  let dts = state.dts;
+  for (let i = 0; i < count; i++) {
+    options.budget?.checkCpu();
+    const row = yield* read(start + i * width, width);
+    const duration = flags & 256 ? row.readU32BE() : header.defaultSampleDuration;
+    const declaredSize = flags & 512 ? row.readU32BE() : header.defaultSampleSize;
+    const sampleFlags = flags & 1024 ? row.readU32BE() : i === 0 && firstFlags !== void 0 ? firstFlags : header.defaultSampleFlags;
+    const cts = flags & 2048 ? version === 1 ? row.readI32BE() : row.readU32BE() : 0;
+    const offset = Math.max(0, Math.min(size, cursor));
+    const isKeyframe = (sampleFlags >>> 24 & 3) === 2 || !(sampleFlags & 65536) && (i === 0 || options.type !== "video");
+    yield { kind: "sample", sample: { offset, size: Math.max(0, Math.min(size - offset, declaredSize)), dts, pts: dts + cts, cts, duration, isKeyframe, sampleDescriptionIndex: header.defaultSampleDescriptionIndex } };
+    dts += duration;
+    cursor += declaredSize;
+  }
+  return { dts, sampleCount: state.sampleCount + count };
+}
+
+// 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 +333018,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 +333476,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 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 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 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) {
@@ -333524,64 +333510,32 @@ function parseMp4(bytes, options = {}) {
         for (const traf of trafBoxes) {
           const tfhd = findBox(traf.children, "tfhd");
           if (!tfhd || tfhd.payload.byteLength < 8) continue;
-          const tfhdReader = new BinaryReader(tfhd.payload);
-          tfhdReader.readU8();
-          const tfhdFlags = tfhdReader.readU24BE();
-          const trafTrackId = tfhdReader.readU32BE();
-          if (trafTrackId !== trackId) continue;
-          let baseDataOffset = moof.offset;
-          let defaultSampleDescriptionIndex = trex.defaultSampleDescriptionIndex;
-          let defaultSampleDuration = trex.defaultSampleDuration;
-          let defaultSampleSize = trex.defaultSampleSize;
-          let defaultSampleFlags = trex.defaultSampleFlags;
-          if (tfhdFlags & 1) baseDataOffset = tfhdReader.readU64BE();
-          if (tfhdFlags & 2) defaultSampleDescriptionIndex = tfhdReader.readU32BE();
-          if (tfhdFlags & 8) defaultSampleDuration = tfhdReader.readU32BE();
-          if (tfhdFlags & 16) defaultSampleSize = tfhdReader.readU32BE();
-          if (tfhdFlags & 32) defaultSampleFlags = tfhdReader.readU32BE();
+          const fragmentOptions = { trackId, moofOffset: moof.offset, defaults: trex, type, budget };
+          const header = mp4FragmentHeader(tfhd.payload, fragmentOptions);
+          if (!header) continue;
           const tfdt = findBox(traf.children, "tfdt");
-          if (tfdt && tfdt.payload.byteLength >= 8) {
-            const tfdtReader = new BinaryReader(tfdt.payload);
-            const tfdtVersion = tfdtReader.readU8();
-            tfdtReader.skip(3);
-            runningDts = tfdtVersion === 1 ? tfdtReader.readU64BE() : tfdtReader.readU32BE();
-          }
-          const trunBoxes = findBoxes(traf.children, "trun");
-          for (const trun of trunBoxes) {
-            if (trun.payload.byteLength < 8) continue;
-            const trunReader = new BinaryReader(trun.payload);
-            const trunVersion = trunReader.readU8();
-            const trunFlags = trunReader.readU24BE();
-            const trunSampleCount = trunReader.readU32BE();
-            budget.checkSamples(samples.length + trunSampleCount);
-            let dataOffset = baseDataOffset;
-            if (trunFlags & 1) {
-              dataOffset = baseDataOffset + trunReader.readI32BE();
-            }
-            const firstSampleFlags = trunFlags & 4 ? trunReader.readU32BE() : void 0;
-            let cursor = dataOffset;
-            for (let s = 0; s < trunSampleCount; s++) {
-              const duration = trunFlags & 256 ? trunReader.readU32BE() : defaultSampleDuration;
-              const size = trunFlags & 512 ? trunReader.readU32BE() : defaultSampleSize;
-              const flags = trunFlags & 1024 ? trunReader.readU32BE() : s === 0 && firstSampleFlags !== void 0 ? firstSampleFlags : defaultSampleFlags;
-              const cts = trunFlags & 2048 ? trunVersion === 1 ? trunReader.readI32BE() : trunReader.readU32BE() : 0;
-              const isNonSync = (flags & 65536) !== 0;
-              const sampleDependsOn = flags >>> 24 & 3;
-              const isKeyframe = sampleDependsOn === 2 || !isNonSync && (s === 0 || type !== "video");
-              const safeStart = Math.max(0, Math.min(bytes.byteLength, cursor));
-              const safeEnd = Math.max(safeStart, Math.min(bytes.byteLength, safeStart + size));
-              samples.push({
-                data: bytes.subarray(safeStart, safeEnd),
-                dts: runningDts,
-                pts: runningDts + cts,
-                cts,
-                duration,
-                size: safeEnd - safeStart,
-                isKeyframe,
-                sampleDescriptionIndex: defaultSampleDescriptionIndex
-              });
-              runningDts += duration;
-              cursor += size;
+          if (tfdt) runningDts = mp4FragmentTime(tfdt.payload, runningDts);
+          for (const trun of findBoxes(traf.children, "trun")) {
+            const steps2 = mp4FragmentRunSteps(
+              bytes.byteLength,
+              { payloadOffset: trun.offset + trun.headerSize, payloadSize: trun.payload.byteLength },
+              header,
+              { dts: runningDts, sampleCount: samples.length },
+              fragmentOptions
+            );
+            let answer2;
+            for (; ; ) {
+              const next = steps2.next(answer2);
+              if (next.done) {
+                runningDts = next.value.dts;
+                break;
+              }
+              const step = next.value;
+              if (step.kind === "read") answer2 = bytes.subarray(step.offset, step.offset + step.length);
+              else if (step.kind === "sample") {
+                const { offset, ...sample } = step.sample;
+                samples.push({ ...sample, data: bytes.subarray(offset, offset + sample.size) });
+              }
             }
           }
         }

package/dist/safe-bash/command-chunks/{chunk-KZ5ODST6.js → chunk-NFGCBQN3.js}

@@ -1,10 +1,10 @@
 import {
   attr,
   child
-} from "./chunk-2Z3WRRFT.js";
+} from "./chunk-ADHFF2IM.js";
 import {
   OfficeError
-} from "./chunk-X6RHJ6YN.js";
+} from "./chunk-CXME4YHU.js";
 
 // packages/safe-bash-presentation-engine/src/shape-paths.ts
 import { SaxesParser } from "saxes";