@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,11 @@
+// packages/safe-bash-command-ssconvert/dist/chunks/chunk-VYPKNMBU.js
+import { chartDataTypes as c, chartPlugins as r, sheetObjectTypes as s, sheetObjects as a } from "../../spreadsheet-engine/objects/index.js";
+import { objectRectangle as p } from "../../spreadsheet-engine/objects/layout.js";
+
+export {
+  c,
+  r,
+  s,
+  a,
+  p
+};

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

@@ -0,0 +1,127 @@
+import {
+  normalizePartName
+} from "./chunk-WAKYUXVQ.js";
+import {
+  isXmlContentType
+} from "./chunk-MWAAMNAM.js";
+import {
+  InputTypeError,
+  InvalidContainerError,
+  ResourceLimitError
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/pack-inventory.ts
+function compareInventoryNames(left, right) {
+  const a = [...left], b = [...right];
+  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+    const difference = a[i].codePointAt(0) - b[i].codePointAt(0);
+    if (difference) return difference;
+  }
+  return a.length - b.length;
+}
+function record(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw new InputTypeError("Expected an inventory record.");
+  const result = {};
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== "string" || !keys.includes(key) || !("value" in descriptor)) throw new InputTypeError("Unknown inventory field or accessor.");
+    result[key] = descriptor.value;
+  }
+  return result;
+}
+function inventoryPath(path, absolute) {
+  if (typeof path !== "string" || !path || path.startsWith("/") !== absolute || path.includes("\\") || path.includes(":"))
+    throw new InvalidContainerError("Unsafe inventory VFS path.");
+  const segments = (absolute ? path.slice(1) : path).split("/");
+  for (const segment of segments) {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      throw new InvalidContainerError("Invalid inventory path escape.");
+    }
+    if (!segment || segment === "." || segment === ".." || segment.endsWith(".") || segment.endsWith(" ") || decoded.includes("/") || decoded.includes("\\") || decoded === "." || decoded === ".." || [...decoded].some((c) => c.codePointAt(0) < 32 || c === "\x7F") || [...segment].some((c) => c.codePointAt(0) >= 55296 && c.codePointAt(0) <= 57343))
+      throw new InvalidContainerError("Unsafe inventory VFS path.");
+  }
+}
+function sequence(value) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) throw new InputTypeError("Expected inventory entries.");
+  for (const key of Reflect.ownKeys(value)) {
+    if (key === "length") continue;
+    if (typeof key !== "string" || !Object.hasOwn(value, key) || !Number.isSafeInteger(Number(key)) || String(Number(key)) !== key || Number(key) < 0 || Number(key) >= value.length || !("value" in Object.getOwnPropertyDescriptor(value, key)))
+      throw new InputTypeError("Invalid inventory sequence.");
+  }
+  for (let i = 0; i < value.length; i++) if (!Object.hasOwn(value, i)) throw new InputTypeError("Sparse inventory sequence.");
+  return value;
+}
+function admitPackageInventory(value, budget, absolute) {
+  const input = record(value, ["version", "kind", "dialect", "entries", "selection", "pretty", "directories"]);
+  if (input.version !== 1 || !["docx", "dotx"].includes(input.kind) || !["strict", "transitional"].includes(input.dialect) || input.selection !== void 0 && input.selection !== "all" || input.pretty !== void 0 && typeof input.pretty !== "boolean")
+    throw new InputTypeError("Expected a complete version 1 package inventory.");
+  const raw = sequence(input.entries);
+  budget.check("zipEntries", raw.length);
+  if (!raw.length) throw new InputTypeError("Package inventory is empty.");
+  const paths = /* @__PURE__ */ new Set(), parts = /* @__PURE__ */ new Set();
+  let prior, total = 0;
+  const entries = raw.map((value2) => {
+    const e = record(value2, ["part", "path", "contentType", "bytes", "sha256"]);
+    if (typeof e.part !== "string" || !e.part || typeof e.contentType !== "string" || !e.contentType || typeof e.sha256 !== "string" || e.sha256.length !== 64 || [...e.sha256].some((c) => !"0123456789abcdef".includes(c)) || typeof e.bytes !== "number" || !Number.isSafeInteger(e.bytes) || e.bytes < 0)
+      throw new InputTypeError("Invalid package entry metadata.");
+    if (e.part !== "[Content_Types].xml" && normalizePartName(e.part) !== e.part) throw new InvalidContainerError("Inventory part names must be canonical.");
+    inventoryPath(e.path, absolute);
+    const partKey = e.part.normalize("NFC").toUpperCase().toLowerCase(), pathKey = decodeURIComponent(e.path).normalize("NFC").toUpperCase().toLowerCase();
+    if (prior !== void 0 && compareInventoryNames(prior, e.part) >= 0 || parts.has(partKey) || paths.has(pathKey)) throw new InvalidContainerError("Inventory records must be sorted and unambiguous.");
+    prior = e.part;
+    parts.add(partKey);
+    paths.add(pathKey);
+    total += e.bytes;
+    if (!Number.isSafeInteger(total)) throw new ResourceLimitError("Inventory byte total exceeded.");
+    budget.check("expandedPackage", total);
+    const xml = isXmlContentType(e.contentType);
+    if (e.part === "[Content_Types].xml" || xml) budget.check("xmlPartBytes", e.bytes);
+    budget.charge("retainedBytes", (e.part.length + e.path.length + e.contentType.length + 64) * 4 + 128);
+    budget.charge("work", e.part.length + e.path.length + 1);
+    return Object.freeze(e);
+  });
+  const rawDirectories = input.directories === void 0 ? void 0 : sequence(input.directories);
+  if (rawDirectories) budget.check("zipEntries", entries.length + rawDirectories.length);
+  const directories = rawDirectories?.map((d) => {
+    inventoryPath(d, false);
+    budget.charge("retainedBytes", d.length * 8 + 128);
+    budget.charge("work", d.length + 1);
+    return d;
+  });
+  if (directories) budget.check("zipEntries", entries.length + directories.length);
+  return Object.freeze({ version: 1, kind: input.kind, dialect: input.dialect, entries: Object.freeze(entries), ...directories ? { directories: Object.freeze(directories) } : {}, ...input.selection === void 0 ? {} : { selection: "all" }, ...input.pretty === void 0 ? {} : { pretty: input.pretty } });
+}
+var packageInventorySchema = {
+  type: "object",
+  required: ["version", "kind", "dialect", "entries"],
+  additionalProperties: false,
+  properties: {
+    version: { const: 1 },
+    kind: { enum: ["docx", "dotx"] },
+    dialect: { enum: ["strict", "transitional"] },
+    selection: { const: "all" },
+    pretty: { type: "boolean" },
+    directories: { type: "array", items: { type: "string", minLength: 1 }, uniqueItems: true },
+    entries: {
+      type: "array",
+      minItems: 1,
+      description: "Strictly increasing canonical part names in Unicode scalar order; paths and directory spellings must be unambiguous. Relative VFS paths require an explicitly granted inventoryDirectory; stdin uses absolute VFS paths.",
+      items: {
+        type: "object",
+        required: ["part", "path", "contentType", "bytes", "sha256"],
+        additionalProperties: false,
+        properties: { part: { type: "string", minLength: 1, description: "Canonical absolute OPC part name, except literal [Content_Types].xml." }, path: { type: "string", minLength: 1 }, contentType: { type: "string", minLength: 1 }, bytes: { type: "integer", minimum: 0, maximum: Number.MAX_SAFE_INTEGER }, sha256: { type: "string", minLength: 64, maxLength: 64, description: "Exact lowercase SHA-256 hexadecimal payload digest." } }
+      }
+    }
+  }
+};
+
+export {
+  compareInventoryNames,
+  inventoryPath,
+  admitPackageInventory,
+  packageInventorySchema
+};

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

