@poe-platform/safe-bash 0.1.799 → 0.1.800

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

@@ -0,0 +1,331 @@
+import {
+  JqError,
+  JqLimitError
+} from "./chunk-QP4R6GLA.js";
+import {
+  isNumber,
+  numberValue
+} from "./chunk-UCL3PNXL.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-query-engine/src/dates.ts
+init_buffer();
+function fromDateIso8601(input) {
+  if (typeof input !== "string") throw new JqError("strptime/1 requires string inputs and arguments");
+  const mismatch = () => new JqError(`date ${JSON.stringify(input)} does not match format "%Y-%m-%dT%H:%M:%SZ"`);
+  const parts = input.split("T");
+  if (parts.length !== 2 || !parts[1].endsWith("Z")) throw mismatch();
+  const date = parts[0].split("-");
+  const time = parts[1].slice(0, -1).split(":");
+  const fields = [...date, ...time];
+  if (date.length !== 3 || time.length !== 3 || fields.some((field, index) => field.length === 0 || field.length > (index === 0 ? 4 : 2) || [...field].some((character) => !"0123456789".includes(character)))) throw mismatch();
+  const [year, month, day, hour, minute, second] = fields.map(Number);
+  if (month < 1 || month > 12 || day > 31 || hour > 23 || minute > 59 || second > 60) throw mismatch();
+  if (year < 1900) throw new JqError("invalid gmtime representation");
+  return Date.UTC(year, month - 1, day, hour, minute, second) / 1e3;
+}
+function toDateIso8601(input) {
+  if (!isNumber(input)) throw new JqError("strftime/1 requires parsed datetime inputs");
+  const date = new Date(Math.trunc(numberValue(input)) * 1e3);
+  if (!Number.isFinite(date.getTime())) throw new JqError("error converting number of seconds since epoch to datetime");
+  const year = String(date.getUTCFullYear()).padStart(4, "0");
+  const fields = [date.getUTCMonth() + 1, date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds()].map((value) => String(value).padStart(2, "0"));
+  return `${year}-${fields[0]}-${fields[1]}T${fields[2]}:${fields[3]}:${fields[4]}Z`;
+}
+var weekdays = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+var months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var compoundFormats = { F: "%Y-%m-%d", D: "%m/%d/%y", R: "%H:%M", T: "%H:%M:%S", r: "%I:%M:%S %p", c: "%a %b %e %T %Y", x: "%m/%d/%y", X: "%T", "+": "%a %b %e %T %Z %Y" };
+function utcDate(fields) {
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(fields[0], fields[1], fields[2]);
+  date.setUTCHours(fields[3], fields[4], Math.trunc(fields[5]), 0);
+  return date;
+}
+function datetime(input, name) {
+  if (!Array.isArray(input) || input.length < 8 || input.slice(0, 8).some((value) => !isNumber(value))) throw new JqError(`${name} requires parsed datetime inputs`);
+  return input.slice(0, 8).map((value) => {
+    if (!isNumber(value)) throw new JqError(`${name} requires parsed datetime inputs`);
+    return Math.trunc(numberValue(value));
+  });
+}
+function gmtime(input) {
+  if (!isNumber(input)) throw new JqError("gmtime() requires numeric inputs");
+  const seconds = numberValue(input);
+  const date = new Date(Math.trunc(seconds) * 1e3);
+  if (!Number.isFinite(date.getTime())) throw new JqError("error converting number of seconds since epoch to datetime");
+  const fields = [date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds() + seconds - Math.floor(seconds), date.getUTCDay()];
+  const start = utcDate([fields[0], 0, 1, 0, 0, 0]);
+  fields.push(Math.floor((date.getTime() - start.getTime()) / 864e5));
+  return fields;
+}
+function mktime(input) {
+  const fields = datetime(input, "mktime");
+  const seconds = utcDate(fields).getTime() / 1e3;
+  if (!Number.isFinite(seconds) || fields[0] < 1900 || seconds === -1) throw new JqError("invalid gmtime representation");
+  if (seconds === -2) throw new JqError("mktime not supported on this platform");
+  return seconds;
+}
+function strftime(input, format, budget) {
+  if (typeof format !== "string") throw new JqError("strftime/1 requires a string format");
+  const fields = isNumber(input) ? gmtime(input) : datetime(input, "strftime/1");
+  const [year, month, day, hour, minute, second, weekday, yearday] = fields;
+  const pad = (value, width = 2, fill = "0") => String(Math.trunc(value)).padStart(width, fill);
+  const date = utcDate(fields);
+  const thursday = new Date(date);
+  thursday.setUTCDate(date.getUTCDate() + 3 - (date.getUTCDay() + 6) % 7);
+  const isoYear = thursday.getUTCFullYear();
+  const isoWeek = 1 + Math.floor((thursday.getTime() - utcDate([isoYear, 0, 1, 0, 0, 0]).getTime()) / 6048e5);
+  const directives = {
+    Y: pad(year, 4),
+    y: pad(year % 100),
+    C: pad(Math.floor(year / 100)),
+    m: pad(month + 1),
+    d: pad(day),
+    e: pad(day, 2, " "),
+    H: pad(hour),
+    k: pad(hour, 2, " "),
+    I: pad(hour % 12 || 12),
+    l: pad(hour % 12 || 12, 2, " "),
+    M: pad(minute),
+    S: pad(second),
+    p: hour < 12 ? "AM" : "PM",
+    P: hour < 12 ? "am" : "pm",
+    a: weekdays[weekday]?.slice(0, 3) ?? "?",
+    A: weekdays[weekday] ?? "?",
+    b: months[month]?.slice(0, 3) ?? "?",
+    h: months[month]?.slice(0, 3) ?? "?",
+    B: months[month] ?? "?",
+    j: pad(yearday + 1, 3),
+    w: String(weekday),
+    u: String(weekday || 7),
+    U: pad(Math.floor((yearday + 7 - weekday) / 7)),
+    W: pad(Math.floor((yearday + 7 - (weekday + 6) % 7) / 7)),
+    G: pad(isoYear, 4),
+    g: pad(isoYear % 100),
+    V: pad(isoWeek),
+    s: String(date.getTime() / 1e3),
+    z: "+0000",
+    Z: "UTC",
+    "%": "%",
+    n: "\n",
+    t: "	"
+  };
+  const fragments = [];
+  let bytes = 2;
+  const emit = (text) => {
+    bytes += budget.value(text) - 2;
+    if (bytes > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+    fragments.push(text);
+  };
+  const append = (source) => {
+    for (let index = 0; index < source.length; index++) {
+      budget.step();
+      if (source[index] !== "%") {
+        const character = String.fromCodePoint(source.codePointAt(index));
+        emit(character);
+        index += character.length - 1;
+      } else {
+        let directive = source[++index] ?? "%";
+        if (directive === "E" || directive === "O") directive = source[++index] ?? "%";
+        if (Object.hasOwn(compoundFormats, directive)) append(compoundFormats[directive]);
+        else emit(directives[directive] ?? directive);
+      }
+    }
+  };
+  append(format);
+  return fragments.join("");
+}
+function strptime(input, format, budget) {
+  if (typeof input !== "string" || typeof format !== "string") throw new JqError("strptime/1 requires string inputs and arguments");
+  const mismatch = () => new JqError(`date ${JSON.stringify(input)} does not match format ${JSON.stringify(format)}`);
+  const fields = [1900, 0, 0, 0, 0, 0, 0, -1];
+  let position = 0;
+  let afternoon;
+  let ordinal;
+  let century;
+  let shortYear;
+  let week;
+  let hasDate = false;
+  let zoneMinutes;
+  const whitespace = (character) => " 	\r\n\v\f".includes(character);
+  const skipSpace = () => {
+    while (position < input.length && whitespace(input[position])) {
+      budget.step();
+      position++;
+    }
+  };
+  const numeric = (width, min, max) => {
+    skipSpace();
+    const start = position;
+    while (position - start < width && position < input.length && "0123456789".includes(input[position])) position++;
+    const value = Number(input.slice(start, position));
+    if (position === start || value < min || value > max) throw mismatch();
+    return value;
+  };
+  const named = (names) => {
+    for (let index = 0; index < names.length; index++) {
+      const name = names[index].toLowerCase();
+      for (const text of [name, name.slice(0, 3)]) if (input.slice(position, position + text.length).toLowerCase() === text) {
+        position += text.length;
+        return index;
+      }
+    }
+    throw mismatch();
+  };
+  const consume = (source) => {
+    for (let index = 0; index < source.length; index++) {
+      budget.step();
+      const character = source[index];
+      if (whitespace(character)) {
+        skipSpace();
+        continue;
+      }
+      if (character !== "%") {
+        if (input[position++] !== character) throw mismatch();
+        continue;
+      }
+      let directive = source[++index];
+      if (directive === "E" || directive === "O") directive = source[++index];
+      if (directive && Object.hasOwn(compoundFormats, directive)) {
+        consume(compoundFormats[directive]);
+        continue;
+      }
+      switch (directive) {
+        case "%":
+          if (input[position++] !== "%") throw mismatch();
+          break;
+        case "Y":
+          fields[0] = numeric(4, 0, 9999);
+          break;
+        case "y":
+          shortYear = numeric(2, 0, 99);
+          fields[0] = (shortYear <= 68 ? 2e3 : 1900) + shortYear;
+          break;
+        case "C":
+          century = numeric(2, 0, 99);
+          break;
+        case "m":
+          hasDate = true;
+          fields[1] = numeric(2, 1, 12) - 1;
+          break;
+        case "d":
+        case "e":
+          hasDate = true;
+          fields[2] = numeric(2, 1, 31);
+          break;
+        case "H":
+        case "k":
+          fields[3] = numeric(2, 0, 23);
+          break;
+        case "I":
+        case "l":
+          fields[3] = numeric(2, 1, 12) % 12;
+          break;
+        case "M":
+          fields[4] = numeric(2, 0, 59);
+          break;
+        case "S":
+          fields[5] = numeric(2, 0, 60);
+          break;
+        case "s": {
+          const seconds = numeric(16, 0, Number.MAX_SAFE_INTEGER);
+          fields.splice(0, 8, ...gmtime(seconds));
+          hasDate = true;
+          break;
+        }
+        case "U":
+        case "W":
+          week = { number: numeric(2, 0, 53), monday: directive === "W" };
+          break;
+        case "j":
+          ordinal = numeric(3, 1, 366) - 1;
+          break;
+        case "a":
+        case "A":
+          fields[6] = named(weekdays);
+          break;
+        case "b":
+        case "B":
+        case "h":
+          hasDate = true;
+          fields[1] = named(months);
+          break;
+        case "w":
+          fields[6] = numeric(1, 0, 6);
+          break;
+        case "u":
+          fields[6] = numeric(1, 1, 7) % 7;
+          break;
+        case "p": {
+          const text = input.slice(position, position + 2).toLowerCase();
+          if (text !== "am" && text !== "pm") throw mismatch();
+          afternoon = text === "pm";
+          position += 2;
+          break;
+        }
+        case "n":
+        case "t":
+          skipSpace();
+          break;
+        case "z": {
+          if (input[position] === "Z") {
+            position++;
+            zoneMinutes = 0;
+            break;
+          }
+          if (input[position] !== "+" && input[position] !== "-") throw mismatch();
+          const sign = input[position++] === "-" ? -1 : 1;
+          const hours = numeric(2, 0, 23);
+          if (input[position] === ":") position++;
+          zoneMinutes = sign * (hours * 60 + numeric(2, 0, 59));
+          break;
+        }
+        case "Z": {
+          while (position < input.length && "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".includes(input[position])) {
+            budget.step();
+            position++;
+          }
+          break;
+        }
+        default:
+          throw mismatch();
+      }
+    }
+  };
+  consume(format);
+  if (century !== void 0) fields[0] = century * 100 + (shortYear ?? 0);
+  if (afternoon) fields[3] += 12;
+  if (week) {
+    const janFirst = utcDate([fields[0], 0, 1, 0, 0, 0]).getUTCDay();
+    const shift = week.monday ? 6 : 0;
+    ordinal = week.number * 7 + (fields[6] + shift) % 7 - (janFirst + shift) % 7;
+    if ((janFirst + shift) % 7 === 0) ordinal -= 7;
+  }
+  if (ordinal !== void 0) {
+    hasDate = true;
+    const date2 = utcDate([fields[0], 0, ordinal + 1, 0, 0, 0]);
+    fields[1] = date2.getUTCMonth();
+    fields[2] = date2.getUTCDate();
+  }
+  const date = utcDate(fields);
+  if (hasDate) fields[6] = date.getUTCDay();
+  fields[7] = Math.floor((utcDate([fields[0], fields[1], fields[2], 0, 0, 0]).getTime() - utcDate([fields[0], 0, 1, 0, 0, 0]).getTime()) / 864e5);
+  if (zoneMinutes !== void 0) fields.splice(0, 8, ...gmtime(date.getTime() / 1e3 - zoneMinutes * 60));
+  const result = fields;
+  if (position < input.length) {
+    if (!whitespace(input[position])) throw mismatch();
+    result.push(input.slice(position));
+  }
+  return result;
+}
+
+export {
+  fromDateIso8601,
+  toDateIso8601,
+  gmtime,
+  mktime,
+  strftime,
+  strptime
+};

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

@@ -0,0 +1,11 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/crc.ts
+init_buffer();
+import { crcTable } from "../../safe-bash-compression-engine/crc.js";
+
+export {
+  crcTable
+};

package/dist/safe-bash/command-chunks/{chunk-UI32HWGS.js → chunk-HMOZ6XVJ.js}

@@ -1,7 +1,7 @@
 import {
   JqError,
   JqLimitError
-} from "./chunk-VVI4Z73I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-AVSPNLWV.js → chunk-I237SNW5.js}

@@ -1,6 +1,6 @@
 import {
   SearchError
-} from "./chunk-J4PEQWSF.js";
+} from "./chunk-VGG2DL5Q.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-ZS3QPNUL.js → chunk-IR2BY7EL.js}

