@poe-platform/safe-bash 0.1.817 → 0.1.819

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

@@ -0,0 +1,416 @@
+import {
+  readXmlCoordinate,
+  readXmlInteger
+} from "./chunk-LBILRPVR.js";
+import {
+  Length
+} from "./chunk-GNVAW6NL.js";
+import {
+  attr,
+  child
+} from "./chunk-UDRJKA3P.js";
+import {
+  InvalidXmlError
+} from "./chunk-HTBUIRTH.js";
+import {
+  OfficeError,
+  characters,
+  equal,
+  literal
+} from "./chunk-VJQ5OWS5.js";
+import {
+  readJsonNumber
+} from "./chunk-NUGQQDGE.js";
+
+// packages/safe-bash-presentation-engine/src/retained-shape-geometry.ts
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
+
+// packages/safe-bash-presentation-engine/src/retained-xml-scalars.ts
+async function readRetainedXmlScalar(kind, source, check) {
+  let started = false, trailing = false, digits = false, dot = false, invalid2 = false, suffix = "";
+  async function* number() {
+    for await (const character of characters(source)) {
+      check();
+      if (invalid2) continue;
+      if (" 	\r\n".includes(character)) {
+        if (started) trailing = true;
+        continue;
+      }
+      if (trailing) {
+        invalid2 = true;
+        continue;
+      }
+      const first = !started;
+      started = true;
+      if (suffix || character === "%" || character >= "a" && character <= "z") {
+        if (suffix.length === 2) invalid2 = true;
+        else suffix += character;
+        continue;
+      }
+      if (first && (character === "+" || character === "-")) {
+        yield character;
+        continue;
+      }
+      if (character === "." && !dot) {
+        dot = true;
+        yield character;
+        continue;
+      }
+      if (character >= "0" && character <= "9") {
+        digits = true;
+        yield character;
+      } else invalid2 = true;
+    }
+  }
+  const value = await readJsonNumber(
+    number(),
+    async () => {
+      check();
+    },
+    false
+  );
+  check();
+  const units = {
+    in: 914400,
+    mm: 36e3,
+    cm: 36e4,
+    pt: 12700,
+    pc: 152400,
+    pi: 152400
+  };
+  const scale = kind === "coordinate" ? units[suffix] : void 0;
+  const fractional = scale !== void 0 || kind === "percentage" && suffix === "%";
+  if (invalid2 || !digits || !Number.isFinite(value) || dot && !fractional || suffix && !fractional)
+    throw new InvalidXmlError("Invalid numeric XML token.");
+  if (scale !== void 0) {
+    const scaled = value * scale, result = Math.sign(scaled) * Math.round(Math.abs(scaled));
+    if (!Number.isSafeInteger(result))
+      throw new InvalidXmlError("XML coordinate exceeds the safe range.");
+    return result === 0 ? 0 : result;
+  }
+  if (kind === "percentage" && suffix === "%") return value / 100;
+  if (!Number.isSafeInteger(value))
+    throw new InvalidXmlError("XML integer exceeds the safe range.");
+  return kind === "percentage" ? value / 1e5 : value;
+}
+
+// packages/safe-bash-presentation-engine/src/retained-shape-geometry.ts
+async function openRetainedShapeGeometry(doc, node, settings) {
+  const signal = settings.signal ?? new AbortController().signal, working = settings.workingStorage;
+  const pages = new PagedStorage(
+    { fs: working.fs, cwd: working.directory, env: {}, signal },
+    (working.cacheBytes ?? 1024 * 1024) / 16384
+  );
+  let closed = false;
+  const close = () => {
+    closed = true;
+    return pages.close();
+  };
+  const check = () => {
+    if (closed) throw new OfficeError("invalid-handle", "Shape geometry is closed.", "index");
+    if (signal.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "index");
+  };
+  const invalid2 = () => {
+    throw new OfficeError(
+      "unsupported-edit",
+      "Explicit nonsingular geometry is required for coordinate projection.",
+      "validate-intent"
+    );
+  };
+  const local = (n, name) => equal(doc.raw(n.localName), literal(name));
+  async function child2(n, name, namespace = () => doc.namespace(n)) {
+    let found;
+    for await (const item of doc.children(n))
+      if (item.kind === "element" && await local(item, name) && await equal(doc.namespace(item), namespace())) {
+        if (found) throw new OfficeError("invalid-value", "Ambiguous shared structure.", "usage");
+        found = item;
+      }
+    return found;
+  }
+  async function attr2(n, name) {
+    for await (const item of doc.attributes(n))
+      if (await local(item, name) && await equal(doc.namespace(item), literal(""))) return item;
+  }
+  async function transform2(n) {
+    const drawing = await equal(
+      doc.namespace(n),
+      literal("http://purl.oclc.org/ooxml/presentationml/main")
+    ) ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+    const frame = await local(n, "graphicFrame");
+    const owner = frame ? n : await child2(n, await local(n, "grpSp") ? "grpSpPr" : "spPr");
+    const xfrm = owner && await child2(owner, "xfrm", frame ? () => doc.namespace(n) : () => literal(drawing));
+    if (!xfrm) return null;
+    async function integer(name, key) {
+      const pair = await child2(xfrm, name, () => literal(drawing)), value = pair && await attr2(pair, key);
+      if (!value) return null;
+      try {
+        return await readRetainedXmlScalar(
+          name === "off" || name === "chOff" ? "coordinate" : "integer",
+          doc.text(value),
+          check
+        );
+      } catch (error) {
+        check();
+        if (error instanceof OfficeError && error.code === "invalid-xml") invalid2();
+        throw error;
+      }
+    }
+    const x = await integer("off", "x"), y = await integer("off", "y"), w = await integer("ext", "cx"), h = await integer("ext", "cy");
+    if (x === null || y === null || w === null || h === null) return null;
+    if (w < 0 || h < 0) invalid2();
+    const raw = await attr2(xfrm, "rot");
+    let rotation = 0;
+    if (raw)
+      try {
+        rotation = await readRetainedXmlScalar("integer", doc.text(raw), check);
+      } catch (error) {
+        check();
+        if (error instanceof OfficeError && error.code === "invalid-xml") invalid2();
+        throw error;
+      }
+    async function flip(key) {
+      const value = await attr2(xfrm, key);
+      if (!value) return 1;
+      for (const token of ["true", "false", "1", "0"])
+        if (await equal(doc.text(value), literal(token)))
+          return token === "true" || token === "1" ? -1 : 1;
+      return invalid2();
+    }
+    return {
+      x,
+      y,
+      w,
+      h,
+      integer,
+      map: shapeCoordinateMap(x, y, w, h, rotation, await flip("flipH"), await flip("flipV"))
+    };
+  }
+  async function write(pointer, row2) {
+    const bytes = new Uint8Array(row2.length * 8), view = new DataView(bytes.buffer);
+    row2.forEach((n, i) => view.setFloat64(i * 8, n, true));
+    await pages.write(pointer, bytes);
+  }
+  async function row(pointer) {
+    check();
+    const bytes = await pages.read(pointer, 24), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return [view.getFloat64(0, true), view.getFloat64(8, true), view.getFloat64(16, true)];
+  }
+  try {
+    check();
+    const target = doc.reference(node);
+    let top = 0, found = false;
+    for await (const item of doc.nodes()) {
+      check();
+      if (item.node.kind !== "element") continue;
+      while (top && (await row(top))[1] >= item.depth) top = (await row(top))[0];
+      if (doc.reference(item.node) === target) {
+        found = true;
+        break;
+      }
+      if (await local(item.node, "grpSp") && await equal(doc.namespace(item.node), doc.namespace(node))) {
+        const next = pages.allocate(24);
+        await write(next, [top, item.depth, doc.reference(item.node)]);
+        top = next;
+      }
+    }
+    if (!found)
+      throw new OfficeError(
+        "invalid-selection",
+        "Shape does not belong to the supplied drawing.",
+        "select"
+      );
+    const own = await transform2(node);
+    if (!own) return { value: null, close };
+    let corners = [
+      own.map(own.x, own.y),
+      own.map(own.x + own.w, own.y),
+      own.map(own.x + own.w, own.y + own.h),
+      own.map(own.x, own.y + own.h)
+    ];
+    const grouped = !!top;
+    let path = 0;
+    while (top) {
+      const data = await row(top), group = await doc.node(data[2]), parent = await transform2(group);
+      top = data[0];
+      if (!parent) return { value: null, close };
+      const cx = await parent.integer("chOff", "x"), cy = await parent.integer("chOff", "y"), cw = await parent.integer("chExt", "cx"), ch = await parent.integer("chExt", "cy");
+      if (cx === null || cy === null || cw === null || ch === null) return { value: null, close };
+      if (cw <= 0 || ch <= 0 || parent.w <= 0 || parent.h <= 0) invalid2();
+      corners = corners.map(
+        (point) => parent.map(
+          parent.x + (point.x - cx) * parent.w / cw,
+          parent.y + (point.y - cy) * parent.h / ch
+        )
+      );
+      const next = pages.allocate(24);
+      await write(next, [path, 0, data[2]]);
+      path = next;
+    }
+    for (let pointer = path; pointer; ) {
+      const data = await row(pointer), group = await doc.node(data[2]);
+      const nv = await child2(group, "nvGrpSpPr"), cn = nv && await child2(nv, "cNvPr"), id = cn && await attr2(cn, "id");
+      await write(pointer, [data[0], 0, id ? doc.reference(id) : 0]);
+      pointer = data[0];
+    }
+    async function* groupPath() {
+      check();
+      for (let pointer = path; pointer; ) {
+        const data = await row(pointer);
+        pointer = data[0];
+        const id = data[2] ? await doc.node(data[2]) : null;
+        yield id ? () => doc.text(id) : null;
+      }
+      check();
+    }
+    return {
+      value: {
+        coordinateSystem: grouped ? "group" : "slide",
+        unit: "emu",
+        groupPath: groupPath(),
+        corners: corners.map((point) => ({
+          x: new Length(point.x).emu,
+          y: new Length(point.y).emu
+        }))
+      },
+      close
+    };
+  } catch (error) {
+    await close().catch(() => {
+    });
+    throw error;
+  }
+}
+
+// packages/safe-bash-presentation-engine/src/shape-transforms.ts
+function invalid() {
+  throw new OfficeError(
+    "unsupported-edit",
+    "Explicit nonsingular geometry is required for coordinate projection.",
+    "validate-intent"
+  );
+}
+function transform(node) {
+  const a = node.name.namespace === "http://purl.oclc.org/ooxml/presentationml/main" ? "http://purl.oclc.org/ooxml/drawingml/main" : "http://schemas.openxmlformats.org/drawingml/2006/main";
+  const owner = node.name.localName === "graphicFrame" ? node : child(node, node.name.localName === "grpSp" ? "grpSpPr" : "spPr");
+  const xfrm = owner && child(owner, "xfrm", node.name.localName === "graphicFrame" ? node.name.namespace : a);
+  if (!xfrm) return null;
+  const integer = (name, key) => {
+    const pair = child(xfrm, name, a), value = pair && attr(pair, key);
+    if (value === void 0) return null;
+    try {
+      return name === "off" || name === "chOff" ? readXmlCoordinate(value) : readXmlInteger(value);
+    } catch {
+      invalid();
+    }
+  };
+  const x = integer("off", "x"), y = integer("off", "y"), w = integer("ext", "cx"), h = integer("ext", "cy");
+  if (x === null || y === null || w === null || h === null) return null;
+  if (w < 0 || h < 0) invalid();
+  const rawRotation = attr(xfrm, "rot");
+  let rotation = 0;
+  if (rawRotation !== void 0) {
+    try {
+      rotation = readXmlInteger(rawRotation);
+    } catch {
+      invalid();
+    }
+  }
+  const flip = (key) => {
+    const value = attr(xfrm, key);
+    if (value !== void 0 && !["true", "false", "1", "0"].includes(value)) invalid();
+    return value === "true" || value === "1" ? -1 : 1;
+  };
+  return {
+    x,
+    y,
+    w,
+    h,
+    integer,
+    map: shapeCoordinateMap(x, y, w, h, rotation, flip("flipH"), flip("flipV"))
+  };
+}
+function shapeCoordinateMap(x, y, w, h, rotation, fx, fy) {
+  const angle = (rotation % 216e5 + 216e5) % 216e5;
+  const quarter = angle / 54e5;
+  const cos = Number.isInteger(quarter) ? [1, 0, -1, 0][quarter] : Math.cos(angle / 6e4 * Math.PI / 180);
+  const sin = Number.isInteger(quarter) ? [0, 1, 0, -1][quarter] : Math.sin(angle / 6e4 * Math.PI / 180);
+  return (px, py) => {
+    const dx = (px - x - w / 2) * fx, dy = (py - y - h / 2) * fy;
+    return { x: x + w / 2 + dx * cos - dy * sin, y: y + h / 2 + dx * sin + dy * cos };
+  };
+}
+function readShapeGeometry(root, node) {
+  const projection = prepareProjection(root, node);
+  if (!projection) return null;
+  const { own, groups } = projection;
+  return {
+    coordinateSystem: groups.length ? "group" : "slide",
+    unit: "emu",
+    groupPath: groups.map((group) => {
+      const nv = child(group, "nvGrpSpPr"), cn = nv && child(nv, "cNvPr");
+      return cn ? attr(cn, "id") ?? null : null;
+    }),
+    corners: projection.project([
+      { x: own.x, y: own.y },
+      { x: own.x + own.w, y: own.y },
+      { x: own.x + own.w, y: own.y + own.h },
+      { x: own.x, y: own.y + own.h }
+    ])
+  };
+}
+function projectShapePoint(root, node, x, y) {
+  const projection = prepareProjection(root, node);
+  return projection?.project([{ x, y }])[0] ?? null;
+}
+function prepareProjection(root, node) {
+  const pending = [{ node: root, groups: [] }];
+  let groups;
+  while (pending.length) {
+    const current = pending.pop();
+    if (current.node === node) {
+      groups = current.groups;
+      break;
+    }
+    const ancestors = current.node.name.namespace === node.name.namespace && current.node.name.localName === "grpSp" ? [...current.groups, current.node] : current.groups;
+    for (const next of current.node.children) pending.push({ node: next, groups: ancestors });
+  }
+  if (!groups)
+    throw new OfficeError(
+      "invalid-selection",
+      "Shape does not belong to the supplied drawing.",
+      "select"
+    );
+  const own = transform(node);
+  if (!own) return null;
+  const parents = [];
+  for (const group of [...groups].reverse()) {
+    const parent = transform(group);
+    if (!parent) return null;
+    const cx = parent.integer("chOff", "x"), cy = parent.integer("chOff", "y"), cw = parent.integer("chExt", "cx"), ch = parent.integer("chExt", "cy");
+    if (cx === null || cy === null || cw === null || ch === null) return null;
+    if (cw <= 0 || ch <= 0 || parent.w <= 0 || parent.h <= 0) invalid();
+    parents.push({ parent, cx, cy, cw, ch });
+  }
+  return {
+    own,
+    groups,
+    project(points) {
+      let projected = points.map((point) => own.map(point.x, point.y));
+      for (const { parent, cx, cy, cw, ch } of parents)
+        projected = projected.map(
+          (point) => parent.map(
+            parent.x + (point.x - cx) * parent.w / cw,
+            parent.y + (point.y - cy) * parent.h / ch
+          )
+        );
+      return projected.map((point) => ({ x: new Length(point.x).emu, y: new Length(point.y).emu }));
+    }
+  };
+}
+
+export {
+  openRetainedShapeGeometry,
+  shapeCoordinateMap,
+  readShapeGeometry,
+  projectShapePoint
+};

