@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-2P7BLWWI.js

@@ -0,0 +1,272 @@
+import {
+  DocumentBudget,
+  documentByteView
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/argument-json.ts
+var DocxUsageError = class extends Error {
+  code = "usage";
+  exitCode = 2;
+};
+function docxByteLength(bytes) {
+  if (!ArrayBuffer.isView(bytes) || !(bytes instanceof Uint8Array)) throw new DocxUsageError("Expected a byte source.");
+  try {
+    return documentByteView(bytes).byteLength;
+  } catch {
+    throw new DocxUsageError("Expected a byte source.");
+  }
+}
+function copyDocxBytes(bytes) {
+  const result = new Uint8Array(docxByteLength(bytes));
+  Uint8Array.prototype.set.call(result, bytes);
+  return result;
+}
+function decodeDocxText(bytes) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  } catch {
+    throw new DocxUsageError("Expected valid UTF-8 text.");
+  }
+}
+function validText(value) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(++i);
+      if (!(next >= 56320 && next <= 57343)) return false;
+    } else if (code >= 56320 && code <= 57343) return false;
+  }
+  return true;
+}
+var forbidden = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var finite = (value) => typeof value === "number" && Number.isFinite(value);
+function integralTokenUnchanged(token, value) {
+  const lowerExponent = token.indexOf("e"), upperExponent = token.indexOf("E");
+  const exponentAt = lowerExponent < 0 ? upperExponent : lowerExponent;
+  const end = exponentAt < 0 ? token.length : exponentAt;
+  const dot = token.indexOf(".");
+  const exponent = exponentAt < 0 ? 0 : Number(token.slice(exponentAt + 1));
+  const scale = exponent - (dot < 0 ? 0 : end - dot - 1);
+  let digits = 0, leading = 0, trailing = 0, nonzero = false;
+  for (let index = token[0] === "-" ? 1 : 0; index < end; index++) {
+    const digit = token[index];
+    if (digit === ".") continue;
+    digits++;
+    if (digit === "0") {
+      if (!nonzero) leading++;
+      trailing++;
+    } else {
+      nonzero = true;
+      trailing = 0;
+    }
+  }
+  if (!nonzero) return value === 0;
+  if (scale < 0 && -scale > trailing) return true;
+  const length2 = digits - leading + scale;
+  if (!Number.isInteger(value) || length2 < 1 || length2 > 309) return false;
+  const retainedDigits = digits + Math.min(scale, 0);
+  let canonical = "", position = 0;
+  for (let index = token[0] === "-" ? 1 : 0; index < end; index++) {
+    const digit = token[index];
+    if (digit === ".") continue;
+    if (position >= leading && position < retainedDigits) canonical += digit;
+    position++;
+  }
+  if (scale > 0) canonical += "0".repeat(scale);
+  return canonical === BigInt(Math.abs(value)).toString();
+}
+function parseDocxJson(input, budget = new DocumentBudget()) {
+  budget.check("xmlPartBytes", typeof input === "string" ? new TextEncoder().encode(input).length : docxByteLength(input));
+  let source = typeof input === "string" ? input : decodeDocxText(input);
+  if (!validText(source)) throw new DocxUsageError("JSON contains invalid Unicode.");
+  if (source.startsWith("\uFEFF")) source = source.slice(1);
+  let cursor = 0;
+  const fail = () => {
+    throw new DocxUsageError(`Invalid JSON at offset ${cursor}.`);
+  };
+  const whitespace = () => {
+    while (cursor < source.length && " 	\r\n".includes(source[cursor])) cursor++;
+  };
+  const string = () => {
+    const start = cursor++;
+    while (cursor < source.length) {
+      const char = source[cursor++];
+      if (char === "\\") {
+        cursor++;
+        continue;
+      }
+      if (char !== '"') continue;
+      let result2;
+      try {
+        result2 = JSON.parse(source.slice(start, cursor));
+      } catch {
+        return fail();
+      }
+      if (typeof result2 !== "string" || !validText(result2)) return fail();
+      budget.charge("retainedBytes", new TextEncoder().encode(result2).length);
+      return result2;
+    }
+    return fail();
+  };
+  const value = (depth) => {
+    budget.check("xmlDepth", depth);
+    budget.charge("xmlNodes", 1);
+    whitespace();
+    const char = source[cursor];
+    if (char === '"') return string();
+    if (char === "{" || char === "[") {
+      cursor++;
+      const array2 = char === "[";
+      const close = array2 ? "]" : "}";
+      const result3 = {};
+      const items = [];
+      const keys = /* @__PURE__ */ new Set();
+      whitespace();
+      if (source[cursor] === close) {
+        cursor++;
+        return array2 ? items : result3;
+      }
+      while (cursor < source.length) {
+        if (array2) items.push(value(depth + 1));
+        else {
+          whitespace();
+          if (source[cursor] !== '"') return fail();
+          const key = string();
+          if (forbidden.has(key) || keys.has(key)) return fail();
+          keys.add(key);
+          whitespace();
+          if (source[cursor++] !== ":") return fail();
+          result3[key] = value(depth + 1);
+        }
+        whitespace();
+        const next = source[cursor++];
+        if (next === close) return array2 ? items : result3;
+        if (next !== ",") return fail();
+      }
+      return fail();
+    }
+    const start = cursor;
+    while (cursor < source.length && !" 	\r\n,]}".includes(source[cursor])) cursor++;
+    if (cursor === start) return fail();
+    budget.charge("work", (cursor - start) * 2 + 1024);
+    budget.charge("retainedBytes", (cursor - start) * 2 + 2048);
+    const token = source.slice(start, cursor);
+    let result2;
+    try {
+      result2 = JSON.parse(token);
+    } catch {
+      return fail();
+    }
+    if (result2 === null || typeof result2 === "boolean" || finite(result2) && integralTokenUnchanged(token, result2)) return result2;
+    return fail();
+  };
+  const result = value(1);
+  whitespace();
+  if (cursor !== source.length) return fail();
+  return result;
+}
+function array(value) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return false;
+  const keys = Reflect.ownKeys(value);
+  if (keys.length !== value.length + 1) return false;
+  for (let index = 0; index < value.length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor || !("value" in descriptor)) return false;
+  }
+  return true;
+}
+function record(value, allowed, required = []) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return false;
+  return Reflect.ownKeys(value).every((key) => typeof key === "string" && allowed.includes(key) && Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), "value")) && required.every((key) => Object.hasOwn(value, key) && value[key] !== void 0);
+}
+var text = (value) => typeof value === "string" && validText(value);
+var identifier = (value) => text(value) && value.length > 0 && !value.includes("\0");
+function validFontName(value) {
+  if (!identifier(value)) return false;
+  for (const char of value) {
+    const code = char.codePointAt(0);
+    if (code < 32 || code >= 127 && code <= 159) return false;
+  }
+  return true;
+}
+function optional(value, key, check) {
+  return value[key] === void 0 || check(value[key]);
+}
+function length(value) {
+  return record(value, ["value", "unit"], ["value", "unit"]) && finite(value.value) && Math.abs(value.value) <= Number.MAX_SAFE_INTEGER && ["emu", "in", "cm", "mm", "pt", "twip"].includes(value.unit);
+}
+var tableKeys = ["width", "style", "columnWidths", "autofit", "repeatHeader", "headerRows", "allowRowSplit", "rowHeight", "heightRule", "borders", "shading", "cellMargin", "rowOptions"];
+var color = (value) => typeof value === "string" && value.length === 6 && [...value].every((c) => "0123456789abcdefABCDEF".includes(c));
+var heightRule = (value) => record(value, ["enum", "name"], ["enum", "name"]) && value.enum === "WD_ROW_HEIGHT_RULE" && ["AUTO", "AT_LEAST", "EXACTLY"].includes(value.name);
+var shading = (value) => record(value, ["fill", "color", "pattern"], ["fill", "pattern"]) && color(value.fill) && optional(value, "color", color) && ["clear", "solid", "pct5", "pct10", "pct20", "pct25", "pct50", "pct75"].includes(value.pattern);
+var borders = (value) => record(value, ["top", "left", "bottom", "right", "insideH", "insideV"]) && Object.values(value).every((v) => v === void 0 || record(v, ["style", "width", "color", "space"], ["style", "width", "color"]) && ["none", "single", "double", "dotted", "dashed"].includes(v.style) && length(v.width) && color(v.color) && optional(v, "space", length));
+var rowOptions = (value) => record(value, ["repeatHeader", "allowRowSplit", "height", "heightRule"]) && optional(value, "repeatHeader", (v) => typeof v === "boolean") && optional(value, "allowRowSplit", (v) => typeof v === "boolean") && optional(value, "height", length) && optional(value, "heightRule", heightRule);
+function tableFormat(value) {
+  return optional(value, "width", length) && optional(value, "style", identifier) && optional(value, "columnWidths", (v) => array(v) && v.every(length)) && ["autofit", "repeatHeader", "allowRowSplit"].every((key) => optional(value, key, (v) => typeof v === "boolean")) && optional(value, "headerRows", (v) => Number.isSafeInteger(v) && Number(v) >= 0) && optional(value, "rowHeight", length) && optional(value, "heightRule", heightRule) && optional(value, "borders", borders) && optional(value, "shading", shading) && optional(value, "cellMargin", length) && optional(value, "rowOptions", (v) => array(v) && v.every(rowOptions));
+}
+function validateOriginalDocumentContent(value) {
+  const ancestors = /* @__PURE__ */ new Set();
+  function blocks(value2) {
+    if (!array(value2) || ancestors.has(value2)) return false;
+    ancestors.add(value2);
+    const result = value2.every(block);
+    ancestors.delete(value2);
+    return result;
+  }
+  function block(value2) {
+    if (!record(value2, ["kind", "text", "level", "runs", "rows", ...tableKeys], ["kind"]) || ancestors.has(value2)) return false;
+    ancestors.add(value2);
+    let result = false;
+    if (value2.kind === "paragraph") result = record(value2, ["kind", "text", "style", "level", "runs"], ["kind"]) && !(value2.text !== void 0 && value2.runs !== void 0) && !(value2.style !== void 0 && value2.level !== void 0) && optional(value2, "text", text) && optional(value2, "style", identifier) && optional(value2, "level", (item) => Number.isSafeInteger(item) && Number(item) >= 0 && Number(item) <= 9) && optional(value2, "runs", (item) => array(item) && item.every(run));
+    if (value2.kind === "table") {
+      const rows = value2.rows;
+      result = record(value2, ["kind", "rows", ...tableKeys], ["kind", "rows"]) && tableFormat(value2) && array(rows) && rows.length > 0 && array(rows[0]) && rows[0].length > 0 && rows.every((row) => array(row) && row.length === rows[0].length && row.every((cell) => record(cell, ["blocks", "borders", "shading", "margins"], ["blocks"]) && optional(cell, "borders", borders) && optional(cell, "shading", shading) && optional(cell, "margins", (v) => record(v, ["top", "left", "bottom", "right"]) && Object.values(v).every((n) => n === void 0 || length(n))) && blocks(cell.blocks)));
+    }
+    ancestors.delete(value2);
+    return result;
+  }
+  function run(value2) {
+    const nullableBoolean = (item) => item === null || typeof item === "boolean";
+    return record(value2, ["text", "bold", "italic", "underline", "style"], ["text"]) && text(value2.text) && optional(value2, "bold", nullableBoolean) && optional(value2, "italic", nullableBoolean) && optional(value2, "style", identifier) && optional(value2, "underline", (item) => nullableBoolean(item) || record(item, ["enum", "name"], ["enum", "name"]) && item.enum === "WD_UNDERLINE" && ["NONE", "SINGLE", "WORDS", "DOUBLE", "DOTTED", "THICK", "DASH", "DOT_DASH", "DOT_DOT_DASH", "WAVY", "DOTTED_HEAVY", "DASH_HEAVY", "DOT_DASH_HEAVY", "DOT_DOT_DASH_HEAVY", "WAVY_HEAVY", "DASH_LONG", "WAVY_DOUBLE", "DASH_LONG_HEAVY"].includes(item.name));
+  }
+  const page = (item) => record(item, ["width", "height", "orientation", "margins"]) && optional(item, "width", length) && optional(item, "height", length) && optional(item, "orientation", (v) => v === "portrait" || v === "landscape") && optional(item, "margins", (v) => record(v, ["top", "right", "bottom", "left", "header", "footer", "gutter"]) && Object.values(v).every((n) => n === void 0 || length(n)));
+  const style = (item) => record(item, ["name", "type", "font", "size", "bold", "italic"], ["name", "type"]) && identifier(item.name) && ["paragraph", "character", "table"].includes(item.type) && optional(item, "font", validFontName) && optional(item, "size", length) && optional(item, "bold", (v) => typeof v === "boolean") && optional(item, "italic", (v) => typeof v === "boolean");
+  const theme = (item) => record(item, ["name", "majorFont", "minorFont", "colors"], ["name", "majorFont", "minorFont"]) && identifier(item.name) && validFontName(item.majorFont) && validFontName(item.minorFont) && optional(item, "colors", (v) => record(v, ["dark1", "light1", "dark2", "light2", "accent1", "accent2", "accent3", "accent4", "accent5", "accent6", "hyperlink", "followedHyperlink"]) && Object.values(v).every((color2) => color2 === void 0 || typeof color2 === "string" && color2.length === 6 && [...color2].every((c) => "0123456789abcdefABCDEF".includes(c))));
+  return record(value, ["version", "blocks", "page", "styles", "theme"], ["version", "blocks"]) && value.version === 1 && blocks(value.blocks) && optional(value, "page", page) && optional(value, "styles", (v) => array(v) && v.every(style)) && optional(value, "theme", theme);
+}
+function validateTemplateData(value, nested = false) {
+  const pending = [];
+  if (array(value)) for (const item of value) pending.push({ value: item });
+  else pending.push({ value });
+  const active = /* @__PURE__ */ new Set();
+  while (pending.length) {
+    const frame = pending.pop(), current = frame.value;
+    if (frame.leave) {
+      active.delete(current);
+      continue;
+    }
+    if (!record(current, ["values"], ["values"]) || !array(current.values) || active.has(current)) return false;
+    active.add(current);
+    pending.push({ value: current, leave: true });
+    const seen = /* @__PURE__ */ new Set();
+    for (const item of current.values) {
+      if (!record(item, ["binding", "value"], ["binding", "value"]) || !identifier(item.binding) || seen.has(item.binding)) return false;
+      seen.add(item.binding);
+      if (text(item.value) || typeof item.value === "boolean" || finite(item.value)) continue;
+      if (!nested || !array(item.value)) return false;
+      for (const child of item.value) pending.push({ value: child });
+    }
+  }
+  return true;
+}
+
+export {
+  DocxUsageError,
+  docxByteLength,
+  copyDocxBytes,
+  decodeDocxText,
+  parseDocxJson,
+  validFontName,
+  validateOriginalDocumentContent,
+  validateTemplateData
+};