@@ -1,9 +1,9 @@
 import {
   escape
-} from "./chunk-XS3PGJU2.js";
+} from "./chunk-XJXU3VVH.js";
 import {
   XmlQueryError
-} from "./chunk-KVFCSLKK.js";
+} from "./chunk-NXEQ3ESQ.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -37,7 +37,7 @@ function declaration(source) {
   }
   return result + "?>\n";
 }
-async function attributes(element, inherited, budget) {
+async function attributes(element, inherited, budget, exclusive) {
   const selected = [];
   for (const attribute of element.attributes) {
     {
@@ -52,6 +52,18 @@ async function attributes(element, inherited, budget) {
       if (_p) await _p;
     }
     if (prefix === "xml") continue;
+    if (exclusive) {
+      const colon = element.name.indexOf(":");
+      let used = prefix === (colon < 0 ? "" : element.name.slice(0, colon));
+      for (const attribute of element.attributes) {
+        const p = budget.tick(attribute.name.length + 1);
+        if (p) await p;
+        if (attribute.namespace === xmlns) continue;
+        const at = attribute.name.indexOf(":");
+        if (at > 0 && attribute.name.slice(0, at) === prefix) used = true;
+      }
+      if (!used) continue;
+    }
     if (uri === (inherited.get(prefix) ?? "")) continue;
     selected.push({
       name: prefix ? `xmlns:${prefix}` : "xmlns",
@@ -73,7 +85,7 @@ async function attributes(element, inherited, budget) {
   return selected;
 }
 async function* serializeDocument(root, mode, budget, format = mode === "format") {
-  const canonical = mode === "c14n";
+  const canonical = mode !== "format";
   const escaping = { canonical, ascii: !canonical && !root.declaration?.includes("encoding") };
   if (canonical) {
     const elements = [root];
@@ -179,7 +191,7 @@ async function* serializeDocument(root, mode, budget, format = mode === "format"
         } else if (child.kind === "cdata") mixed = true;
         content.push(child);
       }
-      const ordered = canonical ? await attributes(current, frame.namespaces, budget) : [];
+      const ordered = canonical ? await attributes(current, frame.namespaces, budget, mode === "exc-c14n") : [];
       if (!canonical) {
         for (const namespace of [true, false])
           for (const attribute of current.attributes) {
@@ -206,7 +218,10 @@ async function* serializeDocument(root, mode, budget, format = mode === "format"
       }
       yield ">";
       const indent = !canonical && format && !mixed && content.length > 0;
-      const childNamespaces = canonical ? current.namespaces : frame.namespaces;
+      const childNamespaces = new Map(frame.namespaces);
+      if (canonical) for (const attribute of ordered) {
+        if (attribute.namespace === xmlns) childNamespaces.set(attribute.localName, attribute.value);
+      }
       const childFrame = { depth: frame.depth + 1, namespaces: childNamespaces, preserveSpace };
       pending.push({
         ...frame,

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

@@ -0,0 +1,42 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/types.ts
+init_buffer();
+var defaultNetworkLimits = Object.freeze({
+  maxUploadBytes: Infinity,
+  maxDownloadBytes: Infinity,
+  maxBufferBytes: Infinity,
+  maxHeaderBytes: Infinity,
+  maxRedirects: Infinity,
+  maxRetries: Infinity,
+  maxUrls: Infinity,
+  maxTimeMs: Infinity,
+  maxTotalTimeMs: Infinity
+});
+var cloudflareWorkerNetworkLimits = Object.freeze({
+  maxUploadBytes: 4 * 1024 * 1024,
+  maxDownloadBytes: 4 * 1024 * 1024,
+  maxBufferBytes: 1024 * 1024,
+  maxHeaderBytes: 32 * 1024,
+  maxRedirects: 2,
+  maxRetries: 1,
+  maxUrls: 8,
+  maxTimeMs: 1e4,
+  maxTotalTimeMs: 1e4
+});
+var CurlError = class extends Error {
+  constructor(exitCode, message) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CurlError";
+  }
+  exitCode;
+};
+
+export {
+  defaultNetworkLimits,
+  cloudflareWorkerNetworkLimits,
+  CurlError
+};

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

@@ -0,0 +1,94 @@
+import {
+  curlRequestTarget
+} from "./chunk-RVLO4DYT.js";
+import {
+  CurlError
+} from "./chunk-IYPAQ7PH.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/fetch-transport.ts
+init_buffer();
+function requestBody(source, signal) {
+  if (!source) return void 0;
+  const iterator = source[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        signal.throwIfAborted();
+        const next = await iterator.next();
+        if (next.done) controller.close();
+        else controller.enqueue(next.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      await iterator.return?.(reason);
+    }
+  });
+}
+function createFetchTransport(options = {}) {
+  const fetchRequest = options.fetch ?? globalThis.fetch;
+  if (typeof fetchRequest !== "function") throw new TypeError("Fetch is unavailable");
+  return async (input) => {
+    input.signal.throwIfAborted();
+    if (input.ca !== void 0) throw new CurlError(2, "Fetch transport cannot enforce request CA trust");
+    if (input.httpVersion !== void 0) throw new CurlError(2, "Transport cannot enforce requested HTTP version");
+    if (input.ignoreContentLength) throw new CurlError(2, "Transport cannot enforce ignored Content-Length");
+    const url = new URL(input.url);
+    if (url.protocol !== "http:" && url.protocol !== "https:") throw new CurlError(1, "Unsupported protocol");
+    if (input.denyPrivateNetworks === true) throw new CurlError(7, "Fetch transport cannot enforce private-network denial");
+    if (curlRequestTarget(input.url) !== url.pathname + url.search) {
+      throw new CurlError(2, "Fetch transport cannot preserve the literal request target");
+    }
+    const stopped = new AbortController();
+    const signal = AbortSignal.any([input.signal, stopped.signal]);
+    const body = requestBody(input.body, signal);
+    const headers = new Headers();
+    for (const [name, value] of input.headers) headers.append(name, value);
+    const request = new Request(url, {
+      method: input.method,
+      headers,
+      body,
+      credentials: "omit",
+      redirect: "manual",
+      signal,
+      ...body ? { duplex: "half" } : {}
+    });
+    let response;
+    const dispose = async () => {
+      stopped.abort();
+      if (response?.body) await response.body.cancel().catch(() => void 0);
+    };
+    input.registerCleanup?.(dispose);
+    response = await fetchRequest(request);
+    const reader = response.body?.getReader();
+    const responseBody = reader ? (async function* () {
+      try {
+        while (true) {
+          input.signal.throwIfAborted();
+          const next = await reader.read();
+          if (next.done) return;
+          yield next.value;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    })() : (async function* () {
+    })();
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: [...response.headers.entries()],
+      body: responseBody,
+      contentDecoded: options.contentDecoded ?? true,
+      dispose
+    };
+  };
+}
+
+export {
+  createFetchTransport
+};