package/dist/safe-bash/command-chunks/{chunk-NQL3WNFI.js → chunk-YYRVGXJH.js}

@@ -13,13 +13,22 @@ from pydantic import Field, create_model
 # The runtime's enabled provider owns network authorization and billing.
 # Keep the genuine plugin manager; disable the bundled direct-HTTP provider.
 llm.plugins.pm.set_blocked("llm.default_plugins.openai_models")
-llm.plugins.pm.set_blocked("llm.default_plugins.default_tools")
 
 
 def restrict_providers():
     def reject(*args, **kwargs):
         raise llm.ModelError("This runtime uses platform-configured providers")
-    llm.plugins.pm.register = reject
+    register = llm.plugins.pm.register
+    def register_tooling(plugin, name=None):
+        hooks = []
+        for attribute in dir(plugin):
+            options = llm.plugins.pm.parse_hookimpl_opts(plugin, attribute)
+            if options is not None:
+                hooks.append(options.get("specname") or attribute)
+        if not hooks or any(hook not in ("register_tools", "register_template_loaders", "register_fragment_loaders") for hook in hooks):
+            reject()
+        return register(plugin, name)
+    llm.plugins.pm.register = register_tooling
     llm.plugins.pm.load_setuptools_entrypoints = reject
 
 
@@ -109,6 +118,10 @@ def _request(model, prompt, stream, response, conversation):
 
     try:
         messages = []
