@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/command-chunks/{chunk-KMCZ6P4O.js → chunk-KQLD3AED.js}

@@ -1,12 +1,15 @@
+import {
+  extendedPattern
+} from "./chunk-CQTRW45K.js";
 import {
   describe
-} from "./chunk-YZ5SVZFD.js";
+} from "./chunk-KXU3IRUO.js";
 import {
   JqError,
   JqLimitError,
   object,
   put
-} from "./chunk-VVI4Z73I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   utf8ByteLength
 } from "./chunk-PDKXAR4Y.js";
@@ -18,7 +21,7 @@ import {
 init_buffer();
 import { Pattern } from "../../safe-bash-regex-engine/text/regex.js";
 import { ProgramError } from "../../safe-bash-regex-engine/text/budget.js";
-async function* substituteRegex(input, source, flags, replacement, budget) {
+async function* substituteRegex(input, source, flags, replacement, budget, global = true) {
   if (typeof input !== "string") throw new JqError(`${describe(input, budget)} cannot be matched, as it is not a string`);
   if (typeof source !== "string") throw new JqError(`${describe(source, budget)} is not a string`);
   if (typeof flags !== "string" || [...flags].some((flag) => !"gimns".includes(flag))) throw new JqError(`${typeof flags === "string" ? flags + "g" : describe(flags, budget)} is not a valid modifier string`);
@@ -58,6 +61,7 @@ async function* substituteRegex(input, source, flags, replacement, budget) {
         results = next;
         copied = match.end;
       }
+      if (!global && !flags.includes("g")) break;
       search = match.end > match.start ? match.end : match.end + ((input.codePointAt(match.end) ?? 0) > 65535 ? 2 : 1);
     }
     for (const prefix of results) {
@@ -76,10 +80,11 @@ function regexError(error) {
   const message = error.message === "unterminated bracket expression" ? "premature end of char-class" : error.message === "unmatched '(' in regular expression" ? "end pattern with unmatched parenthesis" : error.message === "quantifier without an expression" ? "target of repeat operator is not specified" : error.message === "reversed character range" ? "empty range in char class" : error.message;
   return new JqError(`Regex failure: ${message}`);
 }
-async function* scanRegex(input, source, budget) {
+async function* scanRegex(input, source, budget, modifiers = null) {
+  const flags = regexFlags(modifiers, budget);
   if (typeof source !== "string") throw new JqError(`${describe(source, budget)} is not a string`);
   if (typeof input !== "string") throw new JqError(`${describe(input, budget)} cannot be matched, as it is not a string`);
-  if (source === "") {
+  if (source === "" && !flags.includes("n")) {
     const boundaries = utf8ByteLength(input) + 1;
     for (let index = 0; index < boundaries; index++) {
       {
@@ -93,7 +98,7 @@ async function* scanRegex(input, source, budget) {
   const work = { step: (count = 1) => budget.step(count), checkpoint: () => budget.tick(0), maxBufferBytes: budget.limits.maxValueBytes };
   try {
     budget.step(source.length);
-    const pattern = new Pattern(source, true, false, "jq");
+    const pattern = new Pattern(flags.includes("x") ? await extendedPattern(source, budget) : source, true, flags.includes("i"), "jq", flags.includes("p") ? flags + "m" : flags);
     let search = 0;
     while (search <= input.length) {
       const match = await pattern.find(input, work, search);
@@ -108,9 +113,65 @@ async function* scanRegex(input, source, budget) {
     throw regexError(error);
   }
 }
+function regexFlags(modifiers, budget) {
+  if (modifiers !== null && typeof modifiers !== "string") throw new JqError(`${describe(modifiers, budget)} is not a string`);
+  const flags = modifiers ?? "";
+  if ([...flags].some((flag) => !"gimnpsx".includes(flag))) throw new JqError(`${flags} is not a valid modifier string`);
+  return flags;
+}
+async function* matchRegex(input, source, modifiers, budget, test) {
+  if (typeof input !== "string") throw new JqError(`${describe(input, budget)} cannot be matched, as it is not a string`);
+  if (typeof source !== "string") throw new JqError(`${describe(source, budget)} is not a string`);
+  const flags = regexFlags(modifiers, budget);
+  const work = { step: (count = 1) => budget.step(count), checkpoint: () => budget.tick(0), maxBufferBytes: budget.limits.maxValueBytes };
+  try {
+    budget.step(source.length + input.length);
+    const pattern = new Pattern(flags.includes("x") ? await extendedPattern(source, budget) : source, true, flags.includes("i"), "jq", flags.includes("p") ? flags + "m" : flags);
+    let search = 0;
+    while (search <= input.length) {
+      const match = await pattern.find(input, work, search);
+      if (!match) {
+        if (test) yield false;
+        return;
+      }
+      if (test) {
+        yield true;
+        return;
+      }
+      const position = (start, end) => {
+        budget.step(end + start);
+        return { offset: [...input.slice(0, start)].length, length: [...input.slice(start, end)].length, string: input.slice(start, end) };
+      };
+      const names = new Map([...pattern.groupNames].map(([name, index]) => [index, name]));
+      const captures = [];
+      budget.collection(pattern.groupCount);
+      for (let index = 1; index <= pattern.groupCount; index++) {
+        const start = match.captureOffsets?.[index * 2];
+        const end = match.captureOffsets?.[index * 2 + 1];
+        captures.push({ ...start === void 0 || end === void 0 ? { offset: -1, length: 0, string: null } : position(start, end), name: names.get(index) ?? null });
+      }
+      const result = { ...position(match.start, match.end), captures };
+      budget.value(result);
+      yield result;
+      if (!flags.includes("g")) return;
+      if (source === "" && match.end < input.length) {
+        const character = String.fromCodePoint(input.codePointAt(match.end));
+        for (let repeat = 1; repeat < utf8ByteLength(character); repeat++) {
+          await budget.tick();
+          yield { offset: result.offset + 1, length: 0, string: "", captures: [] };
+        }
+      }
+      search = match.end > match.start ? match.end : match.end + ((input.codePointAt(match.end) ?? 0) > 65535 ? 2 : 1);
+    }
+  } catch (error) {
+    throw regexError(error);
+  }
+}
 
 export {
   substituteRegex,
   regexError,
-  scanRegex
+  scanRegex,
+  regexFlags,
+  matchRegex
 };

package/dist/safe-bash/command-chunks/chunk-KWESKQHR.js

@@ -0,0 +1,25 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/deadline.ts
+init_buffer();
+function scheduleNetworkDeadline(milliseconds, expire) {
+  const deadline = performance.now() + milliseconds;
+  let timer;
+  let closed = false;
+  const arm = () => {
+    if (closed || !Number.isFinite(deadline)) return;
+    const remaining = deadline - performance.now();
+    timer = setTimeout(remaining > 2147483647 ? arm : expire, Math.max(0, Math.min(remaining, 2147483647)));
+  };
+  arm();
+  return () => {
+    closed = true;
+    clearTimeout(timer);
+  };
+}
+
+export {
+  scheduleNetworkDeadline
+};

package/dist/safe-bash/command-chunks/{chunk-YZ5SVZFD.js → chunk-KXU3IRUO.js}

@@ -1,10 +1,10 @@
 import {
   splitString
-} from "./chunk-UI32HWGS.js";
+} from "./chunk-HMOZ6XVJ.js";
 import {
   jsonFragments,
   renderJsonFragment
-} from "./chunk-5ZSM4UFN.js";
+} from "./chunk-WECIOOQB.js";
 import {
   JqError,
   JqLimitError,
@@ -14,7 +14,7 @@ import {
   objectKeyIterator,
   objectKeys,
   put
-} from "./chunk-VVI4Z73I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   decoder,
   encoder,

package/dist/safe-bash/command-chunks/{chunk-C7IHMJEW.js → chunk-KZC5UWFF.js}

@@ -1,7 +1,7 @@
 import {
   bareAutolink,
   filterGfmHtml
-} from "./chunk-G4PNVO6Z.js";
+} from "./chunk-KP7AO66M.js";
 import {
   asciiPunctuation,
   decodeSyntax,
@@ -14,7 +14,7 @@ import {
   readLabel,
   readTitle,
   whitespace
-} from "./chunk-2ENZ6JGA.js";
+} from "./chunk-KEV7C3KH.js";
 import {
   unicodePunctuation,
   unicodeWhitespace

package/dist/safe-bash/command-chunks/{chunk-2WRTLCGK.js → chunk-LAOM65EE.js}

@@ -1,14 +1,14 @@
-import {
-  cell,
-  widthOf
-} from "./chunk-NI7MKJPN.js";
 import {
   jsonOutput,
   tableOutput
-} from "./chunk-WDHI3S6Y.js";
+} from "./chunk-4OOUQTQO.js";
 import {
   usage
 } from "./chunk-AHEQ2THG.js";
+import {
+  cell,
+  widthOf
+} from "./chunk-MTQH74CF.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-LE5LZNHE.js

@@ -0,0 +1,204 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/zip64.ts
+init_buffer();
+import { fail } from "../../safe-bash-io-engine/commands/archive/internal.js";
+function wide(view, offset) {
+  if (offset < 0 || offset + 8 > view.byteLength) fail("ZIP64 truncated numeric field");
+  const value = view.getBigUint64(offset, true);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) fail("ZIP64 unsafe numeric field");
+  return Number(value);
+}
+function zipDiskRecord(disks, start, end) {
+  if (!disks) return;
+  let disk = disks.starts.length - 1;
+  while (disk >= 0 && disks.starts[disk] > start) disk--;
+  if (disk < 0 || end > disks.starts[disk] + disks.lengths[disk]) fail("ZIP record straddles volume boundary");
+}
+function zipDiskOffset(disks, disk, offset) {
+  if (!Number.isSafeInteger(disk) || disk < 0 || !Number.isSafeInteger(offset) || offset < 0) fail("ZIP invalid disk offset");
+  if (!disks) {
+    if (disk) fail("ZIP multi-disk archive requires a volume resolver");
+    return offset;
+  }
+  if (disk >= disks.starts.length || offset >= disks.lengths[disk]) fail("ZIP disk offset outside volume");
+  return disks.starts[disk] + offset;
+}
+function zip64Directory(view, end, limits, disks, displacement = 0) {
+  zipDiskRecord(disks, end, view.byteLength);
+  let members = view.getUint16(end + 10, true);
+  let centralSize = view.getUint32(end + 12, true);
+  let centralStart = view.getUint32(end + 16, true);
+  let centralEnd = end;
+  let zip64Disk = -1, zip64DiskMembers = -1;
+  let diskMembers = view.getUint16(end + 8, true);
+  const disk = view.getUint16(end + 4, true);
+  if (!disks && disk) fail("ZIP multi-disk archive requires a volume resolver");
+  const centralDisk = view.getUint16(end + 6, true);
+  if (disks && disk !== disks.starts.length - 1) fail("ZIP final disk number mismatch");
+  if (centralStart !== 4294967295) centralStart = zipDiskOffset(disks, centralDisk, centralStart);
+  if (centralStart !== 4294967295) centralStart += displacement;
+  const locator = end >= 20 && view.getUint32(end - 20, true) === 117853008;
+  if (locator) {
+    zipDiskRecord(disks, end - 20, end);
+    const recordDisk = view.getUint32(end - 16, true);
+    if (view.getUint32(end - 4, true) !== (disks?.starts.length ?? 1)) fail("ZIP64 multi-disk locator count mismatch");
+    centralEnd = zipDiskOffset(disks, recordDisk, wide(view, end - 12)) + displacement;
+    if (centralEnd > end - 76 || view.getUint32(centralEnd, true) !== 101075792) fail("ZIP64 invalid end-record span");
+    const length = wide(view, centralEnd + 4);
+    if (length < 44 || length - 44 > limits.maxPaxBytes || length !== end - 32 - centralEnd) fail("ZIP64 invalid end-record length");
+    zipDiskRecord(disks, centralEnd, centralEnd + 12 + length);
+    const version = view.getUint16(centralEnd + 14, true);
+    if (version < 45 || version > 46) fail("ZIP64 unsupported end-record extraction version");
+    if (view.getUint32(centralEnd + 16, true) !== recordDisk || view.getUint32(centralEnd + 20, true) !== centralDisk) fail("ZIP64 inconsistent disk numbers");
+    const count = wide(view, centralEnd + 32);
+    const wideDiskMembers = wide(view, centralEnd + 24);
+    if (wideDiskMembers > count || recordDisk === disk && wideDiskMembers !== diskMembers && diskMembers !== 65535 || members !== 65535 && members !== count || !disks && wideDiskMembers !== count) fail("ZIP64 inconsistent member count");
+    if (recordDisk === disk) diskMembers = wideDiskMembers;
+    zip64Disk = recordDisk;
+    zip64DiskMembers = wideDiskMembers;
+    const size = wide(view, centralEnd + 40);
+    const start = zipDiskOffset(disks, centralDisk, wide(view, centralEnd + 48)) + displacement;
+    if (centralSize !== 4294967295 && centralSize !== size || centralStart !== 4294967295 && centralStart !== start) fail("ZIP64 inconsistent central directory");
+    members = count;
+    centralSize = size;
+    centralStart = start;
+  } else if (centralSize === 4294967295 || centralStart === 4294967295) fail("ZIP64 missing end record and locator");
+  else if (!disks && diskMembers !== members) fail("ZIP inconsistent member count");
+  if (members > limits.maxMembers) fail("ZIP member limit exceeded");
+  if (centralStart > limits.maxArchiveBytes || centralSize > limits.maxArchiveBytes || centralSize !== centralEnd - centralStart) fail("ZIP invalid central directory span");
+  return { members, centralStart, centralSize, centralEnd, diskMembers, disk, zip64Disk, zip64DiskMembers };
+}
+function zip64Fields(data, values) {
+  let offset = 0;
+  const view = data && new DataView(data.buffer, data.byteOffset, data.byteLength);
+  return values.map((value, index) => {
+    if (value !== 4294967295) return value;
+    if (!view) fail("ZIP64 missing required extra field");
+    const width = index === 3 ? 4 : 8;
+    if (offset + width > view.byteLength) fail("ZIP64 truncated extra field");
+    const resolved = width === 4 ? view.getUint32(offset, true) : wide(view, offset);
+    offset += width;
+    return resolved;
+  });
+}
+function stripZip64(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const retained = [];
+  let length = 0;
+  for (let offset2 = 0; offset2 < bytes.length; ) {
+    if (offset2 + 4 > bytes.length) fail("ZIP truncated extra field");
+    const next = offset2 + 4 + view.getUint16(offset2 + 2, true);
+    if (next > bytes.length) fail("ZIP truncated extra field payload");
+    if (view.getUint16(offset2, true) !== 1) {
+      retained.push(bytes.subarray(offset2, next));
+      length += next - offset2;
+    }
+    offset2 = next;
+  }
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const field of retained) {
+    result.set(field, offset);
+    offset += field.length;
+  }
+  return result;
+}
+function zip64Extra(values, retained) {
+  values.forEach(counter);
+  if (retained.length + 4 + values.length * 8 > 65535) fail("ZIP64 extra field limit exceeded");
+  const bytes = new Uint8Array(4 + values.length * 8 + retained.length);
+  const view = new DataView(bytes.buffer);
+  view.setUint16(0, 1, true);
+  view.setUint16(2, values.length * 8, true);
+  values.forEach((value, index) => view.setBigUint64(4 + index * 8, BigInt(value), true));
+  bytes.set(retained, 4 + values.length * 8);
+  return bytes;
+}
+function writeZip64End(view, offset, count, size, start, recordOffset = offset) {
+  [offset, count, size, start, recordOffset].forEach(counter);
+  if (offset > view.byteLength - 76) fail("ZIP64 truncated end-record destination");
+  view.setUint32(offset, 101075792, true);
+  view.setBigUint64(offset + 4, 44n, true);
+  view.setUint16(offset + 12, 813, true);
+  view.setUint16(offset + 14, 45, true);
+  view.setUint32(offset + 16, 0, true);
+  view.setUint32(offset + 20, 0, true);
+  view.setBigUint64(offset + 24, BigInt(count), true);
+  view.setBigUint64(offset + 32, BigInt(count), true);
+  view.setBigUint64(offset + 40, BigInt(size), true);
+  view.setBigUint64(offset + 48, BigInt(start), true);
+  view.setUint32(offset + 56, 117853008, true);
+  view.setUint32(offset + 60, 0, true);
+  view.setBigUint64(offset + 64, BigInt(recordOffset), true);
+  view.setUint32(offset + 72, 1, true);
+  return offset + 76;
+}
+function counter(value) {
+  if (!Number.isSafeInteger(value) || value < 0) fail("ZIP64 unsafe or invalid numeric field");
+}
+function zip64Member(size, compressed, offset, force = false, allowed = true, forceSizes = false) {
+  [size, compressed, offset].forEach(counter);
+  const widths = [size, compressed, offset].map((value, index) => force || forceSizes && index < 2 || value >= 4294967295);
+  if (!allowed && widths.some(Boolean)) fail("ZIP64 required but disabled");
+  return {
+    size: widths[0] ? 4294967295 : size,
+    compressed: widths[1] ? 4294967295 : compressed,
+    offset: widths[2] ? 4294967295 : offset,
+    values: [size, compressed, offset].filter((_, index) => widths[index]),
+    wide: widths.some(Boolean)
+  };
+}
+function zipEnd(count, size, start, comment, force = false, allowed = true) {
+  [count, size, start].forEach(counter);
+  if (size > Number.MAX_SAFE_INTEGER - start) fail("ZIP64 unsafe directory sum");
+  if (comment.length > 65535) fail("ZIP archive comment limit exceeded");
+  const wide2 = force || count >= 65535 || size >= 4294967295 || start >= 4294967295;
+  if (wide2 && !allowed) fail("ZIP64 required but disabled");
+  const length = (wide2 ? 76 : 0) + 22 + comment.length;
+  if (start + size > Number.MAX_SAFE_INTEGER - length) fail("ZIP64 unsafe archive sum");
+  const bytes = new Uint8Array(length);
+  const view = new DataView(bytes.buffer);
+  const end = wide2 ? writeZip64End(view, 0, count, size, start, start + size) : 0;
+  view.setUint32(end, 101010256, true);
+  view.setUint16(end + 8, Math.min(count, 65535), true);
+  view.setUint16(end + 10, Math.min(count, 65535), true);
+  view.setUint32(end + 12, size >= 4294967295 ? 4294967295 : size, true);
+  view.setUint32(end + 16, start >= 4294967295 ? 4294967295 : start, true);
+  view.setUint16(end + 20, comment.length, true);
+  bytes.set(comment, end + 22);
+  return bytes;
+}
+function zipDescriptor(checksum, compressed, size, wide2, signed = true) {
+  [checksum, compressed, size].forEach(counter);
+  if (checksum > 4294967295) fail("ZIP invalid descriptor checksum");
+  if (!wide2 && (compressed >= 4294967295 || size >= 4294967295)) fail("ZIP64 descriptor required");
+  const bytes = new Uint8Array((signed ? 4 : 0) + (wide2 ? 20 : 12));
+  const view = new DataView(bytes.buffer);
+  const base = signed ? 4 : 0;
+  if (signed) view.setUint32(0, 134695760, true);
+  view.setUint32(base, checksum, true);
+  if (wide2) {
+    view.setBigUint64(base + 4, BigInt(compressed), true);
+    view.setBigUint64(base + 12, BigInt(size), true);
+  } else {
+    view.setUint32(base + 4, compressed, true);
+    view.setUint32(base + 8, size, true);
+  }
+  return bytes;
+}
+
+export {
+  zipDiskRecord,
+  zipDiskOffset,
+  zip64Directory,
+  zip64Fields,
+  stripZip64,
+  zip64Extra,
+  writeZip64End,
+  zip64Member,
+  zipEnd,
+  zipDescriptor
+};

package/dist/safe-bash/command-chunks/{chunk-HFII3QYO.js → chunk-LWS62ISU.js}

@@ -1,6 +1,6 @@
 import {
   entities
-} from "./chunk-7L24L4UO.js";
+} from "./chunk-OQU6UT6X.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -20,6 +20,7 @@ var Parser = class {
   mode = "text";
   buffer = "";
   bufferBytes = 0;
+  commentState = "start";
   quote = "";
   attributeMode = "name";
   rawName = "";
@@ -72,8 +73,17 @@ var Parser = class {
         this.rawCandidate = "";
         this.rawCandidateBytes = 0;
         this.mode = "text";
-      } else if (this.rawCandidate.length < target.length && target.startsWith((this.rawCandidate + character).toLowerCase()) || this.rawCandidate.length >= target.length && /[\t\r\n\f ]/u.test(character)) {
-        if (this.rawText === "drop" && this.rawCandidate.length >= target.length) return;
+      } else if (this.rawCandidate.length === target.length && (character === "/" || /[\t\r\n\f ]/u.test(character))) {
+        await this.flushText(true, this.rawText === "entities");
+        this.budget.check(1, this.budget.limits.maxTokenBytes - this.rawCandidateBytes, "token bytes");
+        this.buffer = this.rawCandidate + character;
+        this.bufferBytes = this.rawCandidateBytes + 1;
+        this.rawCandidate = "";
+        this.rawCandidateBytes = 0;
+        this.mode = "tag";
+        this.attributeMode = "name";
+        this.quote = "";
+      } else if (this.rawCandidate.length < target.length && target.startsWith((this.rawCandidate + character).toLowerCase())) {
         const bytes = utf8ByteLength(character);
         this.budget.check(bytes, this.budget.limits.maxTokenBytes - this.rawCandidateBytes, "token bytes");
         this.rawCandidateBytes += bytes;
@@ -240,28 +250,30 @@ var Parser = class {
   async feed(text) {
     for (let offset = 0; offset < text.length; ) {
       if (this.mode === "text") {
-        const lt = text.indexOf("<", offset);
-        const end = lt >= 0 ? lt : text.length;
+        const maximum = Math.min(
+          text.length,
+          offset + 4096 - this.bufferBytes,
+          offset + this.budget.limits.maxTokenBytes - this.bufferBytes
+        );
+        let end = offset;
+        while (end < maximum) {
+          const code = text.charCodeAt(end);
+          if (code >= 128 || code === 60) break;
+          end++;
+        }
         if (end > offset) {
-          const span = text.slice(offset, end);
-          let isAscii = true;
-          for (let i = 0; i < span.length; i++) {
-            if (span.charCodeAt(i) >= 128) {
-              isAscii = false;
-              break;
-            }
-          }
-          if (isAscii && span.length <= this.budget.limits.maxTokenBytes - this.bufferBytes) {
-            this.budget.work(span.length);
-            this.budget.check(span.length, this.budget.limits.maxTokenBytes - this.bufferBytes, "token bytes");
-            this.bufferBytes += span.length;
-            this.buffer += span;
-            if (this.bufferBytes >= 4096) await this.flushText(false);
-            offset = end;
-            continue;
+          this.budget.work(end - offset);
+          this.bufferBytes += end - offset;
+          this.buffer += text.slice(offset, end);
+          offset = end;
+          if (this.bufferBytes >= 4096) await this.flushText(false);
+          {
+            const checkpoint = this.budget.checkpoint();
+            if (checkpoint) await checkpoint;
           }
+          continue;
         }
-        if (lt === offset && offset + 2 < text.length) {
+        if (text[offset] === "<" && offset + 2 < text.length) {
           const c1 = text.charCodeAt(offset + 1);
           const isAlpha = c1 >= 65 && c1 <= 90 || c1 >= 97 && c1 <= 122;
           const c2 = text.charCodeAt(offset + 2);
@@ -298,6 +310,16 @@ var Parser = class {
         await this.rawCharacter(character);
         continue;
       }
+      if (this.mode === "comment") {
+        const state = this.commentState;
+        if (character === ">" && (state === "start" || state === "start-dash" || state === "end" || state === "bang")) {
+          this.budget.add("tokens");
+          this.mode = "text";
+        } else if (character === "-") {
+          this.commentState = state === "start" ? "start-dash" : state === "start-dash" || state === "dash" || state === "end" ? "end" : "dash";
+        } else this.commentState = character === "!" && state === "end" ? "bang" : "body";
+        continue;
+      }
       if (this.mode === "tag" && (this.buffer === "<" && !/[A-Za-z/?!]/u.test(character) || this.buffer === "</" && !/[A-Za-z]/u.test(character))) this.mode = "text";
       if (this.mode === "text" && character === "<") {
         await this.flushText(true);
@@ -311,16 +333,6 @@ var Parser = class {
       if (this.mode === "text" && bytes > this.budget.limits.maxTokenBytes - this.bufferBytes) await this.flushText(false);
       this.budget.check(bytes, this.budget.limits.maxTokenBytes - this.bufferBytes, "token bytes");
       this.bufferBytes += bytes;
-      if (this.mode === "comment") {
-        this.buffer = (this.buffer + character).slice(-3);
-        if (this.buffer === "-->") {
-          this.budget.add("tokens");
-          this.mode = "text";
-          this.buffer = "";
-          this.bufferBytes = 0;
-        }
-        continue;
-      }
       this.buffer += character;
       if (this.mode === "text") {
         if (this.bufferBytes >= 4096) await this.flushText(false);
@@ -328,7 +340,9 @@ var Parser = class {
       }
       if (this.buffer === "<!--") {
         this.mode = "comment";
+        this.commentState = "start";
         this.buffer = "";
+        this.bufferBytes = 0;
         continue;
       }
       if (this.quote) {

package/dist/safe-bash/command-chunks/{chunk-BZDDAPSV.js → chunk-LWSBAWLT.js}

@@ -1,6 +1,6 @@
 import {
   Parser
-} from "./chunk-HFII3QYO.js";
+} from "./chunk-LWS62ISU.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-MDH5T4OS.js

@@ -0,0 +1,41 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/private-address.ts
+init_buffer();
+function privateIPv4(first, second) {
+  return first === 10 || first === 127 || first === 0 || first === 169 && second === 254 || first === 192 && second === 168 || first === 172 && second >= 16 && second <= 31 || first === 100 && second >= 64 && second <= 127 || first === 198 && second >= 18 && second <= 19 || first >= 224;
+}
+function privateHostname(input) {
+  const hostname = input.toLowerCase().replace(/\.$/u, "").replace(/^\[|\]$/gu, "");
+  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "::1") return true;
+  if (hostname.includes(":")) {
+    const [prefix, suffix] = hostname.split("::");
+    const leading = prefix ? prefix.split(":") : [];
+    const trailing = suffix ? suffix.split(":") : [];
+    const hextets = new Array(8).fill(0);
+    for (let index = 0; index < leading.length; index++) hextets[index] = Number.parseInt(leading[index], 16);
+    for (let index = 0; index < trailing.length; index++) hextets[8 - trailing.length + index] = Number.parseInt(trailing[index], 16);
+    if (hextets.every((value) => value === 0)) return true;
+    const mappedIPv4 = hextets.slice(0, 5).every((value) => value === 0) && hextets[5] === 65535;
+    const translatedIPv4 = hextets.slice(0, 4).every((value) => value === 0) && hextets[4] === 65535 && hextets[5] === 0;
+    const nat64IPv4 = hextets[0] === 100 && hextets[1] === 65435 && hextets.slice(2, 6).every((value) => value === 0);
+    const compatibleIPv4 = hextets.slice(0, 6).every((value) => value === 0);
+    if (mappedIPv4 || translatedIPv4 || nat64IPv4 || compatibleIPv4) {
+      return privateIPv4(hextets[6] >>> 8, hextets[6] & 255);
+    }
+    if (hextets[0] === 8194) return privateIPv4(hextets[1] >>> 8, hextets[1] & 255);
+    return (hextets[0] & 65024) === 64512 || (hextets[0] & 65472) === 65152 || (hextets[0] & 65472) === 65216 || (hextets[0] & 65280) === 65280 || hextets[0] === 100 && hextets[1] === 65435 && hextets[2] === 1;
+  }
+  const parts = hostname.split(".");
+  if (parts.length !== 4 || parts.some((part) => !part || Array.from(part).some((character) => character < "0" || character > "9"))) return false;
+  const octets = parts.map(Number);
+  if (octets.some((value) => value < 0 || value > 255)) return false;
+  const [first, second] = octets;
+  return privateIPv4(first, second);
+}
+
+export {
+  privateHostname
+};

package/dist/safe-bash/command-chunks/{chunk-X7TM3AKW.js → chunk-MIXBO6U7.js}

@@ -1,15 +1,18 @@
-import {
-  contents
-} from "./chunk-J34TZVMW.js";
 import {
   parse
-} from "./chunk-44AHAB5O.js";
+} from "./chunk-BDSMROQZ.js";
+import {
+  contents
+} from "./chunk-ALDC4XP4.js";
 import {
   FileFailure,
   PatchError,
   Work,
   diagnostic
 } from "./chunk-4PX2KMUK.js";
+import {
+  settings
+} from "./chunk-4HZISH3R.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -41,6 +44,7 @@ var Invocation = class {
   initial = /* @__PURE__ */ new Map();
   ordinal;
   fs;
+  inputBytes = 0;
   async confine(files) {
     if (!this.fs.confineExtraction) throw new PatchError("filesystem does not support race-safe patch mutations");
     if (!this.fs.writeFileConditional || !this.fs.removeFileConditional) throw new PatchError("filesystem does not support conditional patch mutations");
@@ -66,7 +70,8 @@ var Invocation = class {
     if (context.args.length > 1) throw new PatchError("expected stdin or one literal patch argument", 2);
     if (context.args.length === 1) {
       const text = context.args[0];
-      await work.utf8(text, work.limits.maxPatchBytes, 2);
+      const bytes2 = await work.utf8(text, work.limits.maxPatchBytes, 2);
+      context.inputBudget?.check(this.inputBytes += bytes2);
       return text;
     }
     const chunks = [];
@@ -74,6 +79,7 @@ var Invocation = class {
     for await (const chunk of readBytes(context.stdin, context.signal)) {
       work.count("maxInputChunks", 1);
       if (chunk.byteLength > work.limits.maxPatchBytes - bytes) throw new PatchError("maxPatchBytes limit exceeded");
+      context.inputBudget?.check(this.inputBytes += chunk.byteLength);
       await work.charge(1);
       if (chunk.byteLength) chunks.push(await work.copy(chunk));
       bytes += chunk.byteLength;
@@ -133,10 +139,11 @@ var Invocation = class {
     }
   }
   async read(path) {
-    const maximum = Math.min(this.work.limits.maxFileBytes, this.work.remaining("maxReadBytes"));
+    const maximum = Math.min(this.work.limits.maxFileBytes, this.work.remaining("maxReadBytes"), (this.context.inputBudget?.maxBytes ?? Infinity) - this.inputBytes);
     const bytes = await this.work.fs(path, () => this.fs.readFile(path, { signal: this.context.signal, ...Number.isFinite(maximum) ? { maxBytes: maximum } : {} }));
     if (!(bytes instanceof Uint8Array)) throw new TypeError("FileSystem.readFile must return Uint8Array");
     if (bytes.length > maximum) throw new PatchError("target read byte limit exceeded");
+    this.context.inputBudget?.check(this.inputBytes += bytes.length);
     this.work.count("maxReadBytes", bytes.length);
     return this.work.copy(bytes);
   }
@@ -274,7 +281,13 @@ var Invocation = class {
   }
 };
 function execute(context, limits) {
-  return new Invocation(context, limits).run();
+  const profile = context.capabilities?.commandLimits?.applyPatch;
+  const effective = { ...limits };
+  if (profile) {
+    settings({ limits: profile });
+    for (const key of Object.keys(profile)) effective[key] = Math.min(effective[key], profile[key]);
+  }
+  return new Invocation(context, effective).run();
 }
 
 export {