@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/command-chunks/{chunk-63R3FEZJ.js → chunk-AIV5BF5W.js}

@@ -12,7 +12,7 @@ import {
   parseExpression,
   quoteNativeSheet,
   serializeExpression
-} from "./chunk-DWFLVJC6.js";
+} from "./chunk-CCRHMAU5.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-AYUTO323.js → chunk-AKJG2XD3.js}

@@ -4,6 +4,7 @@ import {
 
 // packages/safe-bash-command-file/src/shared.ts
 init_buffer();
+import { subscribeAbort } from "../../safe-bash-contracts/index.js";
 import { utf8ByteLength } from "../../safe-bash-byte-engine/index.js";
 import { inheritYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
 import { writeBytes } from "../../safe-bash-contracts/index.js";
@@ -33,23 +34,6 @@ var FileLimitError = class extends FileFailure {
 };
 var utf8Encoder = new TextEncoder();
 var printableAsciiNoBackslash = /^[\x20-\x5b\x5d-\x7e]*$/;
-var hostAbortWaiters = /* @__PURE__ */ new WeakMap();
-function subscribeHostAbort(signal, fn) {
-  let waiters = hostAbortWaiters.get(signal);
-  if (!waiters) {
-    waiters = /* @__PURE__ */ new Set();
-    hostAbortWaiters.set(signal, waiters);
-    signal.addEventListener("abort", () => {
-      const current = Array.from(waiters);
-      waiters.clear();
-      for (let i = 0; i < current.length; i++) current[i]();
-    }, { once: true });
-  }
-  waiters.add(fn);
-  return () => {
-    waiters.delete(fn);
-  };
-}
 var SharedBudget = class {
   constructor(context, limits) {
     this.context = context;
@@ -179,7 +163,7 @@ var SharedBudget = class {
   async host(operation) {
     this.checkTime();
     return new Promise((resolve, reject) => {
-      const unsubscribe = subscribeHostAbort(this.signal, () => reject(this.signal.reason));
+      const unsubscribe = subscribeAbort(this.signal, () => reject(this.signal.reason));
       try {
         Promise.resolve(operation()).then((result) => {
           unsubscribe();

package/dist/safe-bash/command-chunks/{chunk-J34TZVMW.js → chunk-ALDC4XP4.js}

@@ -67,7 +67,6 @@ async function encode(lines, work) {
 async function contents(file, original, work) {
   if (file.kind === "delete") return void 0;
   if (file.kind === "add") {
-    work.count("maxLines", file.added.length);
     const added = [];
     for (const text2 of file.added) {
       work.step();
@@ -114,11 +113,9 @@ async function contents(file, original, work) {
     for (const line of hunk.lines) {
       work.step();
       if (line.kind === " ") {
-        work.count("maxLines", 1);
         replacement.push({ ...old[matched++] });
       } else if (line.kind === "-") matched++;
       else {
-        work.count("maxLines", 1);
         replacement.push({ text: line.text, ending });
       }
       await work.checkpoint();
@@ -133,7 +130,6 @@ async function contents(file, original, work) {
     if (replacement.start < position) throw new PatchError("overlapping update hunks");
     while (position < replacement.start) {
       work.step();
-      work.count("maxLines", 1);
       result.push({ ...old[position++] });
       await work.checkpoint();
     }
@@ -146,7 +142,6 @@ async function contents(file, original, work) {
   }
   while (position < old.length) {
     work.step();
-    work.count("maxLines", 1);
     result.push({ ...old[position++] });
     await work.checkpoint();
   }

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

@@ -0,0 +1,105 @@
+import {
+  flags
+} from "./chunk-UG7SMZFF.js";
+import {
+  expandTabs
+} from "./chunk-6F4XCVON.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-diff/src/sync.ts
+init_buffer();
+var syncDiffDecoder = new TextDecoder("utf-8", { fatal: false });
+function normalizeSyncDiffLines(text, opts) {
+  const rawLines = [];
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) {
+      rawLines.push(text.slice(start, i + 1));
+      start = i + 1;
+    }
+  }
+  if (start < text.length) rawLines.push(text.slice(start));
+  const out = [];
+  for (let i = 0; i < rawLines.length; i++) {
+    let line = rawLines[i];
+    if (opts.stripTrailingCr && line.endsWith("\r\n")) {
+      line = line.slice(0, -2) + "\n";
+    } else if (opts.stripTrailingCr && line.endsWith("\r")) {
+      line = line.slice(0, -1);
+    }
+    let body = line.endsWith("\n") ? line.slice(0, -1) : line;
+    if (opts.ignoreTabs) body = expandTabs(body);
+    if (opts.whitespace !== "exact") {
+      body = body.replace(/[ \t\v\f\r]+/gu, opts.whitespace === "all" ? "" : " ");
+    }
+    if (opts.ignoreTrailing || opts.whitespace !== "exact") {
+      body = body.replace(/[ \t\v\f\r]+$/u, "");
+    }
+    if (opts.ignoreCase) {
+      body = body.replace(/[A-Z]/gu, (letter) => letter.toLowerCase());
+    }
+    if (opts.ignoreBlank && body === "") continue;
+    const suffix = opts.whitespace !== "exact" || opts.ignoreTrailing || opts.ignoreTabs ? "" : line.endsWith("\n") ? "\n" : "";
+    out.push(body + suffix);
+  }
+  return out;
+}
+function evalSyncDiff(stdinBytes, args, readFile) {
+  let opts;
+  try {
+    opts = flags(args);
+  } catch {
+    return void 0;
+  }
+  const pairFiles = opts.fromFile !== void 0 && opts.toFile === void 0 && opts.files.length === 1 ? [opts.fromFile, opts.files[0]] : opts.toFile !== void 0 && opts.fromFile === void 0 && opts.files.length === 1 ? [opts.files[0], opts.toFile] : opts.fromFile === void 0 && opts.toFile === void 0 && opts.files.length === 2 ? [opts.files[0], opts.files[1]] : void 0;
+  if (!pairFiles || opts.recursive || opts.paginate || opts.format === "side" && !opts.suppressCommon || opts.format === "ifdef") {
+    return void 0;
+  }
+  const left = pairFiles[0];
+  const right = pairFiles[1];
+  if (left === "-" && right === "-") return opts.reportSame ? `Files ${opts.labels[0] ?? left} and ${opts.labels[1] ?? right} are identical
+` : "";
+  const resolveOperand = (op) => {
+    if (op === "-" || op === "/dev/stdin" || op === "/dev/fd/0") return stdinBytes;
+    if (!readFile) return void 0;
+    return readFile(op);
+  };
+  const b1 = resolveOperand(left);
+  const b2 = resolveOperand(right);
+  if (!b1 || !b2) return void 0;
+  let same = false;
+  if (b1.byteLength === b2.byteLength) {
+    same = true;
+    for (let i = 0; i < b1.byteLength; i++) {
+      if (b1[i] !== b2[i]) {
+        same = false;
+        break;
+      }
+    }
+  }
+  if (!same) {
+    if (opts.ignorePatterns.length > 0) return void 0;
+    if (!opts.ignoreCase && !opts.ignoreTrailing && !opts.ignoreBlank && !opts.ignoreTabs && !opts.stripTrailingCr && opts.whitespace === "exact") {
+      return void 0;
+    }
+    for (let i = 0; i < b1.byteLength; i++) if (b1[i] === 0) return void 0;
+    for (let i = 0; i < b2.byteLength; i++) if (b2[i] === 0) return void 0;
+    const t1 = syncDiffDecoder.decode(b1);
+    const t2 = syncDiffDecoder.decode(b2);
+    const l1 = normalizeSyncDiffLines(t1, opts);
+    const l2 = normalizeSyncDiffLines(t2, opts);
+    if (l1.length !== l2.length) return void 0;
+    for (let i = 0; i < l1.length; i++) {
+      if (l1[i] !== l2[i]) return void 0;
+    }
+    same = true;
+  }
+  return opts.reportSame ? `Files ${opts.labels[0] ?? left} and ${opts.labels[1] ?? right} are identical
+` : "";
+}
+
+export {
+  evalSyncDiff
+};

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

@@ -0,0 +1,65 @@
+import {
+  CurlError
+} from "./chunk-GRBWW4SG.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/form-content-type.ts
+init_buffer();
+function token(character) {
+  if (character === void 0) return false;
+  const code = character.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || "!#$%&'*+-.^_`|~".includes(character);
+}
+function formContentType(input, start, fileList = false) {
+  let end = start;
+  const invalid = () => {
+    throw new CurlError(2, "Invalid multipart content type");
+  };
+  const readToken = () => {
+    const begin = end;
+    while (token(input[end])) end++;
+    if (end === begin) invalid();
+  };
+  const whitespace = () => {
+    while (input[end] === " " || input[end] === "	") end++;
+  };
+  readToken();
+  if (input[end++] !== "/") invalid();
+  readToken();
+  whitespace();
+  while (end < input.length) {
+    if (fileList && input[end] === ",") break;
+    if (input[end] !== ";") invalid();
+    const separator = end++;
+    whitespace();
+    if (["type=", "filename=", "encoder=", "headers="].some((attribute) => input.startsWith(attribute, end))) {
+      return { value: input.slice(start, separator), end: separator };
+    }
+    readToken();
+    whitespace();
+    if (input[end++] !== "=") invalid();
+    whitespace();
+    if (input[end] === '"') {
+      end++;
+      let closed = false;
+      while (end < input.length) {
+        const character = input[end++];
+        if (character === '"') {
+          closed = true;
+          break;
+        }
+        const literal = character === "\\" ? input[end++] : character;
+        if (literal === void 0 || literal.charCodeAt(0) < 32 || literal.charCodeAt(0) === 127) invalid();
+      }
+      if (!closed) invalid();
+    } else readToken();
+    whitespace();
+  }
+  return { value: input.slice(start, end), end };
+}
+
+export {
+  formContentType
+};

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

@@ -0,0 +1,231 @@
+import {
+  safeTarget
+} from "./chunk-DOKKNRRM.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-gnu-paths.ts
+init_buffer();
+import { FsError, basename, dirname, isFsError, resolvePath } from "../../safe-bash-contracts/index.js";
+import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
+import { ToolError, host, inspect } from "../../safe-bash-diff-engine/shared.js";
+import { byteLength } from "../../safe-bash-io-engine/byte-encoding.js";
+function regular(stat, path) {
+  if (stat && stat.type !== "file") throw new ToolError(`patch target is not a regular file: ${path}`);
+  if (stat && (stat.nlink ?? 1) > 1) throw new ToolError(`hard-linked patch targets are unsupported: ${path}`);
+}
+function headerName(path, options) {
+  const safe = safeTarget(path, 0, options.explicit !== void 0);
+  if (safe === void 0) return void 0;
+  if (options.explicit !== void 0) return safe;
+  if (options.strip === void 0) return safe.split("/").at(-1);
+  if (path.split(/\/+/u).filter(Boolean).length <= options.strip) return void 0;
+  return safeTarget(path, options.strip);
+}
+function rejectName(target, options) {
+  return options.reject === "-" ? void 0 : options.reject ?? `${target}.rej`;
+}
+function pruneParents(target, cwd) {
+  const stop = target.startsWith("/") ? "/" : resolvePath(cwd, ".");
+  const parents = [];
+  for (let path = dirname(resolvePath(cwd, target)); path !== stop && path !== "/"; path = dirname(path)) parents.push(path);
+  return parents;
+}
+async function authorizePaths(patches, options, budget, state) {
+  const result = [];
+  for (const patch of patches) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (patch.unlocated) {
+      result.push({ patch, oldName: void 0, newName: void 0, indexName: void 0, candidates: [] });
+      continue;
+    }
+    if (patch.oldPath === "/dev/null" && patch.newPath === "/dev/null") throw new ToolError("both patch filenames are /dev/null");
+    const oldName = headerName(patch.oldPath, options);
+    const newName = headerName(patch.newPath, options);
+    const indexHeader = patch.indexPath === void 0 ? void 0 : headerName(patch.indexPath, options);
+    const indexName = options.posix || patch.format === "normal" || oldName === void 0 && newName === void 0 ? indexHeader : void 0;
+    const candidates = options.explicit === void 0 ? [...new Set([oldName, newName, indexName].filter((name) => name !== void 0))] : [options.explicit];
+    if (!candidates.length) throw new ToolError("strip count removes every patch filename");
+    result.push({ patch, oldName, newName, indexName, candidates, ...options.posix ? { posix: true } : {} });
+  }
+  const order = result.map((_patch, index) => index);
+  if (state?.reverse) order.reverse();
+  budget.step(order.length);
+  const lastChoice = order.findLastIndex((index) => result[index].candidates.length > 1);
+  for (const [position, index] of order.entries()) {
+    const authorized = result[index];
+    if (authorized.patch.unlocated) continue;
+    const selected = await selectTarget(authorized, state?.exists ?? (async (path2) => await candidateStat(path2, budget) !== void 0), budget);
+    const path = resolvePath(budget.context.cwd, selected);
+    if (path === options.input) throw new ToolError(`patch target aliases patch input: ${path}`);
+    regular(await inspect(budget, path), path);
+    result[index] = { ...authorized, selected };
+    if (position < lastChoice) await state?.advance(result[index]);
+  }
+  return result;
+}
+async function backupName(path, budget, options = {}) {
+  const simple = safeTarget(`${path}${options.suffix ?? ".orig"}`, 0, true);
+  if (simple === void 0) throw new ToolError("invalid backup path");
+  if (options.prefix !== void 0 || options.basenamePrefix !== void 0) {
+    const relative = path.startsWith(`${budget.context.cwd}/`) ? path.slice(budget.context.cwd.length + 1) : path;
+    const prefixed = options.prefix !== void 0 ? `${options.prefix}${relative}` : `${dirname(path)}/${options.basenamePrefix ?? ""}${basename(path)}`;
+    const safe = safeTarget(`${prefixed}${options.suffix ?? ".orig"}`, 0, true);
+    if (safe === void 0) throw new ToolError("invalid backup path");
+    return resolvePath(budget.context.cwd, safe);
+  }
+  if (options.versionControl === "simple") return simple;
+  const parent = dirname(path);
+  if (!await inspect(budget, parent)) return options.versionControl === "numbered" ? `${path}.~1~` : simple;
+  const prefix = `${basename(path)}.~`;
+  const entries = await host(budget.context, () => budget.context.fs.readdir(parent, { signal: budget.context.signal }));
+  let maximum = "0";
+  for (const entry of entries) {
+    budget.file();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (!entry.name || /[/\0]/u.test(entry.name) || entry.name === "." || entry.name === "..") throw new ToolError("unsafe directory entry in backup directory");
+    if (!entry.name.startsWith(prefix) || !entry.name.endsWith("~")) continue;
+    const version = entry.name.slice(prefix.length, -1);
+    budget.step(version.length);
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (!/^[1-9]\d*$/u.test(version)) continue;
+    if (version.length > maximum.length || version.length === maximum.length && version > maximum) maximum = version;
+  }
+  if (maximum === "0" && options.versionControl !== "numbered") return simple;
+  let position = maximum.length - 1;
+  while (position >= 0 && maximum[position] === "9") position--;
+  const next = position < 0 ? `1${"0".repeat(maximum.length)}` : `${maximum.slice(0, position)}${Number(maximum[position]) + 1}${"0".repeat(maximum.length - position - 1)}`;
+  return `${path}.~${next}~`;
+}
+async function authorizeOutputs(paths, targets, input, budget) {
+  const outputs = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    if (path === void 0) continue;
+    budget.step();
+    if (targets.has(path) || outputs.has(path) || path === input) throw new ToolError(`patch output aliases a target, input, or another output: ${path}`);
+    outputs.add(path);
+    regular(await inspect(budget, path), path);
+  }
+}
+function rank(name) {
+  return [name.split("/").length, byteLength(name.split("/").at(-1)), byteLength(name)];
+}
+async function candidateStat(path, budget) {
+  budget.step();
+  {
+    const c = budget.checkpoint();
+    if (c) await c;
+  }
+  try {
+    return await host(budget.context, () => budget.context.fs.stat(path, { signal: budget.context.signal }));
+  } catch (error) {
+    if (isFsError(error, "ENOENT") || isFsError(error, "ENOTDIR") || isFsError(error, "ELOOP")) return void 0;
+    throw error;
+  }
+}
+async function selectTarget(authorized, exists, budget) {
+  const present = [];
+  for (const candidate of authorized.candidates) {
+    budget.step();
+    if (await exists(resolvePath(budget.context.cwd, candidate))) present.push(candidate);
+  }
+  if (authorized.posix) return present[0] ?? authorized.candidates[0];
+  const candidates = present.length ? present : [...authorized.candidates];
+  const missingParents = /* @__PURE__ */ new Map();
+  if (!present.length) for (const candidate of candidates) {
+    let missing = 0;
+    for (let parent = dirname(resolvePath(budget.context.cwd, candidate)); parent !== "/"; parent = dirname(parent)) {
+      if (await exists(parent)) break;
+      missing++;
+    }
+    missingParents.set(candidate, missing);
+  }
+  candidates.sort((left, right) => {
+    const missing = (missingParents.get(left) ?? 0) - (missingParents.get(right) ?? 0);
+    if (missing) return missing;
+    const leftRank = rank(left);
+    const rightRank = rank(right);
+    for (let index = 0; index < leftRank.length; index++) {
+      const order = leftRank[index] - rightRank[index];
+      if (order) return order;
+    }
+    return 0;
+  });
+  return candidates[0];
+}
+async function ensureParents(path, budget) {
+  const missing = [];
+  for (let parent = dirname(path); ; parent = dirname(parent)) {
+    const stat = await inspect(budget, parent);
+    if (stat) {
+      if (stat.type !== "directory") throw new ToolError(`not a directory: ${parent}`);
+      break;
+    }
+    if (parent === "/") throw new ToolError("filesystem root does not exist");
+    missing.push(parent);
+  }
+  for (const parent of missing.reverse()) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    await inspect(budget, parent);
+    await host(budget.context, () => budget.context.fs.mkdir(parent, { signal: budget.context.signal }));
+  }
+}
+async function pruneDirectories(parents, budget) {
+  for (const parent of [...parents].sort((left, right) => right.split("/").length - left.split("/").length)) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    const stat = await inspect(budget, parent);
+    budget.context.signal.throwIfAborted();
+    if (!stat) continue;
+    if (stat.type !== "directory") throw new ToolError(`pruning path changed type: ${parent}`);
+    try {
+      const entries = await host(budget.context, () => budget.context.fs.readdir(parent, { signal: budget.context.signal }));
+      budget.step(entries.length);
+      if (entries.length) continue;
+      const rmdir = budget.context.fs.rmdir;
+      if (!rmdir) throw new FsError("ENOTSUP", { syscall: "rmdir", path: parent });
+      try {
+        await host(budget.context, () => rmdir.call(budget.context.fs, parent, { signal: budget.context.signal }));
+      } catch (error) {
+        budget.context.signal.throwIfAborted();
+        if (!isFsError(error, "ENOTEMPTY")) throw error;
+      }
+    } catch (error) {
+      budget.context.signal.throwIfAborted();
+      if (isFsError(error, "ENOENT")) continue;
+      if (isFsError(error) || error instanceof ToolError) throw error;
+      throw new ToolError(`cannot prune directory ${parent}: ${publicDiagnosticMessage(error, budget.context.onInternalError)}`);
+    }
+  }
+}
+
+export {
+  regular,
+  rejectName,
+  pruneParents,
+  authorizePaths,
+  backupName,
+  authorizeOutputs,
+  candidateStat,
+  selectTarget,
+  ensureParents,
+  pruneDirectories
+};

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

@@ -0,0 +1,101 @@
+import {
+  PandocError
+} from "./chunk-7OKDCM5U.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-pandoc/dist/chunks/chunk-YI4UJTYX.js
+init_buffer();
+function imageLength(value, natural, context, format) {
+  if (value === void 0) return natural;
+  const units = { in: 914400, pt: 12700, cm: 36e4, mm: 36e3, px: 9525 };
+  const unit = Object.keys(units).find((unit2) => value.endsWith(unit2));
+  const number = unit ? Number(value.slice(0, -unit.length)) : NaN;
+  const result = unit ? Math.round(number * units[unit]) : NaN;
+  if (!Number.isSafeInteger(result) || result <= 0)
+    throw new PandocError("E_OPTION", context.operation ?? "write", "Image dimensions require positive in, pt, cm, mm or px values", format);
+  return result;
+}
+
+export {
+  imageLength
+};
+/*!
+MIT License
+
+Copyright © 2017-2019 Benoit Giannangeli
+Copyright © 2017-2025 Daurnimator
+Copyright © 1994–2017 Lua.org, PUC-Rio.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+/*!
+Copyright (c) 2007-present, Alexandru Mărășteanu <hello@alexei.ro>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of this software nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+/*!
+	Copyright (c) 2009-2019 Frank Bennett
+
+	This program is free software: you can redistribute it and/or
+	modify it under EITHER
+
+      * the terms of the Common Public Attribution License (CPAL) as
+	    published by the Open Source Initiative, either version 1 of
+	    the CPAL, or (at your option) any later version; OR
+
+      * the terms of the GNU Affero General Public License (AGPL)
+        as published by the Free Software Foundation, either version
+        3 of the AGPL, or (at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Affero General Public License for more details.
+
+	You should have received copies of the Common Public Attribution
+    License and of the GNU Affero General Public License along with
+    this program.  If not, see <https://opensource.org/licenses/> or
+    <http://www.gnu.org/licenses/> respectively.
+
+*/

package/dist/safe-bash/command-chunks/{chunk-44AHAB5O.js → chunk-BDSMROQZ.js}

@@ -104,10 +104,7 @@ async function parse(text, work) {
           current = { anchors: [], lines: [], eof: false };
           hunks.push(current);
         }
-        if (named) {
-          work.count("maxHunks", 1);
-          current.anchors.push(line.slice(3));
-        }
+        if (named) current.anchors.push(line.slice(3));
       } else if (line === "*** End of File") {
         if (!current?.lines.length) throw new PatchError("EOF requires a nonempty hunk", 2);
         current.eof = true;