+        def add_results(results):
+            for result in results:
+                messages.append({"role": "tool", "content": text_input(result.output),
+                                 "toolCallId": result.tool_call_id})
         for previous in conversation.responses if conversation else ():
             if previous.prompt.system:
                 messages.append({"role": "system", "content": text_input(previous.prompt.system)})
@@ -116,8 +129,20 @@ def _request(model, prompt, stream, response, conversation):
             attachments = previous.attachments or previous.prompt.attachments
             if attachments:
                 message["attachments"] = attachment_inputs(attachments)
-            messages.append(message)
-            messages.append({"role": "assistant", "content": text_input(previous.text_or_raise())})
+            if previous.prompt.prompt or attachments:
+                messages.append(message)
+            add_results(previous.prompt.tool_results)
+            text = previous.text_or_raise()
+            if text:
+                messages.append({"role": "assistant", "content": text_input(text)})
+            calls = previous.tool_calls_or_raise()
+            if calls:
+                messages.append({"role": "assistant", "content": "", "toolCalls": [
+                    {"name": call.name, "arguments": call.arguments,
+                     **({"id": call.tool_call_id} if call.tool_call_id is not None else {})}
+                    for call in calls
+                ]})
+        add_results(prompt.tool_results)
         payload = {**_context(), "model": model.model_id, "prompt": text_input(prompt.prompt),
                    "messages": messages, "stream": stream, "attachments": [], "retain_response": True,
                    "options": prompt.options.model_dump(exclude_none=True)}
