@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,232 @@
+import {
+  packageInventorySchema
+} from "./chunk-2EUH5B6A.js";
+import {
+  docxCommonOptions,
+  docxEnumCanonicalNames,
+  docxEnumSymbols,
+  docxOperationSchemas,
+  isDocxLiteralUnion,
+  splitDocxType
+} from "./chunk-R4TYL2G6.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  documentLimitDefaults
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/operation-json-schema.ts
+var identifier = { type: "string", minLength: 1, pattern: "^[^\\u0000]+$" };
+var number = { type: "number", minimum: -Number.MAX_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER };
+var integer = { ...number, type: "integer" };
+function fieldsSchema(fields, definitions, handles = false) {
+  return {
+    type: "object",
+    properties: Object.fromEntries(Object.entries(fields).map(([name, field]) => {
+      const value = valueSchema(field.wireType ?? field.type, definitions);
+      return [name, handles && field.type !== "unknown" ? { anyOf: [value, {
+        ...objectSchema({ resultHandle: "BatchHandleName", index: "?nonnegative integer", key: "?identifier" }, definitions),
+        not: { required: ["index", "key"] },
+        description: "Prior batch result with a compatible declared type; selected values retain argument validation."
+      }] } : value];
+    })),
+    required: Object.entries(fields).filter(([, field]) => field.required).map(([name]) => name),
+    additionalProperties: false
+  };
+}
+function objectSchema(fields, definitions) {
+  return fieldsSchema(Object.fromEntries(Object.entries(fields).map(([name, type]) => [name, { type: type.startsWith("?") ? type.slice(1) : type, required: !type.startsWith("?") }])), definitions);
+}
+function contentDefinitions(definitions) {
+  if (definitions.Block) return;
+  definitions.Block = {};
+  definitions.RunInput = objectSchema({ text: "string", bold: "?boolean | null", italic: "?boolean | null", underline: "?boolean | WD_UNDERLINE | null", style: "?identifier" }, definitions);
+  const borders = objectSchema(Object.fromEntries(["top", "left", "bottom", "right", "insideH", "insideV"].map((k) => [k, "?Border"])), definitions);
+  const shading = objectSchema({ fill: "RGBColor", color: "?RGBColor", pattern: "ShadingPattern" }, definitions);
+  const margins = objectSchema(Object.fromEntries(["top", "left", "bottom", "right"].map((k) => [k, "?Length"])), definitions);
+  definitions.CellInput = { type: "object", properties: { borders, shading, margins, blocks: { type: "array", items: { $ref: "#/$defs/Block" } } }, required: ["blocks"], additionalProperties: false };
+  const paragraph = objectSchema({ kind: "identifier", text: "?string", style: "?identifier", level: "?integer 0..9" }, definitions);
+  const table = objectSchema({ kind: "identifier", width: "?Length", style: "?identifier", columnWidths: "?ReadonlyArray<Length>", autofit: "?boolean", repeatHeader: "?boolean", headerRows: "?nonnegative integer", allowRowSplit: "?boolean", rowHeight: "?Length", heightRule: "?WD_ROW_HEIGHT_RULE", cellMargin: "?Length", rowOptions: "?ReadonlyArray<{repeatHeader?: boolean; allowRowSplit?: boolean; height?: Length; heightRule?: WD_ROW_HEIGHT_RULE}>" }, definitions);
+  definitions.Block = { oneOf: [
+    { ...paragraph, properties: { ...paragraph.properties, kind: { const: "paragraph" }, runs: { type: "array", items: { $ref: "#/$defs/RunInput" } } }, allOf: [{ not: { required: ["text", "runs"] } }, { not: { required: ["style", "level"] } }] },
+    { ...table, properties: { ...table.properties, borders, shading, kind: { const: "table" }, rows: { type: "array", minItems: 1, items: { type: "array", minItems: 1, items: { $ref: "#/$defs/CellInput" } } } }, required: ["kind", "rows"], description: "Rows have equal cell counts; width, when present, is positive." }
+  ] };
+}
+function receiverSchema(type, definitions) {
+  const direct = objectSchema({ id: "identifier", type: "identifier", owner: "identifier", revision: "nonnegative integer" }, definitions);
+  const handle = objectSchema({ resultHandle: "BatchHandleName", index: "?nonnegative integer", key: "?identifier" }, definitions);
+  return { oneOf: [{ ...direct, properties: { ...direct.properties, ...type ? { type: { const: type } } : {} } }, { ...handle, not: { required: ["index", "key"] } }] };
+}
+function valueSchema(type, definitions) {
+  if (["ImageLayoutOffset", "ImageLayoutExtent", "ImageLayoutDistance"].includes(type)) {
+    const distance = type === "ImageLayoutDistance", offset = type === "ImageLayoutOffset";
+    const domain = offset ? "[-2147483648,2147483647]" : distance ? "[0,4294967295]" : "[1,2147483647]";
+    return {
+      ...valueSchema("Length (explicit emu/in/cm/mm/pt)", definitions),
+      allOf: [{ oneOf: [
+        { properties: { unit: { const: "emu" }, value: { type: "number", minimum: offset ? -2147483648 : distance ? 0 : 0.5, maximum: distance ? 4294967295 : 2147483647 } } },
+        { properties: { unit: { enum: ["in", "cm", "mm", "pt"] } } }
+      ] }],
+      ...distance ? { properties: { value: { ...number, minimum: 0 }, unit: { enum: ["emu", "in", "cm", "mm", "pt"] } } } : {},
+      description: `Explicit finite physical length; convert to EMUs and round once with halfway values away from zero. ${offset || distance ? `Check finite values and the native EMU domain ${domain} before and after conversion and rounding.` : `Supplied and converted values must be positive; converted EMUs must not exceed 2147483647 before rounding. Rounded integer EMUs must be in ${domain}. Positive half-EMU values round to one; values rounding to zero reject.`} No clamping. ${distance ? "The supplied physical value must also be nonnegative." : offset ? "Signed native axis offset." : "Size uses the stored unrotated ratio for an omitted axis."}`
+    };
+  }
+  if (type === "unsigned 32-bit integer") return { type: "integer", minimum: 0, maximum: 4294967295 };
+  if (type === "signed 32-bit integer") return { type: "integer", minimum: -2147483648, maximum: 2147483647 };
+  if (type === "native polygon coordinate") return { type: "integer", minimum: -27273042329600, maximum: 27273042316900 };
+  if (type === "ImageWrapPoint") return objectSchema({ x: "native polygon coordinate", y: "native polygon coordinate" }, definitions);
+  if (type === "ImageWrapPolygon") return { ...objectSchema({ start: "ImageWrapPoint", lineTo: "ReadonlyArray<ImageWrapPoint>" }, definitions), properties: { start: valueSchema("ImageWrapPoint", definitions), lineTo: { type: "array", minItems: 2, items: valueSchema("ImageWrapPoint", definitions) } } };
+  if (type === "OwnedBinaryInput") return { ...valueSchema("BinaryInput", definitions).oneOf[0], description: "SDK owned Uint8Array; JSON carries canonical base64 bytes." };
+  if (type === "nonempty unique list: properties|comments|revisions|links|objects") return { type: "array", minItems: 1, uniqueItems: true, items: { enum: ["properties", "comments", "revisions", "links", "objects"] } };
+  if (type === "DeclaredTemplateRecord | ReadonlyArray<DeclaredTemplateRecord>") return valueSchema("TemplateData", definitions);
+  const variants = splitDocxType(type);
+  if (variants.length > 1) return isDocxLiteralUnion(type) ? { enum: variants } : { anyOf: variants.map((item) => valueSchema(item, definitions)) };
+  if (["string", "boolean", "null"].includes(type)) return { type };
+  if (type === "BatchHandleName") return { type: "string", pattern: "^[A-Za-z][A-Za-z0-9_]*(?![\\s\\S])" };
+  if (type === "unknown") return {};
+  if (type === "number" || type === "finite number") return number;
+  if (type === "finite degrees") return { ...number, minimum: -360, maximum: 360 };
+  if (type === "integer" || type === "safe integer") return integer;
+  if (type === "nonnegative integer" || type === "nonnegative safe integer") return { ...integer, minimum: 0 };
+  if (type === "positive integer") return { ...integer, minimum: 1 };
+  if (type === "integer 0..8" || type === "integer 0..9" || type === "integer 0..99") return { ...integer, minimum: 0, maximum: Number(type.slice("integer 0..".length)) };
+  if (type === "fraction 0..1") return { ...number, minimum: 0, maximum: 1 };
+  if (type === "literal 1") return { const: 1 };
+  if (["identifier", "VfsInput", "VfsDestination", "VfsDirectory", "declared binding ID", "PackURI"].includes(type)) return identifier;
+  if (type === "UTC date") return { type: "string", format: "date", pattern: "^[0-9]{4}-[0-9]{2}-[0-9]{2}$" };
+  if (type === "UTC instant" || type === "Date") return { type: "string", format: "date-time", pattern: "Z$", description: type === "Date" ? "The SDK accepts a valid Date; JSON carries its UTC serialization." : "A UTC instant ending in Z." };
+  if (type === "DeclaredBindingValue") return { anyOf: [{ type: "string" }, { type: "boolean" }, { type: "number" }] };
+  if (type === "typed scalar") return { anyOf: [{ type: "string" }, { type: "boolean" }, number] };
+  if (type === "declared understood-namespace profile") return { const: "core-v1" };
+  if (type === "closed operation ID") return { enum: Object.keys(docxOperationSchemas) };
+  if (type === "Length" || type.startsWith("Length (explicit")) return { type: "object", properties: { value: number, unit: { enum: ["emu", "in", "cm", "mm", "pt", ...type === "Length" ? ["twip"] : []] } }, required: ["value", "unit"], additionalProperties: false };
+  if (type === "RGBColor" || type === "RGB hex") return { type: "string", pattern: "^[0-9A-Fa-f]{6}$" };
+  if (Object.hasOwn(docxEnumSymbols, type)) return { type: "object", properties: { enum: docxEnumCanonicalNames[type] ? { enum: [type, docxEnumCanonicalNames[type]] } : { const: type }, name: { enum: docxEnumSymbols[type] } }, required: ["enum", "name"], additionalProperties: false };
+  if (type === "BinaryInput") return { oneOf: [
+    { type: "object", properties: { kind: { const: "bytes" }, base64: { type: "string", contentEncoding: "base64", pattern: "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?$" } }, required: ["kind", "base64"], additionalProperties: false },
+    { type: "object", properties: { kind: { const: "vfs" }, path: identifier, capability: identifier }, required: ["kind", "path", "capability"], additionalProperties: false }
+  ] };
+  if (type === "Uint8Array") return { ...valueSchema("BinaryInput", definitions), description: "SDK Uint8Array; JSON binary input uses explicit encoded bytes." };
+  if (type === "Input") return { anyOf: [valueSchema("BinaryInput", definitions), valueSchema("VfsPath", definitions)] };
+  if (type === "VfsPath") return objectSchema({ path: "identifier", capability: "identifier" }, definitions);
+  if (type === "ByteSink") return objectSchema({ capability: "identifier" }, definitions);
+  if (type === "DocumentContext") return objectSchema({ vfs: "?identifier", limits: "?LimitOptions", timestamp: "?UTC instant", author: "?string", fonts: "?identifier", template: "?BinaryInput" }, definitions);
+  if (type === "LimitOptions") return objectSchema(Object.fromEntries(Object.keys(documentLimitDefaults).map((key) => [key, "?nonnegative safe integer"])), definitions);
+  if (type === "LimitName") return { enum: Object.keys(documentLimitDefaults) };
+  if (type === "logical cell coordinate") return { type: "string", pattern: "^[A-Z]+[1-9][0-9]*$", description: "Both decoded coordinates must fit safe integers." };
+  if (type === "LocationToken") return { type: "string", pattern: "^docx-loc-v1\\.[A-Za-z0-9_-]+$", description: "Canonical unpadded base64url UTF-8 location payload with closed fields and document fingerprint." };
+  if (type === "OriginalDocumentContentV1") {
+    contentDefinitions(definitions);
+    const font = { type: "string", minLength: 1, pattern: "^[^\\u0000-\\u001f\\u007f-\\u009f]+$", description: "Font name without control characters." };
+    const style = objectSchema({ name: "identifier", type: "paragraph|character|table", font: "?identifier", size: "?Length", bold: "?boolean", italic: "?boolean" }, definitions);
+    const margins = objectSchema(Object.fromEntries(["top", "right", "bottom", "left", "header", "footer", "gutter"].map((key) => [key, "?Length"])), definitions);
+    const colors = objectSchema(Object.fromEntries(["dark1", "light1", "dark2", "light2", "accent1", "accent2", "accent3", "accent4", "accent5", "accent6", "hyperlink", "followedHyperlink"].map((key) => [key, "?RGBColor"])), definitions);
+    return { type: "object", properties: {
+      version: { const: 1 },
+      blocks: { type: "array", items: { $ref: "#/$defs/Block" } },
+      page: { ...objectSchema({ width: "?Length", height: "?Length", orientation: "?portrait|landscape" }, definitions), properties: { width: valueSchema("Length", definitions), height: valueSchema("Length", definitions), orientation: { enum: ["portrait", "landscape"] }, margins } },
+      styles: { type: "array", items: { ...style, properties: { ...style.properties, font } } },
+      theme: { type: "object", properties: { name: identifier, majorFont: font, minorFont: font, colors }, required: ["name", "majorFont", "minorFont"], additionalProperties: false }
+    }, required: ["version", "blocks"], additionalProperties: false };
+  }
+  if (type === "DeclaredTemplateRecord" || type === "TemplateData") {
+    for (let depth = 4; depth >= 0; depth--) {
+      const name = depth === 0 ? "DeclaredTemplateRecord" : `DeclaredTemplateRecord${depth}`;
+      definitions[name] ??= { type: "object", properties: { values: { type: "array", items: { type: "object", properties: {
+        binding: identifier,
+        value: depth === 4 ? valueSchema("DeclaredBindingValue", definitions) : { oneOf: [valueSchema("DeclaredBindingValue", definitions), { type: "array", maxItems: 1e3, items: { $ref: `#/$defs/DeclaredTemplateRecord${depth + 1}` } }] }
+      }, required: ["binding", "value"], additionalProperties: false }, description: "Unique exact declared keys; maximum four repeat levels." } }, required: ["values"], additionalProperties: false };
+    }
+    return type === "DeclaredTemplateRecord" ? { $ref: "#/$defs/DeclaredTemplateRecord" } : { oneOf: [{ $ref: "#/$defs/DeclaredTemplateRecord" }, { type: "array", maxItems: 1e3, items: { $ref: "#/$defs/DeclaredTemplateRecord1" } }] };
+  }
+  if (type === "DeclaredControlRecord") return { type: "object", properties: { values: { type: "array", items: objectSchema({ binding: "identifier", value: "DeclaredBindingValue" }, definitions), description: "Binding identifiers must be unique within each record." } }, required: ["values"], additionalProperties: false };
+  if (type.startsWith("ReadonlyArray<") && type.endsWith(">")) return { type: "array", items: valueSchema(type.slice(14, -1), definitions) };
+  if (type === "bounded range 1..9") return { type: "object", properties: { start: { type: "integer", minimum: 1, maximum: 9 }, end: { type: "integer", minimum: 1, maximum: 9 } }, required: ["start", "end"], additionalProperties: false, description: "start must not exceed end." };
+  if (type === "Baseline") return { enum: ["baseline", "superscript", "subscript"] };
+  if (type === "ThemeFont") return { enum: ["majorAscii", "majorHAnsi", "majorEastAsia", "majorBidi", "minorAscii", "minorHAnsi", "minorEastAsia", "minorBidi"] };
+  if (type === "ShadingPattern") return { enum: ["clear", "solid", "pct5", "pct10", "pct20", "pct25", "pct50", "pct75"] };
+  if (type === "Border") return { ...objectSchema({ style: "none|single|double|dotted|dashed", width: "Length", color: "RGBColor", space: "?Length" }, definitions), description: "Width and space are nonnegative lengths." };
+  if (type === "ExpandedName") return objectSchema({ namespaceURI: "string", localName: "identifier" }, definitions);
+  if (type === "Receiver") return receiverSchema(void 0, definitions);
+  if (type === "Iterable<readonly [string, RelationshipView]>") return { type: "array", items: { type: "array", prefixItems: [identifier, receiverSchema("RelationshipView", definitions)], minItems: 2, maxItems: 2, items: false } };
+  if (type === "XmlNodeInput") {
+    if (!definitions.XmlNodeInput) {
+      definitions.XmlNodeInput = {};
+      const element = objectSchema({ kind: "identifier", name: "ExpandedName", attributes: "?ReadonlyArray<{name: ExpandedName; value: string}>" }, definitions);
+      definitions.XmlNodeInput = { oneOf: [
+        { ...element, properties: { ...element.properties, kind: { const: "element" }, children: { type: "array", items: { $ref: "#/$defs/XmlNodeInput" } } } },
+        ...["text", "comment"].map((kind) => ({ type: "object", properties: { kind: { const: kind }, text: { type: "string" } }, required: ["kind", "text"], additionalProperties: false })),
+        { type: "object", properties: { kind: { const: "processingInstruction" }, target: identifier, data: { type: "string" } }, required: ["kind", "target", "data"], additionalProperties: false }
+      ], description: "Comments and processing instructions must obey XML lexical restrictions; DTD and entities are forbidden." };
+    }
+    return { $ref: "#/$defs/XmlNodeInput" };
+  }
+  if (type.startsWith("{") && type.endsWith("}")) {
+    const fields = {};
+    for (const declaration of type.slice(1, -1).split(";")) {
+      if (!declaration.trim()) continue;
+      const separator = declaration.indexOf(":");
+      const name = declaration.slice(0, separator).trim();
+      fields[name.endsWith("?") ? name.slice(0, -1) : name] = `${name.endsWith("?") ? "?" : ""}${declaration.slice(separator + 1).trim()}`;
+    }
+    return objectSchema(fields, definitions);
+  }
+  if (type === "BatchV1") return objectSchema({ version: "literal 1", operations: "ReadonlyArray<OperationV1>" }, definitions);
+  if (type === "OperationV1") return { oneOf: Object.entries(docxOperationSchemas).filter(([, declaration]) => declaration.batchFields !== void 0).map(([id, declaration]) => {
+    const properties = { id: { type: "string", minLength: 1, maxLength: 64, pattern: "^[A-Za-z][A-Za-z0-9_-]*$" }, operation: { const: id }, arguments: fieldsSchema(declaration.batchFields, definitions, declaration.transport === "typed-batch") };
+    const required = ["operation", "arguments"];
+    if (declaration.receiver) {
+      properties.receiver = receiverSchema(declaration.receiver, definitions);
+      required.push("receiver");
+    }
+    if (declaration.resultHandle?.allowed) properties.resultHandle = valueSchema("BatchHandleName", definitions);
+    return { type: "object", properties, required, additionalProperties: false };
+  }) };
+  if (Object.values(docxOperationSchemas).some((schema) => schema.receiver === type || schema.resultHandle?.allowed && schema.resultHandle.type === type)) return receiverSchema(type, definitions);
+  return { not: {}, description: `No transport value is declared for ${type}.` };
+}
+function docxValueSchema(type) {
+  const definitions = {};
+  const schema = valueSchema(type, definitions);
+  return Object.keys(definitions).length ? { ...schema, $defs: definitions } : schema;
+}
+function getDocxOperationSchema(id, transport = "sdk") {
+  const declaration = docxOperationSchemas[id];
+  if (!declaration) throw new DocxUsageError("Unknown operation schema.");
+  const fields = transport === "cli" ? declaration.fields : transport === "batch" ? declaration.batchFields : declaration.sdkFields;
+  if (!fields) throw new DocxUsageError("Operation is not available in batch.");
+  const definitions = {};
+  if (id === "pack") definitions.PackageInventoryV1 = packageInventorySchema;
+  const applicable = transport === "batch" ? fields : { ...Object.fromEntries(declaration.commonOptions.map((key) => [key, docxCommonOptions[key]])), ...fields };
+  const schema = fieldsSchema(applicable, definitions, transport === "batch" && declaration.transport === "typed-batch");
+  const conditions = [];
+  if (id === "diff") conditions.push({ oneOf: [
+    { properties: { mode: { enum: ["parts", "xml"] }, scope: { const: "package" } } },
+    { properties: { mode: { enum: ["text", "structure"] }, scope: { enum: ["body", "headers", "footers", "footnotes", "endnotes", "comments", "text-boxes", "all-stories"] } }, required: ["mode"] }
+  ] });
+  if (id === "controls.repeat" && transport === "cli") conditions.push({ oneOf: [{ required: ["dataFile"] }, { required: ["dataJson"] }] });
+  if (id === "controls.set") conditions.push({ oneOf: ["text", "checked", "choice", "date", "file"].map((name) => ({ required: [name] })) });
+  if (id === "text.replace") conditions.push({ anyOf: [
+    { properties: { trackChanges: { const: true } }, required: ["trackChanges", "author", "timestamp"] },
+    { properties: { trackChanges: { const: false } }, not: { anyOf: [{ required: ["author"] }, { required: ["timestamp"] }] } }
+  ] });
+  if (["revisions.accept", "revisions.reject"].includes(id)) {
+    const owners = ["section", "paragraph", "run", "table", "cell", "image", "comment", "note", "link", "control", "shape", "field", "bookmark"];
+    conditions.push({ anyOf: [
+      { required: ["revision"], properties: { all: { const: false } }, not: { required: ["select"] } },
+      { required: ["select"], properties: { all: { const: false } }, not: { anyOf: ["revision", "scope", ...owners].map((name) => ({ required: [name] })) } },
+      { required: ["all"], properties: { all: { const: true } }, not: { anyOf: ["revision", "select", ...owners].map((name) => ({ required: [name] })) } }
+    ] });
+  }
+  if (id === "revisions.add") conditions.push({ anyOf: [
+    { properties: { kind: { const: "insert" } }, required: ["text"] },
+    { properties: { kind: { const: "delete" } }, not: { required: ["text"] } }
+  ] });
+  return { $schema: "https://json-schema.org/draft/2020-12/schema", ...schema, ...conditions.length ? { allOf: conditions } : {}, ...Object.keys(definitions).length ? { $defs: definitions } : {} };
+}
+
+export {
+  docxValueSchema,
+  getDocxOperationSchema
+};

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

