@poe-platform/safe-bash 0.1.799 → 0.1.801

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

@@ -0,0 +1,354 @@
+import {
+  HexdumpError,
+  raw
+} from "./chunk-DIEPXUM4.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-hexdump/src/options.ts
+init_buffer();
+
+// packages/safe-bash-command-hexdump/src/custom.ts
+init_buffer();
+
+// packages/safe-bash-command-hexdump/src/float.ts
+init_buffer();
+function formatFloat(number2, code, flags, precision, budget) {
+  const sign = number2 < 0 || Object.is(number2, -0) ? "-" : flags.includes("+") ? "+" : flags.includes(" ") ? " " : "";
+  if (!Number.isFinite(number2)) {
+    const special = Number.isNaN(number2) ? "nan" : "inf";
+    return sign + (code === code.toUpperCase() ? special.toUpperCase() : special);
+  }
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, Math.abs(number2));
+  const bits = view.getBigUint64(0), exponentBits = Number(bits >> 52n & 2047n);
+  let coefficient = bits & (1n << 52n) - 1n;
+  if (exponentBits) coefficient |= 1n << 52n;
+  const binaryExponent = exponentBits ? exponentBits - 1023 - 52 : -1074;
+  const scale = binaryExponent < 0 ? -binaryExponent : 0;
+  budget.buffered((scale + 64) * 4);
+  budget.charge(scale + 64);
+  const decimal = (binaryExponent < 0 ? coefficient * 5n ** BigInt(scale) : coefficient << BigInt(binaryExponent)).toString();
+  const capacity = (length) => {
+    budget.outputCapacity(length + sign.length);
+    budget.buffered((length + decimal.length + sign.length) * 6);
+    budget.charge(length);
+  };
+  const round = (keep) => {
+    if (keep < 0) return "0";
+    if (keep >= decimal.length) {
+      capacity(keep);
+      return decimal.padEnd(keep, "0");
+    }
+    const head = decimal.slice(0, keep) || "0";
+    const next = decimal[keep];
+    let tailNonzero = false;
+    for (let index = keep + 1; index < decimal.length; index++) if (decimal[index] !== "0") {
+      tailNonzero = true;
+      break;
+    }
+    const up = next > "5" || next === "5" && (tailNonzero || Number(head.at(-1)) % 2 === 1);
+    return up ? (BigInt(head) + 1n).toString() : head;
+  };
+  const digits = precision ?? 6, alternate = flags.includes("#");
+  let result;
+  if (code === "f") {
+    capacity(Math.max(1, decimal.length - scale) + digits + (digits || alternate ? 1 : 0));
+    const rounded = round(decimal.length - scale + digits).padStart(digits + 1, "0");
+    result = digits ? rounded.slice(0, -digits) + "." + rounded.slice(-digits) : rounded + (alternate ? "." : "");
+  } else {
+    const general = code === "g" || code === "G";
+    const significant = general ? Math.max(1, digits) : digits + 1;
+    let exponent = coefficient === 0n ? 0 : decimal.length - scale - 1;
+    const keep = general && !alternate ? Math.min(significant, decimal.length) : significant;
+    let rounded = coefficient === 0n ? "0" : round(keep);
+    if (rounded.length > keep) {
+      exponent++;
+      rounded = rounded.slice(0, -1);
+    }
+    if (general && !alternate) {
+      while (rounded.length > 1 && rounded.endsWith("0")) rounded = rounded.slice(0, -1);
+    } else {
+      capacity(significant + 8);
+      rounded = rounded.padEnd(significant, "0");
+    }
+    if (!general || exponent < -4 || exponent >= significant) {
+      result = rounded[0] + (rounded.length > 1 || alternate ? "." + rounded.slice(1) : "") + (code === "E" || code === "G" ? "E" : "e") + (exponent < 0 ? "-" : "+") + Math.abs(exponent).toString().padStart(2, "0");
+    } else {
+      const point = exponent + 1;
+      capacity(Math.max(rounded.length, point) + Math.max(0, 1 - point));
+      result = point <= 0 ? "0." + "0".repeat(-point) + rounded : point < rounded.length ? rounded.slice(0, point) + "." + rounded.slice(point) : rounded.padEnd(point, "0") + (alternate ? "." : "");
+    }
+  }
+  return sign + result;
+}
+
+// packages/safe-bash-command-hexdump/src/custom.ts
+function parseCustom(text, budget) {
+  let at = 0;
+  const fail = () => {
+    throw new HexdumpError(`bad format: ${text}`);
+  };
+  const space = () => {
+    while (at < text.length && " 	\n\r".includes(text[at])) at++;
+  };
+  const integer = () => {
+    const start = at;
+    while (at < text.length && "0123456789".includes(text[at])) at++;
+    if (start === at) return void 0;
+    const value = Number(text.slice(start, at));
+    if (!Number.isSafeInteger(value)) fail();
+    return value;
+  };
+  const units = [];
+  while (at < text.length) {
+    space();
+    if (at === text.length) break;
+    const repeat = integer();
+    space();
+    let size2;
+    if (text[at] === "/") {
+      at++;
+      space();
+      size2 = integer() || void 0;
+      space();
+    }
+    if (text[at++] !== '"') fail();
+    const parts = [];
+    let literal = "";
+    while (at < text.length && text[at] !== '"') {
+      budget.charge();
+      let ch = text[at++];
+      if (ch === "\\") {
+        ch = text[at++] ?? fail();
+        literal += { a: "\x07", b: "\b", f: "\f", n: "\n", r: "\r", t: "	", v: "\v" }[ch] ?? ch;
+      } else if (ch !== "%") literal += ch;
+      else if (text[at] === "%") {
+        at++;
+        literal += "%";
+      } else {
+        if (literal) {
+          parts.push(literal);
+          literal = "";
+        }
+        let flags = "";
+        while (at < text.length && "#0- +".includes(text[at])) flags += text[at++];
+        const width = integer() ?? 0;
+        let precision;
+        if (text[at] === ".") {
+          at++;
+          precision = integer() ?? 0;
+        }
+        let code = text[at++] ?? fail();
+        if (code === "_") {
+          code += text[at++] ?? fail();
+          if (code === "_a" || code === "_A") code += text[at++] ?? fail();
+        }
+        if (!["d", "i", "o", "u", "x", "X", "c", "s", "e", "E", "f", "g", "G", "_c", "_p", "_u", "_ad", "_ao", "_ax", "_Ad", "_Ao", "_Ax"].includes(code)) fail();
+        const bytes2 = code.startsWith("_a") || code.startsWith("_A") ? 0 : size2 ?? (code === "s" ? precision ?? fail() : ["c", "_c", "_p", "_u"].includes(code) ? 1 : 4);
+        if (bytes2 < 0 || code !== "s" && ![0, 1, 2, 4, 8].includes(bytes2)) fail();
+        if (["c", "_c", "_p", "_u"].includes(code) && bytes2 !== 1) fail();
+        if (["e", "E", "f", "g", "G"].includes(code) && bytes2 !== 4 && bytes2 !== 8) fail();
+        budget.check(width, budget.limits.maxBufferedBytes, "format width");
+        budget.check(precision ?? 0, budget.limits.maxBufferedBytes, "format precision");
+        parts.push({ code, flags, width, ...precision === void 0 ? {} : { precision }, bytes: bytes2 });
+      }
+    }
+    if (text[at++] !== '"') fail();
+    if (literal) parts.push(literal);
+    const conversions = parts.filter((part) => typeof part !== "string" && part.bytes > 0);
+    if (size2 !== void 0 && conversions.length > 1) fail();
+    const bytes = size2 ?? conversions.reduce((total, part) => total + part.bytes, 0);
+    budget.check(bytes * (repeat ?? 1), budget.limits.maxBufferedBytes, "format block");
+    units.push({ repeat: repeat ?? 1, explicitRepeat: repeat !== void 0, bytes, parts });
+  }
+  const size = units.reduce((total, unit) => total + unit.bytes * unit.repeat, 0);
+  budget.check(size, budget.limits.maxBufferedBytes, "format block");
+  budget.retain(text.length * 2 + units.length * 64);
+  const finalUnit = units.findLast((unit) => unit.parts.some((part) => typeof part !== "string" && part.code.startsWith("_A")));
+  return { units, size, ...finalUnit ? { finalUnit } : {} };
+}
+var controls = ["nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel", "bs", "ht", "lf", "vt", "ff", "cr", "so", "si", "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb", "can", "em", "sub", "esc", "fs", "gs", "rs", "us"];
+function converted(part, block, offset, used, address, budget) {
+  const { code, flags, width, precision, bytes } = part;
+  budget.buffered(Math.max(width, precision ?? 0) * 6);
+  budget.outputCapacity(width);
+  budget.charge(width);
+  if (bytes && offset >= used) return " ".repeat(width);
+  let value = 0n;
+  for (let i = code === "s" || ["e", "E", "f", "g", "G"].includes(code) ? -1 : bytes - 1; i >= 0; i--) value = value * 256n + BigInt(offset + i < used ? block[offset + i] : 0);
+  let text;
+  if (code === "s") {
+    let end = Math.min(used, offset + bytes, offset + (precision ?? bytes));
+    for (let i = offset; i < end; i++) if (block[i] === 0) {
+      end = i;
+      break;
+    }
+    text = raw(block.subarray(offset, end));
+  } else if (["c", "_p", "_c", "_u"].includes(code)) {
+    const byte = Number(value);
+    text = code === "c" ? String.fromCharCode(byte) : code === "_p" ? byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : "." : code === "_u" ? controls[byte] ?? (byte === 127 ? "del" : byte > 127 ? byte.toString(16) : String.fromCharCode(byte)) : { 0: "\\0", 7: "\\a", 8: "\\b", 9: "\\t", 10: "\\n", 11: "\\v", 12: "\\f", 13: "\\r" }[byte] ?? (byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : byte.toString(8).padStart(3, "0"));
+  } else if (["e", "E", "f", "g", "G"].includes(code)) {
+    const copy = new Uint8Array(bytes);
+    copy.set(block.subarray(offset, Math.min(used, offset + bytes)));
+    const view = new DataView(copy.buffer), number2 = bytes === 4 ? view.getFloat32(0, true) : view.getFloat64(0, true);
+    text = formatFloat(number2, code, flags, precision, budget);
+    if (flags.includes("0") && !flags.includes("-") && Number.isFinite(number2)) {
+      const signed = text.startsWith("-") || text.startsWith("+") || text.startsWith(" ");
+      budget.buffered(Math.max(width, text.length) * 6);
+      budget.outputCapacity(Math.max(width, text.length));
+      text = signed ? text[0] + text.slice(1).padStart(Math.max(0, width - 1), "0") : text.padStart(width, "0");
+    }
+  } else {
+    const addressCode = code.startsWith("_");
+    if (addressCode) value = BigInt(address + offset);
+    else if ((code === "d" || code === "i") && value >= 1n << BigInt(bytes * 8 - 1)) value -= 1n << BigInt(bytes * 8);
+    const kind = code.at(-1);
+    const radix = kind === "x" || kind === "X" ? 16 : kind === "o" ? 8 : 10;
+    const sign = value < 0n ? "-" : (code === "d" || code === "i" || code.endsWith("d")) && flags.includes("+") ? "+" : (code === "d" || code === "i" || code.endsWith("d")) && flags.includes(" ") ? " " : "";
+    budget.outputCapacity(precision ?? 0);
+    budget.charge(precision ?? 0);
+    const digits = (value === 0n && precision === 0 ? "" : (value < 0n ? -value : value).toString(radix)).padStart(precision ?? 0, "0");
+    const prefix = flags.includes("#") ? radix === 16 && value !== 0n ? "0x" : radix === 8 && !digits.startsWith("0") ? "0" : "" : "";
+    text = sign + prefix + digits;
+    if (flags.includes("0") && !flags.includes("-") && precision === void 0) text = sign + prefix + digits.padStart(Math.max(0, width - sign.length - prefix.length), "0");
+    if (kind === "X") text = text.toUpperCase();
+  }
+  return flags.includes("-") ? text.padEnd(width, " ") : text.padStart(width, " ");
+}
+async function formatCustom(format, block, used, address, final, budget) {
+  let offset = 0, result = "";
+  const append = (text) => {
+    budget.buffered((result.length + text.length) * 6);
+    budget.outputCapacity(result.length + text.length);
+    budget.retain(text.length * 2);
+    result += text;
+  };
+  try {
+    for (const [index, unit] of format.units.entries()) {
+      if (final && unit !== format.finalUnit) continue;
+      const isFinal = unit.parts.some((part) => typeof part !== "string" && part.code.startsWith("_A"));
+      if (isFinal !== final) {
+        if (!final) offset += unit.bytes * unit.repeat;
+        continue;
+      }
+      const repeat = !final && index === format.units.length - 1 && !unit.explicitRepeat && unit.bytes && format.size < block.length ? unit.repeat + Math.floor((block.length - format.size) / unit.bytes) : unit.repeat;
+      for (let count = 0; count < repeat; count++) {
+        budget.charge(unit.bytes + 1);
+        const cp = budget.checkpointWork();
+        if (cp) await cp;
+        let position = offset;
+        for (let i = 0; i < unit.parts.length; i++) {
+          const part = unit.parts[i];
+          if (typeof part === "string") {
+            let end = part.length;
+            if (count === repeat - 1 && repeat > 1 && i === unit.parts.length - 1) while (end && " 	".includes(part[end - 1])) end--;
+            append(part.slice(0, end));
+          } else {
+            append(converted(part, block, position, used, address, budget));
+            position += part.bytes;
+          }
+        }
+        offset += unit.bytes;
+      }
+    }
+    return result;
+  } finally {
+    budget.retain(-result.length * 2);
+  }
+}
+
+// packages/safe-bash-command-hexdump/src/options.ts
+var usage = "usage: hexdump [-bcCdovx] [-e fmt] [-f fmt_file] [-n length]\n               [-s skip] [file ...]\n       hd      [-bcdovx]  [-e fmt] [-f fmt_file] [-n length]\n               [-s skip] [file ...]";
+function number(text, skip, dialect) {
+  let offset = 0;
+  while (offset < text.length && " 	\n\r\v\f".includes(text[offset])) offset++;
+  const negative = text[offset] === "-";
+  if (negative || text[offset] === "+") offset++;
+  let base = 10;
+  if ((skip || dialect === "util-linux") && text[offset] === "0") {
+    base = 8;
+    if ((text[offset + 1] === "x" || text[offset + 1] === "X") && "0123456789abcdef".includes((text[offset + 2] ?? "!").toLowerCase())) {
+      base = 16;
+      offset += 2;
+    }
+  }
+  let value = 0;
+  const start = offset;
+  for (; offset < text.length; offset++) {
+    const digit = "0123456789abcdef".indexOf(text[offset].toLowerCase());
+    if (digit < 0 || digit >= base) break;
+    value = value * base + digit;
+    if (!Number.isSafeInteger(value)) throw new HexdumpError(`${text}: numeric value exceeds safe integer range`);
+  }
+  if (negative && value !== 0) throw new HexdumpError(`${text}: bad ${skip ? "skip" : "length"} value`);
+  if (dialect === "util-linux") {
+    const suffix = text.slice(offset);
+    let multiplier = suffix === "b" ? 512 : 1;
+    if (suffix !== "" && suffix !== "b") {
+      const power = "KMGTPEZY".indexOf(suffix[0] === "k" ? "K" : suffix[0]) + 1;
+      const tail = suffix.slice(1);
+      if (!power || tail !== "" && tail !== "B" && tail !== "iB") throw new HexdumpError(`${text}: bad ${skip ? "skip" : "length"} value`);
+      multiplier = (tail === "B" ? 1e3 : 1024) ** power;
+    }
+    if (offset === start || negative) throw new HexdumpError(`${text}: bad ${skip ? "skip" : "length"} value`);
+    value *= multiplier;
+  } else if (skip) value *= { b: 512, k: 1024, m: 1048576 }[text[offset] ?? ""] ?? 1;
+  if (!Number.isSafeInteger(value)) throw new HexdumpError(`${text}: numeric value exceeds safe integer range`);
+  return value;
+}
+function parse(budget, name, dialect) {
+  const args = budget.arguments();
+  const files = [];
+  const custom = [];
+  const formats = name === "hd" ? ["C"] : [];
+  const ordered = [...formats];
+  let verbose = false, ended = false, skip = 0, count = Infinity;
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    if (!ended && argument === "--") {
+      ended = true;
+      continue;
+    }
+    if (ended || argument === "-" || !argument.startsWith("-")) {
+      files.push(argument);
+      if (budget.context.env.POSIXLY_CORRECT !== void 0) ended = true;
+      continue;
+    }
+    for (let offset = 1; offset < argument.length; offset++) {
+      budget.charge();
+      const flag = argument[offset];
+      if (flag === "v") verbose = true;
+      else if (flag === "C" || flag === "b" || flag === "c" || flag === "d" || flag === "o" || flag === "x") {
+        if (name === "hd" && flag === "C") throw new HexdumpError(usage, true);
+        budget.check(custom.length + formats.length + 1, budget.limits.maxFormats, "format count");
+        formats.push(flag);
+        ordered.push(flag);
+      } else if (flag === "n" || flag === "s") {
+        const parameter = argument.slice(offset + 1) || args[++index];
+        if (parameter === void 0) throw new HexdumpError(`${name}: option requires an argument -- '${flag}'
+${usage}`, true);
+        if (flag === "n") count = number(parameter, false, dialect);
+        else skip = number(parameter, true, dialect);
+        break;
+      } else if (flag === "e") {
+        const parameter = argument.slice(offset + 1) || args[++index];
+        if (parameter === void 0) throw new HexdumpError("-e requires a format");
+        budget.check(custom.length + formats.length + 1, budget.limits.maxFormats, "format count");
+        const format = parseCustom(parameter, budget);
+        custom.push(format);
+        ordered.push(format);
+        break;
+      } else if (flag === "f") throw new HexdumpError("-f: format files are not supported");
+      else throw new HexdumpError(`unsupported option -- '${flag}'`);
+    }
+  }
+  if (ordered.length === 0) ordered.push("default");
+  return { ordered, custom, files, formats: formats.length || custom.length ? formats : ["default"], verbose, skip, count, dialect };
+}
+
+export {
+  formatCustom,
+  parse
+};

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