@@ -125,6 +150,12 @@ def _request(model, prompt, stream, response, conversation):
             payload["system"] = text_input(prompt.system)
         if prompt.schema is not None:
             payload["schema"] = prompt.schema
+        if prompt.tools:
+            payload["tools"] = [
+                {"name": tool.name, "inputSchema": tool.input_schema,
+                 **({"description": tool.description} if tool.description is not None else {})}
+                for tool in prompt.tools
+            ]
         payload["attachments"] = attachment_inputs(prompt.attachments)
         yield payload
     finally:
@@ -148,6 +179,9 @@ def _event(event, response):
                            details=usage.get("details"))
         response.response_json = result.get("metadata", {})
         response.resolved_model = result.get("model", response.model.model_id)
+        for call in result.get("toolCalls", ()):
+            response.add_tool_call(llm.ToolCall(name=call["name"], arguments=call["arguments"],
+                                               tool_call_id=call.get("id")))
         return None
     raise llm.ModelError("This model returned non-text output")
 
@@ -167,7 +201,9 @@ class _HostModel:
 
     def __init__(self, entry):
         self.model_id = entry["id"]
+        self.can_stream = entry["metadata"].get("canStream", True)
         self.supports_schema = "schema" in entry["capabilities"]
+        self.supports_tools = "tools" in entry["capabilities"]
         self.attachment_types = set(entry["metadata"]["attachmentTypes"])
         self.Options = _options(entry["metadata"].get("options", {}))
 