@@ -0,0 +1,25 @@
+import {
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+
+// packages/safe-bash-docx-engine/src/inline-image-xml.ts
+function inlineImageRun(ns, drawingId, relationshipId, size, options = {}) {
+  const decorative = options.decorative ? '<di:extLst><di:ext uri="{C183D7F6-B498-43B3-948B-1728B52AA6E4}"><ad:decorative xmlns:ad="http://schemas.microsoft.com/office/drawing/2017/decorative" val="1"/></di:ext></di:extLst>' : "";
+  const blip = options.vectorRelationshipId ? `<di:blip ri:embed="${relationshipId}"><di:extLst><di:ext uri="{96DAC541-7B7A-43D3-8B79-37D633B846F1}"><asvg:svgBlip xmlns:asvg="http://schemas.microsoft.com/office/drawing/2016/SVG/main" xmlns:vr="${documentDialects.transitional.r}" vr:embed="${options.vectorRelationshipId}"/></di:ext></di:extLst></di:blip>` : `<di:blip ri:embed="${relationshipId}"/>`;
+  const prefix = `<wi:r xmlns:wi="${ns.w}" xmlns:wp="${ns.wp}" xmlns:di="${ns.a}" xmlns:pic="${ns.pic}" xmlns:ri="${ns.r}"><wi:drawing><wp:inline distT="0" distB="0" distL="0" distR="0"><wp:extent cx="${size.width}" cy="${size.height}"/><wp:docPr id="${drawingId}" name="Image ${drawingId}" descr="`;
+  const suffix = `">${decorative}</wp:docPr><wp:cNvGraphicFramePr><di:graphicFrameLocks noChangeAspect="1"/></wp:cNvGraphicFramePr><di:graphic><di:graphicData uri="${ns.pic}"><pic:pic><pic:nvPicPr><pic:cNvPr id="0" name="${xmlValue(options.filename ?? `Image ${drawingId}`)}"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill>${blip}${size.crop.split(documentDialects.transitional.a).join(ns.a)}<di:stretch><di:fillRect/></di:stretch></pic:blipFill><pic:spPr><di:xfrm><di:off x="0" y="0"/><di:ext cx="${size.width}" cy="${size.height}"/></di:xfrm><di:prstGeom prst="rect"><di:avLst/></di:prstGeom></pic:spPr></pic:pic></di:graphicData></di:graphic></wp:inline></wi:drawing></wi:r>`;
+  return {
+    prefix,
+    suffix,
+    get run() {
+      return prefix + xmlValue(options.alt ?? "") + suffix;
+    }
+  };
+}
+
+export {
+  inlineImageRun
+};

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

@@ -0,0 +1,322 @@
+import {
+  equationOpaqueElements,
+  interpretCompatibility
+} from "./chunk-5DFZAJHL.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  parseContentTypes
+} from "./chunk-N74TJL6X.js";
+import {
+  readRelationshipGraph
+} from "./chunk-5GEFJROP.js";
+import {
+  resourceContext
+} from "./chunk-FOO3AXFK.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/validation.ts
+var rules = [
+  "main-part",
+  "content-types",
+  "relationship-targets",
+  "required-structure",
+  "slide-ids",
+  "shape-ids",
+  "master-layouts",
+  "note-associations",
+  "timing-references",
+  "connector-references"
+];
+var dialects = [
+  {
+    p: "http://schemas.openxmlformats.org/presentationml/2006/main",
+    a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+    r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  },
+  {
+    p: "http://purl.oclc.org/ooxml/presentationml/main",
+    a: "http://purl.oclc.org/ooxml/drawingml/main",
+    r: "http://purl.oclc.org/ooxml/officeDocument/relationships"
+  }
+];
+var types = new Map(
+  [
+    ["presentation.main", "presentation"],
+    ["template.main", "presentation"],
+    ["slideshow.main", "presentation"],
+    ["slide", "sld"],
+    ["slideMaster", "sldMaster"],
+    ["slideLayout", "sldLayout"],
+    ["notesSlide", "notes"],
+    ["notesMaster", "notesMaster"],
+    ["handoutMaster", "handoutMaster"]
+  ].map(([type, root]) => [
+    `application/vnd.openxmlformats-officedocument.presentationml.${type}+xml`.toLowerCase(),
+    root
+  ])
+);
+function attribute(element, name, namespace = "") {
+  return element.attributes.find(
+    (item) => item.name.namespace === namespace && item.name.localName === name
+  )?.value;
+}
+function integer(value, min, max) {
+  if (value === void 0 || !value.length) return null;
+  const text = value.trim();
+  const digits = text.startsWith("+") ? text.slice(1) : text;
+  if (!digits || [...digits].some((character) => character < "0" || character > "9")) return null;
+  const number = Number(text);
+  return Number.isSafeInteger(number) && number >= min && number <= max ? number : null;
+}
+function validatePresentation(reader, settings = {}) {
+  const context = resourceContext({ xmlLimits: settings, relationshipLimits: settings });
+  const limits = { ...context.xmlLimits, ...context.relationshipLimits, maxEntries: Infinity, ...settings };
+  const issues = [];
+  const fail = (rule, part) => {
+    if (!issues.some((issue) => issue.rule === rule && issue.part === part))
+      issues.push({ rule, part });
+  };
+  const contentTypes = parseContentTypes(reader.get("/[Content_Types].xml"), limits);
+  const graph = readRelationshipGraph(reader, limits);
+  for (const edge of graph.dangling) fail("relationship-targets", edge.owner);
+  const mainEdges = graph.outgoing("/").filter((edge) => dialects.some((d) => edge.type === `${d.r}/officeDocument`));
+  const mainParts = [];
+  const roots = /* @__PURE__ */ new Map();
+  for (const name of reader.names) {
+    if (name.toLowerCase() === "/[content_types].xml") continue;
+    try {
+      const type = contentTypes.get(name).split(";", 1)[0].trim().toLowerCase();
+      const root = types.get(type);
+      if (root) roots.set(name, root);
+      if (root === "presentation") mainParts.push(name);
+      if (!graph.parts.includes(name) && type !== "application/vnd.openxmlformats-package.relationships+xml")
+        fail("content-types", name);
+    } catch (error) {
+      if (!(error instanceof OfficeError) || error.code !== "missing-binding") throw error;
+      fail("content-types", name);
+    }
+  }
+  if (mainEdges.length !== 1 || mainEdges[0].external || mainParts.length !== 1 || mainEdges[0].targetPart !== mainParts[0])
+    fail("main-part", "/");
+  const documents = /* @__PURE__ */ new Map();
+  let bytes = 0;
+  let nodes = 0;
+  for (const [name, expected] of roots) {
+    const data = reader.get(name);
+    bytes += data.length;
+    if (bytes > limits.maxBytes)
+      throw new OfficeError("resource-limit", "Validation XML byte limit exceeded.", "index");
+    if (nodes >= limits.maxNodes)
+      throw new OfficeError("resource-limit", "Validation XML node limit exceeded.", "index");
+    const part = parseXmlPart(data, { ...limits, maxNodes: limits.maxNodes - nodes });
+    nodes += part.nodeCount;
+    const dialect = dialects.find((d) => d.p === part.root.name.namespace);
+    if (!dialect || part.root.name.localName !== expected) {
+      fail("required-structure", name);
+      continue;
+    }
+    const view = interpretCompatibility(
+      part,
+      [dialect.p, dialect.a, dialect.r],
+      [
+        ...equationOpaqueElements,
+        { namespace: dialect.a, localName: "graphicData" },
+        { namespace: dialect.a, localName: "ext" },
+        { namespace: dialect.p, localName: "ext" }
+      ]
+    );
+    documents.set(name, { root: part.root, view, dialect });
+  }
+  for (const [name, { root, view, dialect: d }] of documents) {
+    const children = (node, local) => view.children(node).filter((child) => child.name.namespace === d.p && child.name.localName === local);
+    const outgoing = (kind) => graph.outgoing(name).filter((edge) => edge.type === `${d.r}/${kind}`);
+    const target = (edge, expected) => {
+      if (!edge || edge.external || edge.targetPart === null || roots.get(edge.targetPart) !== expected || !documents.has(edge.targetPart))
+        return null;
+      return edge.targetPart;
+    };
+    const required = (node, local) => {
+      const found = children(node, local);
+      if (found.length !== 1) fail("required-structure", name);
+      return found[0];
+    };
+    const listed = (listName, childName, kind, expected, rule, min, max) => {
+      const lists = children(root, listName);
+      if (lists.length > 1) fail("required-structure", name);
+      const ids = /* @__PURE__ */ new Set();
+      const targets = /* @__PURE__ */ new Set();
+      for (const list of lists)
+        for (const entry of children(list, childName)) {
+          const id = integer(attribute(entry, "id"), min, max);
+          const dest = target(
+            outgoing(kind).find((edge) => edge.id === attribute(entry, "id", d.r)),
+            expected
+          );
+          if (id === null || ids.has(id) || dest === null || targets.has(dest)) fail(rule, name);
+          if (id !== null) ids.add(id);
+          if (dest !== null) targets.add(dest);
+        }
+      return targets;
+    };
+    if (root.name.localName === "presentation") {
+      required(root, "notesSz");
+      listed("sldIdLst", "sldId", "slide", "sld", "slide-ids", 256, 2147483647);
+      listed(
+        "sldMasterIdLst",
+        "sldMasterId",
+        "slideMaster",
+        "sldMaster",
+        "master-layouts",
+        2147483648,
+        4294967295
+      );
+      for (const kind of ["notesMaster", "handoutMaster"]) {
+        const lists = children(root, `${kind}IdLst`);
+        if (lists.length > 1) fail("note-associations", name);
+        for (const list of lists) {
+          const entries = children(list, `${kind}Id`);
+          if (entries.length !== 1 || target(
+            outgoing(kind).find((edge) => edge.id === attribute(entries[0], "id", d.r)),
+            kind
+          ) === null)
+            fail("note-associations", name);
+        }
+      }
+      continue;
+    }
+    const common = required(root, "cSld");
+    const tree = common && required(common, "spTree");
+    const shapeIds = /* @__PURE__ */ new Set();
+    const drawingNodes = [];
+    if (tree) {
+      required(tree, "nvGrpSpPr");
+      required(tree, "grpSpPr");
+      const stack2 = [tree];
+      while (stack2.length) {
+        const node = stack2.pop();
+        drawingNodes.push(node);
+        if (node.name.namespace === d.p && node.name.localName === "cNvPr") {
+          const id = integer(attribute(node, "id"), 0, 4294967295);
+          if (id === null || shapeIds.has(id)) fail("shape-ids", name);
+          if (id !== null) shapeIds.add(id);
+        }
+        if (node.name.namespace === d.p) stack2.push(...view.children(node));
+      }
+      const nonvisual = /* @__PURE__ */ new Map([
+        ["sp", "nvSpPr"],
+        ["pic", "nvPicPr"],
+        ["grpSp", "nvGrpSpPr"],
+        ["graphicFrame", "nvGraphicFramePr"],
+        ["cxnSp", "nvCxnSpPr"],
+        ["spTree", "nvGrpSpPr"]
+      ]);
+      for (const node of drawingNodes) {
+        const nv = node.name.namespace === d.p ? nonvisual.get(node.name.localName) : void 0;
+        if (nv) {
+          const container = required(node, nv);
+          if (container) required(container, "cNvPr");
+        }
+      }
+    }
+    const all = [];
+    const stack = [root];
+    while (stack.length) {
+      const node = stack.pop();
+      all.push(node);
+      if (node.name.namespace === d.p || node.name.namespace === d.a)
+        stack.push(...view.children(node));
+    }
+    for (const node of all)
+      if (node.name.namespace === d.a && ["stCxn", "endCxn"].includes(node.name.localName)) {
+        const id = integer(attribute(node, "id"), 0, 4294967295);
+        if (id === null || !shapeIds.has(id) || integer(attribute(node, "idx"), 0, 4294967295) === null)
+          fail("connector-references", name);
+      }
+    const timingNodes = [];
+    const timingStack = [...children(root, "timing")];
+    while (timingStack.length) {
+      const node = timingStack.pop();
+      if (node.name.namespace !== d.p) continue;
+      timingNodes.push(node);
+      timingStack.push(...view.children(node));
+    }
+    const timingIds = /* @__PURE__ */ new Set();
+    for (const node of timingNodes)
+      if (node.name.localName === "cTn") {
+        const id = integer(attribute(node, "id"), 0, 4294967295);
+        if (id === null || timingIds.has(id)) fail("timing-references", name);
+        if (id !== null) timingIds.add(id);
+      }
+    for (const node of timingNodes) {
+      const shape = attribute(node, "spid");
+      if (shape !== void 0 || ["spTgt", "bldP", "bldDgm", "bldOleChart", "bldGraphic"].includes(node.name.localName)) {
+        const id = integer(shape, 0, 4294967295);
+        if (id === null || !shapeIds.has(id)) fail("timing-references", name);
+      }
+      if (node.name.localName === "tn") {
+        const id = integer(attribute(node, "val"), 0, 4294967295);
+        if (id === null || !timingIds.has(id)) fail("timing-references", name);
+      }
+    }
+    if (root.name.localName === "sld" || root.name.localName === "sldLayout") {
+      const kind = root.name.localName === "sld" ? "slideLayout" : "slideMaster";
+      const expected = root.name.localName === "sld" ? "sldLayout" : "sldMaster";
+      const edges = outgoing(kind);
+      if (edges.length !== 1 || target(edges[0], expected) === null) fail("master-layouts", name);
+      if (root.name.localName === "sldLayout" && target(edges[0], expected) !== null && edges[0]?.targetPart) {
+        if (!graph.outgoing(edges[0].targetPart).some((edge) => edge.type === `${d.r}/slideLayout` && edge.targetPart === name))
+          fail("master-layouts", name);
+      }
+    }
+    if (root.name.localName === "sldMaster") {
+      required(root, "clrMap");
+      const layouts = listed(
+        "sldLayoutIdLst",
+        "sldLayoutId",
+        "slideLayout",
+        "sldLayout",
+        "master-layouts",
+        2147483648,
+        4294967295
+      );
+      for (const edge of outgoing("slideLayout")) {
+        if (edge.targetPart === null || !layouts.has(edge.targetPart)) fail("master-layouts", name);
+      }
+      for (const layout of layouts)
+        if (!graph.outgoing(layout).some((edge) => edge.type === `${d.r}/slideMaster` && edge.targetPart === name))
+          fail("master-layouts", name);
+    }
+    if (["notesMaster", "handoutMaster"].includes(root.name.localName)) required(root, "clrMap");
+    if (root.name.localName === "sld" || root.name.localName === "notes") {
+      const isNotes = root.name.localName === "notes";
+      const kind = isNotes ? "slide" : "notesSlide";
+      const edges = outgoing(kind);
+      if (edges.length > 1 || isNotes && edges.length !== 1) fail("note-associations", name);
+      for (const edge of edges) {
+        const dest = target(edge, isNotes ? "sld" : "notes");
+        const inverse = isNotes ? "notesSlide" : "slide";
+        if (dest === null || graph.outgoing(dest).filter((back) => back.type === `${d.r}/${inverse}` && back.targetPart === name).length !== 1)
+          fail("note-associations", name);
+      }
+      if (isNotes) {
+        const masters = outgoing("notesMaster");
+        if (masters.length !== 1 || target(masters[0], "notesMaster") === null)
+          fail("note-associations", name);
+      }
+    }
+  }
+  return Object.freeze({
+    valid: issues.length === 0,
+    schema: "not-checked",
+    rules: Object.freeze([...rules]),
+    issues: Object.freeze(issues.map((issue) => Object.freeze(issue)))
+  });
+}
+
+export {
+  validatePresentation
+};