@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/{chunk-OAJUAAWH.js → chunk-464RVBGB.js}

@@ -1,16 +1,16 @@
 import {
   sort
-} from "./chunk-RECJB2BO.js";
+} from "./chunk-7BS66BXN.js";
 import {
   Lifecycle,
   Reader
-} from "./chunk-HBXQWTJR.js";
+} from "./chunk-A5ZAV6DO.js";
 import {
   Budget,
   TsortError,
   quote,
   settings
-} from "./chunk-CZVBYCB5.js";
+} from "./chunk-IL53SJL4.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-4B7Y7S6E.js

@@ -0,0 +1,61 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-envelope.ts
+init_buffer();
+import { ToolError } from "../../safe-bash-diff-engine/shared.js";
+async function normalizeTransport(text, budget) {
+  const lines = [];
+  let position = 0;
+  while (position < text.length) {
+    const end = text.indexOf("\n", position);
+    budget.step(1 + end - position);
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (end <= position || text[end - 1] !== "\r") return text;
+    lines.push(text.slice(position, end - 1), "\n");
+    if (lines.length / 2 > budget.limits.maxLines) throw new ToolError("transport line limit exceeded");
+    position = end + 1;
+  }
+  return lines.join("");
+}
+async function unwrapPatch(text, budget) {
+  if (text && !text.endsWith("\n")) throw new ToolError("patch is truncated: missing final LF");
+  text = await normalizeTransport(text, budget);
+  let position = 0;
+  let lines = 0;
+  const mail = /^(?:From [0-9a-f]{40,64} |(?:From|Date|Subject|To|Cc|MIME-Version|Content-Type):)/u.test(text);
+  if (mail) {
+    while (position < text.length) {
+      budget.step();
+      {
+        const c = budget.checkpoint();
+        if (c) await c;
+      }
+      const end = text.indexOf("\n", position);
+      const line = text.slice(position, end);
+      if (/^(?:--- |\*\*\* |diff |\d+(?:,\d+)?[acd]\d)/u.test(line)) break;
+      if (/^(?:old mode |new mode |new file mode |deleted file mode |rename |copy |similarity index |dissimilarity index |GIT binary patch|Binary files |index |@@|[+\\])/u.test(line)) throw new ToolError("unsupported or malformed mail patch metadata");
+      position = end + 1;
+      if (++lines > budget.limits.maxLines) throw new ToolError("mail preamble limit exceeded");
+    }
+    if (position === text.length) throw new ToolError("mail preamble without patch");
+  }
+  const body = text.slice(position);
+  const signature = body.indexOf("\n-- \n");
+  if (signature < 0) return body;
+  const trailer = body.slice(signature + 5);
+  if (trailer.split("\n").length > budget.limits.maxLines) throw new ToolError("mail signature limit exceeded");
+  for (const line of trailer.split("\n")) {
+    budget.step();
+    if (/^(?:diff |---|\+\+\+|\*\*\*|@@|index |old mode |new mode |new file mode |deleted file mode |rename |copy |similarity index |dissimilarity index |GIT binary patch|Binary files |[+\\]|\d+(?:,\d+)?[acd]\d)/u.test(line)) throw new ToolError("patch data after mail signature");
+  }
+  return body.slice(0, signature + 1);
+}
+
+export {
+  unwrapPatch
+};

package/dist/safe-bash/command-chunks/{chunk-HRLIAMXC.js → chunk-4C6QI5BQ.js}