@@ -192,6 +228,7 @@ class HostAsyncModel(_HostModel, llm.AsyncModel):
         from poe_llm import LlmError
         import safe_host
         with _request(self, prompt, stream, response, conversation) as payload:
+            payload["async"] = True
             events = bridge.stream(payload)
             try:
                 async for event in events:
@@ -230,7 +267,9 @@ def register_models(register):
     llm.get_default_model.__defaults__ = ("default_model.txt", _call("resolve_model", _context()))
     for entry in entries:
         if entry["metadata"]["outputType"] == "text/plain" and set(entry["capabilities"]) != {"embed"}:
-            register(HostModel(entry), HostAsyncModel(entry), aliases=entry["aliases"])
+            paired = entry.get("asyncModel")
+            register(HostModel(entry), HostAsyncModel(paired) if paired is not None else None,
+                     aliases=entry["aliases"])
 
 
 @llm.hookimpl(trylast=True)

package/dist/safe-bash/command-chunks/{chunk-35DU6I2M.js → chunk-Z7UPCDTU.js}

@@ -1,6 +1,6 @@
 import {
   resolveDocumentModelContext
-} from "./chunk-XPQUUFQD.js";
+} from "./chunk-FPOM47UA.js";
 import {
   CommentsPart,
   CoreProperties,
@@ -20,16 +20,16 @@ import {
   StylesPart,
   XmlPartView,
   _NumberingDefinitions
-} from "./chunk-TXU7MMHN.js";
+} from "./chunk-PH722HK2.js";
 import {
   acquireDocumentTransportInput
-} from "./chunk-4X2MPZXW.js";
+} from "./chunk-M42GCI5F.js";
 import {
   acquireImageModelInput
-} from "./chunk-IZ3SD5S2.js";
+} from "./chunk-K2NV6H7E.js";
 import {
   docxOperationSchemas
-} from "./chunk-FEKECRJP.js";
+} from "./chunk-EBTKM7KX.js";
 import {
   DocxUsageError
 } from "./chunk-WXMYTNWS.js";