@@ -0,0 +1,400 @@
+import {
+  ValueError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/shape-presets.ts
+var values = {
+  ACTION_BUTTON_BACK_OR_PREVIOUS: 129,
+  ACTION_BUTTON_BEGINNING: 131,
+  ACTION_BUTTON_CUSTOM: 125,
+  ACTION_BUTTON_DOCUMENT: 134,
+  ACTION_BUTTON_END: 132,
+  ACTION_BUTTON_FORWARD_OR_NEXT: 130,
+  ACTION_BUTTON_HELP: 127,
+  ACTION_BUTTON_HOME: 126,
+  ACTION_BUTTON_INFORMATION: 128,
+  ACTION_BUTTON_MOVIE: 136,
+  ACTION_BUTTON_RETURN: 133,
+  ACTION_BUTTON_SOUND: 135,
+  ARC: 25,
+  BALLOON: 137,
+  BENT_ARROW: 41,
+  BENT_UP_ARROW: 44,
+  BEVEL: 15,
+  BLOCK_ARC: 20,
+  CAN: 13,
+  CHART_PLUS: 182,
+  CHART_STAR: 181,
+  CHART_X: 180,
+  CHEVRON: 52,
+  CHORD: 161,
+  CIRCULAR_ARROW: 60,
+  CLOUD: 179,
+  CLOUD_CALLOUT: 108,
+  CORNER: 162,
+  CORNER_TABS: 169,
+  CROSS: 11,
+  CUBE: 14,
+  CURVED_DOWN_ARROW: 48,
+  CURVED_DOWN_RIBBON: 100,
+  CURVED_LEFT_ARROW: 46,
+  CURVED_RIGHT_ARROW: 45,
+  CURVED_UP_ARROW: 47,
+  CURVED_UP_RIBBON: 99,
+  DECAGON: 144,
+  DIAGONAL_STRIPE: 141,
+  DIAMOND: 4,
+  DODECAGON: 146,
+  DONUT: 18,
+  DOUBLE_BRACE: 27,
+  DOUBLE_BRACKET: 26,
+  DOUBLE_WAVE: 104,
+  DOWN_ARROW: 36,
+  DOWN_ARROW_CALLOUT: 56,
+  DOWN_RIBBON: 98,
+  EXPLOSION1: 89,
+  EXPLOSION2: 90,
+  FLOWCHART_ALTERNATE_PROCESS: 62,
+  FLOWCHART_CARD: 75,
+  FLOWCHART_COLLATE: 79,
+  FLOWCHART_CONNECTOR: 73,
+  FLOWCHART_DATA: 64,
+  FLOWCHART_DECISION: 63,
+  FLOWCHART_DELAY: 84,
+  FLOWCHART_DIRECT_ACCESS_STORAGE: 87,
+  FLOWCHART_DISPLAY: 88,
+  FLOWCHART_DOCUMENT: 67,
+  FLOWCHART_EXTRACT: 81,
+  FLOWCHART_INTERNAL_STORAGE: 66,
+  FLOWCHART_MAGNETIC_DISK: 86,
+  FLOWCHART_MANUAL_INPUT: 71,
+  FLOWCHART_MANUAL_OPERATION: 72,
+  FLOWCHART_MERGE: 82,
+  FLOWCHART_MULTIDOCUMENT: 68,
+  FLOWCHART_OFFLINE_STORAGE: 139,
+  FLOWCHART_OFFPAGE_CONNECTOR: 74,
+  FLOWCHART_OR: 78,
+  FLOWCHART_PREDEFINED_PROCESS: 65,
+  FLOWCHART_PREPARATION: 70,
+  FLOWCHART_PROCESS: 61,
+  FLOWCHART_PUNCHED_TAPE: 76,
+  FLOWCHART_SEQUENTIAL_ACCESS_STORAGE: 85,
+  FLOWCHART_SORT: 80,
+  FLOWCHART_STORED_DATA: 83,
+  FLOWCHART_SUMMING_JUNCTION: 77,
+  FLOWCHART_TERMINATOR: 69,
+  FOLDED_CORNER: 16,
+  FRAME: 158,
+  FUNNEL: 174,
+  GEAR_6: 172,
+  GEAR_9: 173,
+  HALF_FRAME: 159,
+  HEART: 21,
+  HEPTAGON: 145,
+  HEXAGON: 10,
+  HORIZONTAL_SCROLL: 102,
+  ISOSCELES_TRIANGLE: 7,
+  LEFT_ARROW: 34,
+  LEFT_ARROW_CALLOUT: 54,
+  LEFT_BRACE: 31,
+  LEFT_BRACKET: 29,
+  LEFT_CIRCULAR_ARROW: 176,
+  LEFT_RIGHT_ARROW: 37,
+  LEFT_RIGHT_ARROW_CALLOUT: 57,
+  LEFT_RIGHT_CIRCULAR_ARROW: 177,
+  LEFT_RIGHT_RIBBON: 140,
+  LEFT_RIGHT_UP_ARROW: 40,
+  LEFT_UP_ARROW: 43,
+  LIGHTNING_BOLT: 22,
+  LINE_CALLOUT_1: 109,
+  LINE_CALLOUT_1_ACCENT_BAR: 113,
+  LINE_CALLOUT_1_BORDER_AND_ACCENT_BAR: 121,
+  LINE_CALLOUT_1_NO_BORDER: 117,
+  LINE_CALLOUT_2: 110,
+  LINE_CALLOUT_2_ACCENT_BAR: 114,
+  LINE_CALLOUT_2_BORDER_AND_ACCENT_BAR: 122,
+  LINE_CALLOUT_2_NO_BORDER: 118,
+  LINE_CALLOUT_3: 111,
+  LINE_CALLOUT_3_ACCENT_BAR: 115,
+  LINE_CALLOUT_3_BORDER_AND_ACCENT_BAR: 123,
+  LINE_CALLOUT_3_NO_BORDER: 119,
+  LINE_CALLOUT_4: 112,
+  LINE_CALLOUT_4_ACCENT_BAR: 116,
+  LINE_CALLOUT_4_BORDER_AND_ACCENT_BAR: 124,
+  LINE_CALLOUT_4_NO_BORDER: 120,
+  LINE_INVERSE: 183,
+  MATH_DIVIDE: 166,
+  MATH_EQUAL: 167,
+  MATH_MINUS: 164,
+  MATH_MULTIPLY: 165,
+  MATH_NOT_EQUAL: 168,
+  MATH_PLUS: 163,
+  MOON: 24,
+  NON_ISOSCELES_TRAPEZOID: 143,
+  NOTCHED_RIGHT_ARROW: 50,
+  NO_SYMBOL: 19,
+  OCTAGON: 6,
+  OVAL: 9,
+  OVAL_CALLOUT: 107,
+  PARALLELOGRAM: 2,
+  PENTAGON: 51,
+  PIE: 142,
+  PIE_WEDGE: 175,
+  PLAQUE: 28,
+  PLAQUE_TABS: 171,
+  QUAD_ARROW: 39,
+  QUAD_ARROW_CALLOUT: 59,
+  RECTANGLE: 1,
+  RECTANGULAR_CALLOUT: 105,
+  REGULAR_PENTAGON: 12,
+  RIGHT_ARROW: 33,
+  RIGHT_ARROW_CALLOUT: 53,
+  RIGHT_BRACE: 32,
+  RIGHT_BRACKET: 30,
+  RIGHT_TRIANGLE: 8,
+  ROUNDED_RECTANGLE: 5,
+  ROUNDED_RECTANGULAR_CALLOUT: 106,
+  ROUND_1_RECTANGLE: 151,
+  ROUND_2_DIAG_RECTANGLE: 153,
+  ROUND_2_SAME_RECTANGLE: 152,
+  SMILEY_FACE: 17,
+  SNIP_1_RECTANGLE: 155,
+  SNIP_2_DIAG_RECTANGLE: 157,
+  SNIP_2_SAME_RECTANGLE: 156,
+  SNIP_ROUND_RECTANGLE: 154,
+  SQUARE_TABS: 170,
+  STAR_10_POINT: 149,
+  STAR_12_POINT: 150,
+  STAR_16_POINT: 94,
+  STAR_24_POINT: 95,
+  STAR_32_POINT: 96,
+  STAR_4_POINT: 91,
+  STAR_5_POINT: 92,
+  STAR_6_POINT: 147,
+  STAR_7_POINT: 148,
+  STAR_8_POINT: 93,
+  STRIPED_RIGHT_ARROW: 49,
+  SUN: 23,
+  SWOOSH_ARROW: 178,
+  TEAR: 160,
+  TRAPEZOID: 3,
+  UP_ARROW: 35,
+  UP_ARROW_CALLOUT: 55,
+  UP_DOWN_ARROW: 38,
+  UP_DOWN_ARROW_CALLOUT: 58,
+  UP_RIBBON: 97,
+  U_TURN_ARROW: 42,
+  VERTICAL_SCROLL: 101,
+  WAVE: 103
+};
+var shapePresets = Object.freeze({
+  ACTION_BUTTON_BACK_OR_PREVIOUS: "actionButtonBackPrevious",
+  ACTION_BUTTON_BEGINNING: "actionButtonBeginning",
+  ACTION_BUTTON_CUSTOM: "actionButtonBlank",
+  ACTION_BUTTON_DOCUMENT: "actionButtonDocument",
+  ACTION_BUTTON_END: "actionButtonEnd",
+  ACTION_BUTTON_FORWARD_OR_NEXT: "actionButtonForwardNext",
+  ACTION_BUTTON_HELP: "actionButtonHelp",
+  ACTION_BUTTON_HOME: "actionButtonHome",
+  ACTION_BUTTON_INFORMATION: "actionButtonInformation",
+  ACTION_BUTTON_MOVIE: "actionButtonMovie",
+  ACTION_BUTTON_RETURN: "actionButtonReturn",
+  ACTION_BUTTON_SOUND: "actionButtonSound",
+  ARC: "arc",
+  BALLOON: "wedgeRoundRectCallout",
+  BENT_ARROW: "bentArrow",
+  BENT_UP_ARROW: "bentUpArrow",
+  BEVEL: "bevel",
+  BLOCK_ARC: "blockArc",
+  CAN: "can",
+  CHART_PLUS: "chartPlus",
+  CHART_STAR: "chartStar",
+  CHART_X: "chartX",
+  CHEVRON: "chevron",
+  CHORD: "chord",
+  CIRCULAR_ARROW: "circularArrow",
+  CLOUD: "cloud",
+  CLOUD_CALLOUT: "cloudCallout",
+  CORNER: "corner",
+  CORNER_TABS: "cornerTabs",
+  CROSS: "plus",
+  CUBE: "cube",
+  CURVED_DOWN_ARROW: "curvedDownArrow",
+  CURVED_DOWN_RIBBON: "ellipseRibbon",
+  CURVED_LEFT_ARROW: "curvedLeftArrow",
+  CURVED_RIGHT_ARROW: "curvedRightArrow",
+  CURVED_UP_ARROW: "curvedUpArrow",
+  CURVED_UP_RIBBON: "ellipseRibbon2",
+  DECAGON: "decagon",
+  DIAGONAL_STRIPE: "diagStripe",
+  DIAMOND: "diamond",
+  DODECAGON: "dodecagon",
+  DONUT: "donut",
+  DOUBLE_BRACE: "bracePair",
+  DOUBLE_BRACKET: "bracketPair",
+  DOUBLE_WAVE: "doubleWave",
+  DOWN_ARROW: "downArrow",
+  DOWN_ARROW_CALLOUT: "downArrowCallout",
+  DOWN_RIBBON: "ribbon",
+  EXPLOSION1: "irregularSeal1",
+  EXPLOSION2: "irregularSeal2",
+  FLOWCHART_ALTERNATE_PROCESS: "flowChartAlternateProcess",
+  FLOWCHART_CARD: "flowChartPunchedCard",
+  FLOWCHART_COLLATE: "flowChartCollate",
+  FLOWCHART_CONNECTOR: "flowChartConnector",
+  FLOWCHART_DATA: "flowChartInputOutput",
+  FLOWCHART_DECISION: "flowChartDecision",
+  FLOWCHART_DELAY: "flowChartDelay",
+  FLOWCHART_DIRECT_ACCESS_STORAGE: "flowChartMagneticDrum",
+  FLOWCHART_DISPLAY: "flowChartDisplay",
+  FLOWCHART_DOCUMENT: "flowChartDocument",
+  FLOWCHART_EXTRACT: "flowChartExtract",
+  FLOWCHART_INTERNAL_STORAGE: "flowChartInternalStorage",
+  FLOWCHART_MAGNETIC_DISK: "flowChartMagneticDisk",
+  FLOWCHART_MANUAL_INPUT: "flowChartManualInput",
+  FLOWCHART_MANUAL_OPERATION: "flowChartManualOperation",
+  FLOWCHART_MERGE: "flowChartMerge",
+  FLOWCHART_MULTIDOCUMENT: "flowChartMultidocument",
+  FLOWCHART_OFFLINE_STORAGE: "flowChartOfflineStorage",
+  FLOWCHART_OFFPAGE_CONNECTOR: "flowChartOffpageConnector",
+  FLOWCHART_OR: "flowChartOr",
+  FLOWCHART_PREDEFINED_PROCESS: "flowChartPredefinedProcess",
+  FLOWCHART_PREPARATION: "flowChartPreparation",
+  FLOWCHART_PROCESS: "flowChartProcess",
+  FLOWCHART_PUNCHED_TAPE: "flowChartPunchedTape",
+  FLOWCHART_SEQUENTIAL_ACCESS_STORAGE: "flowChartMagneticTape",
+  FLOWCHART_SORT: "flowChartSort",
+  FLOWCHART_STORED_DATA: "flowChartOnlineStorage",
+  FLOWCHART_SUMMING_JUNCTION: "flowChartSummingJunction",
+  FLOWCHART_TERMINATOR: "flowChartTerminator",
+  FOLDED_CORNER: "foldedCorner",
+  FRAME: "frame",
+  FUNNEL: "funnel",
+  GEAR_6: "gear6",
+  GEAR_9: "gear9",
+  HALF_FRAME: "halfFrame",
+  HEART: "heart",
+  HEPTAGON: "heptagon",
+  HEXAGON: "hexagon",
+  HORIZONTAL_SCROLL: "horizontalScroll",
+  ISOSCELES_TRIANGLE: "triangle",
+  LEFT_ARROW: "leftArrow",
+  LEFT_ARROW_CALLOUT: "leftArrowCallout",
+  LEFT_BRACE: "leftBrace",
+  LEFT_BRACKET: "leftBracket",
+  LEFT_CIRCULAR_ARROW: "leftCircularArrow",
+  LEFT_RIGHT_ARROW: "leftRightArrow",
+  LEFT_RIGHT_ARROW_CALLOUT: "leftRightArrowCallout",
+  LEFT_RIGHT_CIRCULAR_ARROW: "leftRightCircularArrow",
+  LEFT_RIGHT_RIBBON: "leftRightRibbon",
+  LEFT_RIGHT_UP_ARROW: "leftRightUpArrow",
+  LEFT_UP_ARROW: "leftUpArrow",
+  LIGHTNING_BOLT: "lightningBolt",
+  LINE_CALLOUT_1: "borderCallout1",
+  LINE_CALLOUT_1_ACCENT_BAR: "accentCallout1",
+  LINE_CALLOUT_1_BORDER_AND_ACCENT_BAR: "accentBorderCallout1",
+  LINE_CALLOUT_1_NO_BORDER: "callout1",
+  LINE_CALLOUT_2: "borderCallout2",
+  LINE_CALLOUT_2_ACCENT_BAR: "accentCallout2",
+  LINE_CALLOUT_2_BORDER_AND_ACCENT_BAR: "accentBorderCallout2",
+  LINE_CALLOUT_2_NO_BORDER: "callout2",
+  LINE_CALLOUT_3: "borderCallout3",
+  LINE_CALLOUT_3_ACCENT_BAR: "accentCallout3",
+  LINE_CALLOUT_3_BORDER_AND_ACCENT_BAR: "accentBorderCallout3",
+  LINE_CALLOUT_3_NO_BORDER: "callout3",
+  LINE_CALLOUT_4: "borderCallout3",
+  LINE_CALLOUT_4_ACCENT_BAR: "accentCallout3",
+  LINE_CALLOUT_4_BORDER_AND_ACCENT_BAR: "accentBorderCallout3",
+  LINE_CALLOUT_4_NO_BORDER: "callout3",
+  LINE_INVERSE: "lineInv",
+  MATH_DIVIDE: "mathDivide",
+  MATH_EQUAL: "mathEqual",
+  MATH_MINUS: "mathMinus",
+  MATH_MULTIPLY: "mathMultiply",
+  MATH_NOT_EQUAL: "mathNotEqual",
+  MATH_PLUS: "mathPlus",
+  MOON: "moon",
+  NON_ISOSCELES_TRAPEZOID: "nonIsoscelesTrapezoid",
+  NOTCHED_RIGHT_ARROW: "notchedRightArrow",
+  NO_SYMBOL: "noSmoking",
+  OCTAGON: "octagon",
+  OVAL: "ellipse",
+  OVAL_CALLOUT: "wedgeEllipseCallout",
+  PARALLELOGRAM: "parallelogram",
+  PENTAGON: "homePlate",
+  PIE: "pie",
+  PIE_WEDGE: "pieWedge",
+  PLAQUE: "plaque",
+  PLAQUE_TABS: "plaqueTabs",
+  QUAD_ARROW: "quadArrow",
+  QUAD_ARROW_CALLOUT: "quadArrowCallout",
+  RECTANGLE: "rect",
+  RECTANGULAR_CALLOUT: "wedgeRectCallout",
+  REGULAR_PENTAGON: "pentagon",
+  RIGHT_ARROW: "rightArrow",
+  RIGHT_ARROW_CALLOUT: "rightArrowCallout",
+  RIGHT_BRACE: "rightBrace",
+  RIGHT_BRACKET: "rightBracket",
+  RIGHT_TRIANGLE: "rtTriangle",
+  ROUNDED_RECTANGLE: "roundRect",
+  ROUNDED_RECTANGULAR_CALLOUT: "wedgeRoundRectCallout",
+  ROUND_1_RECTANGLE: "round1Rect",
+  ROUND_2_DIAG_RECTANGLE: "round2DiagRect",
+  ROUND_2_SAME_RECTANGLE: "round2SameRect",
+  SMILEY_FACE: "smileyFace",
+  SNIP_1_RECTANGLE: "snip1Rect",
+  SNIP_2_DIAG_RECTANGLE: "snip2DiagRect",
+  SNIP_2_SAME_RECTANGLE: "snip2SameRect",
+  SNIP_ROUND_RECTANGLE: "snipRoundRect",
+  SQUARE_TABS: "squareTabs",
+  STAR_10_POINT: "star10",
+  STAR_12_POINT: "star12",
+  STAR_16_POINT: "star16",
+  STAR_24_POINT: "star24",
+  STAR_32_POINT: "star32",
+  STAR_4_POINT: "star4",
+  STAR_5_POINT: "star5",
+  STAR_6_POINT: "star6",
+  STAR_7_POINT: "star7",
+  STAR_8_POINT: "star8",
+  STRIPED_RIGHT_ARROW: "stripedRightArrow",
+  SUN: "sun",
+  SWOOSH_ARROW: "swooshArrow",
+  TEAR: "teardrop",
+  TRAPEZOID: "trapezoid",
+  UP_ARROW: "upArrow",
+  UP_ARROW_CALLOUT: "upArrowCallout",
+  UP_DOWN_ARROW: "upDownArrow",
+  UP_DOWN_ARROW_CALLOUT: "upDownArrowCallout",
+  UP_RIBBON: "ribbon2",
+  U_TURN_ARROW: "uturnArrow",
+  VERTICAL_SCROLL: "verticalScroll",
+  WAVE: "wave"
+});
+var entries = Object.keys(values).map(
+  (name) => Object.freeze({ name, value: values[name], xml_value: shapePresets[name] })
+);
+function invalid() {
+  throw new ValueError("Unknown shape preset.");
+}
+var MSO_AUTO_SHAPE_TYPE = Object.freeze(
+  Object.assign(values, {
+    metadata(value) {
+      return entries.find((entry) => entry.value === value) ?? invalid();
+    },
+    from_xml(xml_value) {
+      return entries.find((entry) => entry.xml_value === xml_value)?.value ?? invalid();
+    },
+    to_xml(value) {
+      return entries.find((entry) => entry.value === value)?.xml_value ?? invalid();
+    },
+    validate(value) {
+      if (!entries.some((entry) => entry.value === value)) invalid();
+    }
+  })
+);
+
+export {
+  shapePresets,
+  MSO_AUTO_SHAPE_TYPE
+};

package/dist/safe-bash/command-chunks/{chunk-CZLX3KVF.js → chunk-2GILUQJY.js}

@@ -34,7 +34,6 @@ async function parseOptions(context, limits) {
   let filesFrom = false;
   let stdinUsed = false;
   let filesFromBytes = 0;
-  let lateExclude = false;
   let wildcards = false;
   let occurrence;
   const metadata = {};
@@ -43,13 +42,12 @@ async function parseOptions(context, limits) {
   const exclude = (pattern) => {
     checkPath(pattern, limits);
     if (excludes.length >= limits.maxMembers) fail("exclude pattern limit exceeded");
-    if (operands.length) lateExclude = true;
     excludes.push(pattern);
   };
   const operand = (name) => {
     checkPath(name, limits);
     if (operands.length >= limits.maxMembers) fail("operand limit exceeded");
-    operands.push({ name, cwd });
+    operands.push({ name, cwd, excludeCount: excludes.length, recursion });
   };
   const directory = async (name) => {
     checkPath(name, limits);
@@ -240,7 +238,6 @@ async function parseOptions(context, limits) {
   if (occurrence !== void 0 && (creating || mode === "A" || !operands.length)) fail("--occurrence requires member operands when reading archives");
   if (mode !== "c" && archive === "-" && stdinUsed) fail("archive and file list cannot both use standard input");
   if (mode !== "t" && mode !== "x" && strip !== 0) fail("--strip-components is only supported when listing or extracting archives");
-  if (creating && lateExclude) fail("--exclude after source operands is unsupported; place exclusions before operands");
   if (mode === "c" && !operands.length && !filesFrom) fail("refusing to create an empty archive without -T");
   if (archive !== "-") checkPath(archive, limits);
   if (mode === "c" && autoCompress) {
@@ -317,9 +314,10 @@ var Exclusions = class {
   anchored;
   patterns;
   work = 0;
-  matches(name) {
+  matches(name, count = this.patterns.length) {
     const characters = Array.from(this.anchored ? name : exclusionName(name));
-    for (const tokens of this.patterns) {
+    for (let pattern = 0; pattern < count; pattern++) {
+      const tokens = this.patterns[pattern];
       let states = new Uint8Array(characters.length + 1);
       states[0] = 1;
       if (!this.anchored) {