@@ -62,6 +62,7 @@ async function resolveVfsCwd(cwd, pwd, filesystem, signal) {
 init_buffer();
 function createVfsOutput(fs, writeBytes, retainCleanup) {
   let serial = 0;
+  const removeFile = fs.unlink?.bind(fs) ?? fs.rm?.bind(fs);
   return async (filename, context) => {
     const signal = context.signal;
     const options = { signal };
@@ -79,7 +80,7 @@ function createVfsOutput(fs, writeBytes, retainCleanup) {
       signal.throwIfAborted();
       if (closed) throw new SsconvertError("invalid-request", "ssconvert file output is closed");
     };
-    const abort = (remove = (path2) => fs.unlink(path2)) => {
+    const abort = (remove = removeFile) => {
       closed = true;
       return aborting ??= (async () => {
         await acquiring;
@@ -131,7 +132,7 @@ function createVfsOutput(fs, writeBytes, retainCleanup) {
       check();
       const capabilities = await fs.capabilitiesFor?.(path, options) ?? fs.capabilities;
       check();
-      if (!capabilities.exclusiveCreate || !capabilities.atomicRename || !capabilities.permissions || !fs.unlink || !fs.chmod)
+      if (!capabilities.exclusiveCreate || !capabilities.atomicRename || !capabilities.permissions || !removeFile || !fs.chmod)
         throw new SsconvertError("capability-denied", "Filesystem exclusive creation, atomic rename, unlink and permissions capabilities are required for ssconvert file publication");
       const dirname = path.slice(0, path.lastIndexOf("/") + 1);
       const random = context.random?.next() ?? 0;

package/dist/safe-bash/command-chunks/{chunk-25BLI6S6.js → chunk-4Y3WVMK4.js}

@@ -5,7 +5,7 @@ import {
 // packages/safe-bash-command-html-to-markdown/src/budget.ts
 init_buffer();
 import { utf8ByteLength, bytesFrom } from "../../safe-bash-byte-engine/index.js";
-import { hasYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
 import { FsError, writeBytes } from "../../safe-bash-contracts/index.js";
 function asciiOrUtf8ByteLength(text) {
   const len = text.length;
@@ -19,7 +19,6 @@ var Budget = class {
     this.context = context;
     this.limits = limits;
     const signal = context.signal;
-    this.hasExtYield = hasYieldCheckpoint(signal);
     this.aborted = Boolean(signal.aborted);
     this.pollSignal = typeof signal.addEventListener !== "function" || Object.prototype.hasOwnProperty.call(signal, "aborted");
     if (!this.aborted && !this.pollSignal) {
@@ -37,9 +36,6 @@ var Budget = class {
   cells = 0;
   workUsed = 0;
   sinceYield = 0;
-  checkpoints = 0;
-  lastYieldTime = monotonicNow();
-  hasExtYield;
   aborted;
   pollSignal;
   check(amount, remaining, name) {
@@ -57,18 +53,9 @@ var Budget = class {
     if (this.aborted || this.pollSignal && this.context.signal.aborted) this.context.signal.throwIfAborted();
     if (this.sinceYield >= 4096) {
       this.sinceYield = 0;
-      const count = ++this.checkpoints;
-      const now = monotonicNow();
-      if (!this.hasExtYield && count > 1 && count % 16 !== 0 && now - this.lastYieldTime < 16) {
-        runYieldCheckpoint(this.context.signal);
-        return;
-      }
-      this.lastYieldTime = now;
       return yieldTurn(this.context.signal).then(() => {
-        this.lastYieldTime = monotonicNow();
         if (this.aborted || this.pollSignal && this.context.signal.aborted) this.context.signal.throwIfAborted();
       }, (error) => {
-        this.lastYieldTime = monotonicNow();
         if (this.aborted || this.pollSignal && this.context.signal.aborted) this.context.signal.throwIfAborted();
         throw error;
       });

package/dist/safe-bash/command-chunks/chunk-4ZHMW6F5.js

@@ -0,0 +1,104 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-gnu-reject.ts
+init_buffer();
+function timestamp(header) {
+  if (!header) return "";
+  const separator = header.indexOf("	");
+  return separator < 0 ? "" : header.slice(separator);
+}
+function unifiedRange(start, count, offset) {
+  return `${start + offset}${count === 1 ? "" : `,${count}`}`;
+}
+function contextRange(start, count, offset) {
+  return count === 0 ? "0" : count === 1 ? `${start + offset}` : `${start + offset},${start + offset + count - 1}`;
+}
+async function rejectText(patch, outcomes, oldName, newName, indexName, reverse, budget, format) {
+  const normal = patch.format === "normal";
+  const context = format === void 0 ? patch.format === "context" || normal : format === "context";
+  const names = [normal ? "/dev/null" : oldName ?? "/dev/null", normal ? "/dev/null" : newName ?? "/dev/null"];
+  const times = normal ? ["", ""] : [timestamp(patch.oldHeader), timestamp(patch.newHeader)];
+  if (reverse) {
+    names.reverse();
+    times.reverse();
+  }
+  const output = [];
+  const add = (text) => {
+    budget.output(text);
+    output.push(text);
+  };
+  if (indexName !== void 0) add(`Index: ${indexName}
+`);
+  add(`${context ? "***" : "---"} ${names[0]}${times[0]}
+${context ? "---" : "+++"} ${names[1]}${times[1]}
+`);
+  for (const outcome of outcomes) {
+    if (!outcome.failed) continue;
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    const { hunk, outputOffset } = outcome;
+    if (!context) {
+      add(`@@ -${unifiedRange(hunk.oldStart, hunk.oldCount, outputOffset)} +${unifiedRange(hunk.newStart, hunk.newCount, outputOffset)} @@${hunk.section ?? ""}
+`);
+      let group = [];
+      const flush = () => {
+        for (const kind of ["-", "+"]) for (const line of group) if (line.kind === kind) add(`${kind}${line.text}`);
+        group = [];
+      };
+      for (const line of hunk.lines) {
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+        if (line.kind === " ") {
+          flush();
+          add(` ${line.text}`);
+        } else group.push(line);
+      }
+      flush();
+    } else {
+      add(`***************${hunk.section ?? ""}
+*** ${contextRange(hunk.oldStart, hunk.oldCount, outputOffset)}${normal ? "" : " ****"}
+`);
+      const oldLines = [];
+      const newLines = [];
+      let group = [];
+      const flush = () => {
+        const changed = !normal && group.some((line) => line.kind === "-") && group.some((line) => line.kind === "+");
+        for (const line of group) {
+          const text = `${changed ? "!" : line.kind} ${line.text}`;
+          (line.kind === "-" ? oldLines : newLines).push(text);
+        }
+        group = [];
+      };
+      for (const line of hunk.lines) {
+        budget.step();
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
+        if (line.kind === " ") {
+          flush();
+          oldLines.push(`  ${line.text}`);
+          newLines.push(`  ${line.text}`);
+        } else group.push(line);
+      }
+      flush();
+      for (const line of oldLines) add(line);
+      add(`--- ${contextRange(hunk.newStart, hunk.newCount, outputOffset)}${normal ? " -----" : " ----"}
+`);
+      for (const line of newLines) add(line);
+    }
+  }
+  return output.join("");
+}
+
+export {
+  rejectText
+};

package/dist/safe-bash/command-chunks/{chunk-YMQKVEIF.js → chunk-52PCQXD2.js}

@@ -4,7 +4,7 @@ import {
 
 // packages/safe-bash-io-engine/src/shell/string-operations.ts
 init_buffer();
-import { hasYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
 function stringCheckpoint(work, units = 1) {
   work.signal.throwIfAborted();
   work.remaining -= units;
@@ -12,18 +12,7 @@ function stringCheckpoint(work, units = 1) {
   work.steps = (work.steps ?? 0) + units;
   if (work.steps < 128) return void 0;
   work.steps %= 128;
-  const now = monotonicNow();
-  const firstYield = work.lastYield === void 0;
-  const lastYield = work.lastYield ??= now;
-  work.yieldChecks = (work.yieldChecks ?? 0) + 1;
-  if (work.yieldChecks % 16 === 0 || firstYield || hasYieldCheckpoint(work.signal) || now - lastYield >= 1) {
-    work.lastYield = now;
-    return yieldTurn(work.signal).then(() => {
-      work.lastYield = monotonicNow();
-    });
-  }
-  runYieldCheckpoint(work.signal);
-  return void 0;
+  return yieldTurn(work.signal);
 }
 function nextCodePointOffset(value, offset) {
   if (offset >= value.length) return value.length;

package/dist/safe-bash/command-chunks/{chunk-SSBFTMVI.js → chunk-53P53XFM.js}

@@ -1,9 +1,9 @@
 import {
   stringify
-} from "./chunk-PPOIPMY4.js";
+} from "./chunk-YGC6OS5O.js";
 import {
   JqError
-} from "./chunk-AC6X7Q4I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   decodeBase64,
   decoder,

package/dist/safe-bash/command-chunks/{chunk-ZCKDQGKY.js → chunk-5HDSFHGW.js}

@@ -1,6 +1,6 @@
 import {
   pathText
-} from "./chunk-LW34AKDM.js";
+} from "./chunk-AB4MXHVS.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-5LSGEIZY.js

@@ -0,0 +1,379 @@
+import {
+  validateHeaderName,
+  validateHeaderValue
+} from "./chunk-5XY4DTNG.js";
+import {
+  CurlError
+} from "./chunk-IYPAQ7PH.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/args.ts
+init_buffer();
+var values = {
+  C: "continue-at",
+  X: "request",
+  d: "data",
+  H: "header",
+  u: "user",
+  A: "user-agent",
+  e: "referer",
+  o: "output",
+  D: "dump-header",
+  w: "write-out",
+  T: "upload-file",
+  m: "max-time",
+  F: "form",
+  r: "range"
+};
+var flags = {
+  L: "location",
+  I: "head",
+  i: "include",
+  f: "fail",
+  s: "silent",
+  S: "show-error",
+  G: "get",
+  O: "remote-name",
+  v: "verbose",
+  q: "disable",
+  N: "no-buffer",
+  g: "globoff",
+  h: "help",
+  V: "version"
+};
+var longValues = /* @__PURE__ */ new Set([
+  ...Object.values(values),
+  "data-ascii",
+  "data-raw",
+  "data-binary",
+  "data-urlencode",
+  "url-query",
+  "json",
+  "form-string",
+  "url",
+  "oauth2-bearer",
+  "max-redirs",
+  "max-filesize",
+  "retry",
+  "retry-delay",
+  "connect-timeout",
+  "output-dir",
+  "cacert",
+  "etag-save",
+  "etag-compare"
+]);
+var booleans = {
+  location: "location",
+  head: "head",
+  include: "include",
+  "show-headers": "include",
+  get: "get",
+  "remote-name": "remoteName",
+  fail: "fail",
+  "fail-with-body": "failWithBody",
+  silent: "silent",
+  "show-error": "showError",
+  verbose: "verbose",
+  globoff: "globoff",
+  compressed: "compressed",
+  raw: "raw",
+  "ignore-content-length": "ignoreContentLength"
+};
+function number(value, integral = false) {
+  if (!(integral ? /^\d+$/ : /^\d+(?:\.\d+)?$/).test(value)) throw new CurlError(2, "Invalid numeric option");
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > Number.MAX_SAFE_INTEGER) throw new CurlError(2, "Invalid numeric option");
+  return parsed;
+}
+function timeoutSeconds(value) {
+  const invalid = () => {
+    throw new CurlError(2, "Invalid numeric option");
+  };
+  let index = 0;
+  while (index < value.length && " 	\n\r\v\f".includes(value[index])) index++;
+  const negative = value[index] === "-";
+  if (negative || value[index] === "+") index++;
+  const hexadecimal = value.slice(index, index + 2).toLowerCase() === "0x";
+  if (hexadecimal) index += 2;
+  const digits = hexadecimal ? "0123456789abcdef" : "0123456789";
+  const radix = hexadecimal ? 16 : 10;
+  let mantissa = 0;
+  let digitCount = 0;
+  let fractionDigits = 0;
+  let point = false;
+  for (; index < value.length; index++) {
+    const character = value[index].toLowerCase();
+    const digit = digits.indexOf(character);
+    if (digit >= 0) {
+      mantissa = mantissa * radix + digit;
+      digitCount++;
+      if (point) fractionDigits++;
+    } else if (character === "." && !point) point = true;
+    else break;
+  }
+  if (!digitCount) invalid();
+  let exponent = 0;
+  if (value[index]?.toLowerCase() === (hexadecimal ? "p" : "e")) {
+    index++;
+    const exponentNegative = value[index] === "-";
+    if (exponentNegative || value[index] === "+") index++;
+    const start = index;
+    while (index < value.length && "0123456789".includes(value[index])) index++;
+    if (index === start) invalid();
+    exponent = Number(value.slice(start, index)) * (exponentNegative ? -1 : 1);
+  }
+  if (index !== value.length) invalid();
+  const parsed = hexadecimal ? (negative ? -1 : 1) * mantissa * 2 ** (exponent - fractionDigits * 4) : Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > Number.MAX_SAFE_INTEGER) invalid();
+  return parsed;
+}
+function validateRequestHeader(name, value) {
+  try {
+    validateHeaderName(name);
+    validateHeaderValue(name, value);
+  } catch {
+    throw new CurlError(2, "Invalid HTTP header");
+  }
+  if (["host", "content-length", "transfer-encoding", "connection", "proxy-authorization", "upgrade", "expect"].includes(name.toLowerCase())) {
+    throw new CurlError(2, "Transport-controlled HTTP header is not supported");
+  }
+}
+function addHeader(result, raw) {
+  const colon = raw.indexOf(":");
+  const semicolon = colon < 0 && raw.endsWith(";");
+  if (colon < 1 && !semicolon) throw new CurlError(2, "Invalid HTTP header");
+  const name = semicolon ? raw.slice(0, -1) : raw.slice(0, colon);
+  const value = semicolon ? "" : raw.slice(colon + 1).trim();
+  validateRequestHeader(name, value);
+  result.headers.push([name, value === "" && !semicolon ? null : value]);
+}
+function parseArguments(args, limits) {
+  const result = {
+    urls: [],
+    data: [],
+    headers: [],
+    include: false,
+    head: false,
+    get: false,
+    location: false,
+    remoteName: false,
+    fail: false,
+    failWithBody: false,
+    silent: false,
+    showError: false,
+    verbose: false,
+    globoff: false,
+    help: false,
+    version: false,
+    retries: 0,
+    retryDelayMs: 0,
+    maxTimeMs: limits.maxTimeMs,
+    maxRedirects: limits.maxRedirects,
+    maxFileSize: limits.maxDownloadBytes
+  };
+  const apply = (option, value) => {
+    const positive = option.startsWith("no-") ? option.slice(3) : option;
+    const property = Object.hasOwn(booleans, positive) ? booleans[positive] : void 0;
+    if (property) {
+      Object.assign(result, { [property]: !option.startsWith("no-") });
+      if (property === "remoteName") {
+        (result.outputs ??= []).push({ remoteName: result.remoteName });
+        if (result.remoteName) delete result.output;
+      }
+      return;
+    }
+    switch (option) {
+      case "continue-at": {
+        if (value === "-") result.continueAt = "auto";
+        else {
+          if (!value || [...value].some((character) => !"0123456789".includes(character)) || !Number.isSafeInteger(Number(value))) {
+            throw new CurlError(2, "Invalid resume offset");
+          }
+          result.continueAt = Number(value);
+        }
+        break;
+      }
+      case "etag-save":
+        result.etagSave = value;
+        break;
+      case "etag-compare":
+        result.etagCompare = value;
+        break;
+      case "cacert":
+        result.caFile = value;
+        break;
+      case "http1.0":
+        result.httpVersion = "1.0";
+        break;
+      case "http1.1":
+        result.httpVersion = "1.1";
+        break;
+      case "url-query":
+        (result.query ??= []).push({ kind: value.startsWith("+") ? "raw" : "urlencode", value: value.startsWith("+") ? value.slice(1) : value });
+        break;
+      case "request":
+        if (!value || !/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(value) || ["CONNECT", "TRACE"].includes(value.toUpperCase())) {
+          throw new CurlError(2, "Invalid or unsupported HTTP method");
+        }
+        result.method = value;
+        break;
+      case "header":
+        addHeader(result, value);
+        break;
+      case "range":
+        try {
+          validateHeaderValue("Range", value);
+        } catch {
+          throw new CurlError(2, "Invalid byte range");
+        }
+        result.range = value;
+        break;
+      case "user-agent":
+        addHeader(result, `User-Agent: ${value}`);
+        break;
+      case "referer": {
+        validateRequestHeader("Referer", value);
+        const auto = value.indexOf(";auto");
+        result.autoReferer = auto >= 0;
+        result.referer = auto >= 0 ? value.slice(0, auto) : value;
+        break;
+      }
+      case "user":
+        if (!value.includes(":")) throw new CurlError(2, "Basic authentication requires user:password; prompting is unsupported");
+        result.user = value;
+        break;
+      case "oauth2-bearer":
+        result.bearer = value;
+        break;
+      case "data":
+      case "data-ascii":
+        result.data.push({ kind: "data", value });
+        break;
+      case "data-raw":
+        result.data.push({ kind: "raw", value });
+        break;
+      case "data-binary":
+        result.data.push({ kind: "binary", value });
+        break;
+      case "data-urlencode":
+        result.data.push({ kind: "urlencode", value });
+        break;
+      case "json":
+      case "form":
+      case "form-string":
+        result.data.push({ kind: option, value });
+        break;
+      case "output":
+        result.output = value;
+        result.remoteName = false;
+        (result.outputs ??= []).push({ output: value, remoteName: false });
+        break;
+      case "output-dir":
+        result.outputDirectory = value;
+        break;
+      case "dump-header":
+        result.dumpHeader = value;
+        break;
+      case "write-out":
+        result.writeOut = value;
+        break;
+      case "upload-file":
+        result.upload = value;
+        break;
+      case "url":
+        result.urls.push(value);
+        break;
+      case "max-time": {
+        const milliseconds = timeoutSeconds(value) * 1e3;
+        result.maxTimeMs = Math.min(milliseconds === 0 ? Infinity : milliseconds, limits.maxTimeMs);
+        break;
+      }
+      case "connect-timeout": {
+        const milliseconds = timeoutSeconds(value) * 1e3;
+        if (milliseconds === 0) delete result.connectTimeoutMs;
+        else result.connectTimeoutMs = Math.min(milliseconds, limits.maxTimeMs);
+        break;
+      }
+      case "max-filesize":
+        result.maxFileSize = Math.min(number(value, true), limits.maxDownloadBytes);
+        break;
+      case "max-redirs":
+        result.maxRedirects = Math.min(number(value, true), limits.maxRedirects);
+        break;
+      case "retry":
+        result.retries = Math.min(number(value, true), limits.maxRetries);
+        break;
+      case "retry-delay":
+        result.retryDelayMs = Math.min(number(value) * 1e3, limits.maxTimeMs);
+        break;
+      case "help":
+        result.help = true;
+        break;
+      case "version":
+        result.version = true;
+        break;
+      case "disable":
+      case "no-buffer":
+      case "no-progress-meter":
+      case "basic":
+        break;
+      default:
+        throw new CurlError(2, "Unsupported curl option");
+    }
+  };
+  let ended = false;
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    if (ended || !argument.startsWith("-") || argument === "-") {
+      result.urls.push(argument);
+      continue;
+    }
+    if (argument === "--") {
+      ended = true;
+      continue;
+    }
+    if (argument.startsWith("--")) {
+      const equals = argument.indexOf("=");
+      const name = argument.slice(2, equals < 0 ? void 0 : equals);
+      let value = equals < 0 ? void 0 : argument.slice(equals + 1);
+      if (longValues.has(name)) {
+        value ??= args[++index];
+        if (value === void 0) throw new CurlError(2, "Option requires an argument");
+      } else if (value !== void 0) throw new CurlError(2, "Unexpected option argument");
+      apply(name, value);
+    } else {
+      for (let offset = 1; offset < argument.length; offset++) {
+        const name = argument[offset];
+        if (values[name]) {
+          const value = argument.slice(offset + 1) || args[++index];
+          if (value === void 0) throw new CurlError(2, "Option requires an argument");
+          apply(values[name], value);
+          break;
+        }
+        if (!flags[name]) throw new CurlError(2, "Unsupported curl option");
+        apply(flags[name]);
+      }
+    }
+  }
+  if (!result.help && !result.version && !result.urls.length) throw new CurlError(2, "No URL specified");
+  if (result.urls.length > limits.maxUrls) throw new CurlError(2, "URL count exceeds host limit");
+  if (result.fail && result.failWithBody) throw new CurlError(2, "--fail and --fail-with-body are mutually exclusive");
+  const form = result.data.some((part) => part.kind === "form" || part.kind === "form-string");
+  if (result.upload !== void 0 && result.data.length || form && result.data.some((part) => !part.kind.startsWith("form")) || result.get && (form || result.upload !== void 0) || result.head && (result.upload !== void 0 || result.data.length > 0) && !result.get) {
+    throw new CurlError(2, "Incompatible request body options");
+  }
+  if (result.data.some((part) => part.kind === "json") && result.data.some((part) => part.kind !== "json")) {
+    throw new CurlError(2, "Mixing JSON and other data modes is unsupported");
+  }
+  return result;
+}
+
+export {
+  values,
+  flags,
+  longValues,
+  validateRequestHeader,
+  parseArguments
+};