package/dist/safe-bash/command-chunks/{chunk-O2XP6HQN.js → chunk-ZBGP6XEG.js}

@@ -5,7 +5,7 @@ import {
   credential,
   jsonBody,
   providerLimits
-} from "./chunk-4SISSPIH.js";
+} from "./chunk-HLRLMFMS.js";
 import {
   acceptsMimeType
 } from "./chunk-VMA3NJXU.js";

package/dist/safe-bash/command-chunks/{chunk-VWRHPDCD.js → chunk-ZIDESNHW.js}

@@ -1,10 +1,10 @@
 import {
   splitString
-} from "./chunk-GNT3SCF3.js";
+} from "./chunk-BOMCPF7N.js";
 import {
   jsonFragments,
   renderJsonFragment
-} from "./chunk-ZOEKSH3R.js";
+} from "./chunk-HCPEYQKT.js";
 import {
   JqError,
   JqLimitError,
@@ -14,7 +14,7 @@ import {
   objectKeyIterator,
   objectKeys,
   put
-} from "./chunk-5VO534FR.js";
+} from "./chunk-3K5FCRUG.js";
 import {
   decoder,
   encoder,

package/dist/safe-bash/command-chunks/{chunk-VVV45NLY.js → chunk-ZJUU5IAS.js}

@@ -1,7 +1,7 @@
 import {
   paragraphLineMultiples,
   paragraphUnits
-} from "./chunk-LZY46GYY.js";
+} from "./chunk-QMWBKR4C.js";
 import {
   DocxUsageError,
   validFontName

package/dist/safe-bash/command-chunks/{chunk-3ZWFE4CK.js → chunk-ZLMCWAAU.js}

@@ -1,26 +1,26 @@
 import {
   readTextBodies,
   validateTextReadingOptions
-} from "./chunk-YKODRSGT.js";
+} from "./chunk-FCGMSOF6.js";
 import {
   loadShared
-} from "./chunk-A5SPMSKD.js";
+} from "./chunk-UDRJKA3P.js";
 import {
   SelectionError,
   readSelectionIndex
-} from "./chunk-NCNHJRIY.js";
+} from "./chunk-SKF6PGA5.js";
 import {
   readPackage
-} from "./chunk-Q65GWGQR.js";
-import {
-  readBinary
-} from "./chunk-FAU2KL6I.js";
+} from "./chunk-KVTZJBLM.js";
 import {
   parseXmlPart
-} from "./chunk-7PYDVQPB.js";
+} from "./chunk-YWP62BAZ.js";
+import {
+  readBinary
+} from "./chunk-S5MBHFLB.js";
 import {
   OfficeError
-} from "./chunk-KM2SMMXZ.js";
+} from "./chunk-VJQ5OWS5.js";
 
 // packages/safe-bash-presentation-engine/src/equations.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-7OCTMVYJ.js → chunk-ZNABMTV3.js}

@@ -8,7 +8,7 @@ import {
   docxOperationSchemas,
   isDocxLiteralUnion,
   splitDocxType
-} from "./chunk-FEKECRJP.js";
+} from "./chunk-EBTKM7KX.js";
 import {
   DocxUsageError
 } from "./chunk-WXMYTNWS.js";