@@ -0,0 +1,35 @@
+import {
+  CurlError
+} from "./chunk-GRBWW4SG.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/url.ts
+init_buffer();
+function curlRequestTarget(text) {
+  const scheme = text.indexOf("://");
+  if (scheme < 0) throw new CurlError(3, "Malformed URL; explicit HTTP(S) scheme required");
+  let start = scheme + 3;
+  while (start < text.length && !"/?#".includes(text[start])) {
+    if (text[start] === "\\") throw new CurlError(3, "Malformed URL authority");
+    start++;
+  }
+  const fragment = text.indexOf("#", start);
+  const target = text.slice(start, fragment < 0 ? void 0 : fragment);
+  const queryIndex = target.indexOf("?");
+  const path = queryIndex < 0 ? target : target.slice(0, queryIndex);
+  const query = queryIndex < 0 ? "" : target.slice(queryIndex);
+  const segments = [];
+  for (const segment of (path || "/").split("/")) {
+    if (segment === "..") {
+      if (segments.length > 1) segments.pop();
+    } else if (segment !== ".") segments.push(segment);
+  }
+  if (path.endsWith("/.") || path.endsWith("/..")) segments.push("");
+  return (segments.join("/") || "/") + query;
+}
+
+export {
+  curlRequestTarget
+};