package/dist/safe-bash/command-chunks/chunk-2PSVE7I5.js

@@ -0,0 +1,101 @@
+import {
+  MarkupCompatibility,
+  isXmlLocalName,
+  relationshipCompatibilityProfile,
+  relationshipNamespace
+} from "./chunk-GZ2N24A2.js";
+import {
+  isAbsoluteRelationshipType,
+  isRelationshipTargetReference
+} from "./chunk-WAKYUXVQ.js";
+import {
+  InvalidPackageError,
+  UnsupportedProfileError
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocumentBudget
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/relationship-xml.ts
+function relationshipAttribute(element, name) {
+  const value = element.attributes.find((attribute) => !attribute.namespace && attribute.localName === name)?.value;
+  if (value === void 0 || name === "TargetMode") return value;
+  return collapseRelationshipScalar(value);
+}
+function collapseRelationshipScalar(value) {
+  let result = "", space = false;
+  for (const char of value) {
+    if (" 	\r\n".includes(char)) space = result.length > 0;
+    else {
+      if (space) result += " ";
+      result += char;
+      space = false;
+    }
+  }
+  return result;
+}
+function relationshipXmlIds(root, budget) {
+  budget.charge("retainedBytes", 8);
+  const ids = /* @__PURE__ */ new Set(), pending = [root];
+  while (pending.length) {
+    const node = pending.pop();
+    budget.charge("work", 1 + node.children.length + node.attributes.reduce((sum, attribute) => sum + attribute.value.length, 0));
+    if (node.namespace === relationshipNamespace && node.localName === "Relationship") {
+      const id = relationshipAttribute(node, "Id");
+      if (id !== void 0 && !ids.has(id)) {
+        budget.charge("retainedBytes", 32 + id.length * 2);
+        ids.add(id);
+      }
+    }
+    if (node.children.length) budget.charge("retainedBytes", node.children.length * 8);
+    for (const child of node.children) pending.push(child);
+  }
+  return ids;
+}
+function relationshipXmlRows(root, budget = new DocumentBudget(), part) {
+  const view = new MarkupCompatibility(root, relationshipCompatibilityProfile, budget);
+  budget.charge("work", view.branches.length);
+  if (view.branches.some((branch) => branch.selected === void 0))
+    throw new UnsupportedProfileError("Active alternate content has no eligible choice or fallback.");
+  const invalid = (index) => {
+    throw new InvalidPackageError("Invalid relationship metadata.", part, index ? `/Relationship[${index}]` : "/Relationships[1]");
+  };
+  const roots = view.content.filter((node) => "source" in node);
+  if (roots.length !== 1 || roots[0].source !== root || root.namespace !== relationshipNamespace || root.localName !== "Relationships") invalid(0);
+  const attributes = (node, allowed, index) => {
+    budget.charge("work", node.attributes.length);
+    for (const attribute of node.attributes) {
+      if (attribute.namespace === "http://www.w3.org/2000/xmlns/") continue;
+      if (attribute.namespace || !allowed.includes(attribute.localName)) invalid(index);
+    }
+  };
+  const document = roots[0];
+  attributes(document, [], 0);
+  const rows = [], ids = /* @__PURE__ */ new Set();
+  for (const node of document.content) {
+    budget.charge("work", 1);
+    if (!("source" in node)) {
+      if (node.kind === "text" || node.kind === "cdata") budget.charge("work", node.text.length);
+      if ((node.kind === "text" || node.kind === "cdata") && [...node.text].some((char) => !" 	\r\n".includes(char))) invalid(0);
+      continue;
+    }
+    const index = rows.length + 1, element = node.source;
+    budget.charge("work", node.content.length + element.attributes.reduce((sum, attribute) => sum + attribute.value.length, 0));
+    if (element.namespace !== relationshipNamespace || element.localName !== "Relationship" || node.content.some((child) => "source" in child)) invalid(index);
+    attributes(node, ["Id", "Type", "Target", "TargetMode"], index);
+    const rId = relationshipAttribute(element, "Id"), reltype = relationshipAttribute(element, "Type"), target_ref = relationshipAttribute(element, "Target");
+    const mode = relationshipAttribute(element, "TargetMode") ?? "Internal";
+    if (rId === void 0 || !isXmlLocalName(rId) || ids.has(rId) || reltype === void 0 || !isAbsoluteRelationshipType(reltype) || target_ref === void 0 || !["External", "Internal"].includes(mode) || mode === "External" && !isRelationshipTargetReference(target_ref)) invalid(index);
+    ids.add(rId);
+    budget.charge("retainedBytes", 160 + (rId.length + reltype.length + target_ref.length) * 2);
+    rows.push(Object.freeze({ element, rId, reltype, target_ref, is_external: mode === "External" }));
+  }
+  return Object.freeze(rows);
+}
+
+export {
+  relationshipAttribute,
+  collapseRelationshipScalar,
+  relationshipXmlIds,
+  relationshipXmlRows
+};