@poe-platform/safe-bash 0.1.806 → 0.1.807

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

@@ -0,0 +1,160 @@
+import {
+  duplicateSlides
+} from "./chunk-CK5Q6RDE.js";
+import {
+  removeSlides
+} from "./chunk-KD25ICP4.js";
+import {
+  applyTemplateBindings,
+  validateTemplateBindings
+} from "./chunk-TBVWTZTR.js";
+import {
+  readSelectionIndex
+} from "./chunk-CKEODJVT.js";
+import {
+  readBinary
+} from "./chunk-TL3KDYEM.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/template-repeat.ts
+function invalid() {
+  throw new OfficeError(
+    "invalid-value",
+    "Repeat requires closed stored records, distinct prototype positions and an explicit media policy.",
+    "usage"
+  );
+}
+function array(value) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || Reflect.ownKeys(value).length !== value.length + 1)
+    invalid();
+  for (let i = 0; i < value.length; i++)
+    if (!("value" in (Object.getOwnPropertyDescriptor(value, String(i)) ?? {}))) invalid();
+}
+function validateTemplateRepeat(value) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    invalid();
+  const keys = ["kind", "slides", "records", "mediaPolicy"];
+  if (Reflect.ownKeys(value).length !== keys.length || Reflect.ownKeys(value).some(
+    (key) => typeof key !== "string" || !keys.includes(key) || !("value" in Object.getOwnPropertyDescriptor(value, key))
+  ))
+    invalid();
+  const repeat = value;
+  if (repeat.kind !== "repeat" || !["shared-media", "isolated-instance"].includes(repeat.mediaPolicy))
+    invalid();
+  array(repeat.slides);
+  array(repeat.records);
+  if (!repeat.slides.length || repeat.slides.length > 1e3 || new Set(repeat.slides).size !== repeat.slides.length || repeat.slides.some((slide) => !Number.isSafeInteger(slide) || slide < 1))
+    invalid();
+  if (repeat.records.length > 1e3)
+    throw new OfficeError("resource-limit", "Repeat record limit exceeded.", "admit");
+  let count = 0;
+  for (const record of repeat.records) {
+    validateTemplateBindings(record);
+    count += record.length;
+    if (count > 1e3)
+      throw new OfficeError("resource-limit", "Repeat binding limit exceeded.", "admit");
+    if (record.some((binding) => !repeat.slides.includes(binding.slide))) invalid();
+  }
+}
+async function applyTemplateRepeat(input, repeat, context) {
+  validateTemplateRepeat(repeat);
+  if (repeat.slides.length * repeat.records.length > context.relationshipLimits.maxParts)
+    throw new OfficeError("resource-limit", "Repeated slide limit exceeded.", "admit");
+  const slides = [...repeat.slides], policy = repeat.mediaPolicy;
+  let payloadBytes = 0;
+  const size = (value) => {
+    for (const character of value) {
+      const point = character.codePointAt(0);
+      payloadBytes += point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+    }
+  };
+  for (const record of repeat.records)
+    for (const binding of record) {
+      if (binding.kind === "image") payloadBytes += binding.image.bytes.length;
+      else if (binding.kind === "table")
+        for (const row of binding.table)
+          for (const cell of row) {
+            size(cell);
+            payloadBytes++;
+          }
+      else size(binding.text);
+      if (payloadBytes > context.limits.maxBytes)
+        throw new OfficeError(
+          "resource-limit",
+          "Repeat payload exceeds the aggregate byte budget.",
+          "admit"
+        );
+    }
+  const records = repeat.records.map(
+    (record) => record.map(
+      (binding) => binding.kind === "image" ? { ...binding, image: { ...binding.image, bytes: [...binding.image.bytes] } } : binding.kind === "table" ? { ...binding, table: binding.table.map((row) => [...row]) } : { ...binding }
+    )
+  );
+  const source = await readBinary(input, context);
+  const index = await readSelectionIndex(source, context);
+  const prototypes = slides.map((position2) => {
+    const slide = index.slides[position2 - 1];
+    if (!slide)
+      throw new OfficeError("missing-selection", "A prototype slide does not exist.", "select");
+    return slide;
+  });
+  const position = Math.min(...slides);
+  for (const record of records) {
+    context.signal?.throwIfAborted();
+    await applyTemplateBindings(source, record, context, slides);
+  }
+  let bytes = source;
+  const cloneParts = [];
+  const bindingObjects = [];
+  let affected = prototypes.length;
+  for (const [recordIndex, record] of records.entries()) {
+    const insertAt = position + recordIndex * slides.length;
+    bytes = await duplicateSlides(
+      bytes,
+      {
+        selection: prototypes.map((slide) => ({ kind: "slide", id: slide.id })),
+        position: insertAt,
+        mediaPolicy: policy
+      },
+      context
+    );
+    const current = await readSelectionIndex(bytes, context);
+    cloneParts.push(
+      ...current.slides.slice(insertAt - 1, insertAt - 1 + slides.length).map((slide) => slide.part)
+    );
+    const bound = await applyTemplateBindings(
+      bytes,
+      record.map((binding) => ({ ...binding, slide: insertAt + slides.indexOf(binding.slide) })),
+      context
+    );
+    bytes = bound.bytes;
+    affected += slides.length + bound.affected;
+    bindingObjects.push(
+      ...bound.locations.map((location) => ({ owner: location.owner, objectId: location.objectId }))
+    );
+  }
+  bytes = await removeSlides(
+    bytes,
+    { selection: prototypes.map((slide) => ({ kind: "slide", id: slide.id })) },
+    context
+  );
+  const final = await readSelectionIndex(bytes, context);
+  const locations = records.length ? final.slides.filter((slide) => cloneParts.includes(slide.part)).map((slide) => slide.location) : prototypes.map((slide) => slide.location);
+  for (const target of bindingObjects) {
+    const object = final.objects.find(
+      (object2) => object2.location.owner === target.owner && object2.id === target.objectId
+    );
+    if (object && !locations.some(
+      (location) => location.owner === object.location.owner && location.objectId === object.id
+    ))
+      locations.push(object.location);
+  }
+  return { bytes, affected, locations };
+}
+
+export {
+  validateTemplateRepeat,
+  applyTemplateRepeat
+};

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

@@ -0,0 +1,292 @@
+import {
+  imageBatchActions
+} from "./chunk-Q6W5FRZG.js";
+import {
+  packUriBatchActions
+} from "./chunk-MOL3TRBT.js";
+import {
+  packageViewBatchActions
+} from "./chunk-IKHBXETN.js";
+import {
+  partProviderReceivers
+} from "./chunk-RMJNV6Q7.js";
+import {
+  BaseStyle,
+  CharacterStyle,
+  ColorFormat,
+  Font,
+  LatentStyle,
+  LatentStyles,
+  ParagraphFormat,
+  ParagraphStyle,
+  RGBColor,
+  Styles,
+  TabStop,
+  TabStops,
+  TableStyle,
+  modelOutput,
+  setStyleLinks
+} from "./chunk-YQYVEVUE.js";
+import {
+  StylesPart,
+  XmlElementView
+} from "./chunk-RZJRR4UJ.js";
+import {
+  modelVfsResolver
+} from "./chunk-A7EMM3SB.js";
+import {
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  Cm,
+  Emu,
+  Inches,
+  Length,
+  Mm,
+  Pt,
+  Twips,
+  docxOperationSchemas,
+  enumFamilies,
+  enumFromValue,
+  enumFromXml,
+  enumMembers,
+  enumString,
+  enumToXml,
+  enumValue,
+  isLength
+} from "./chunk-R4TYL2G6.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  archiveSettings,
+  readArchive
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/model-save-stage.ts
+var modelSaveOperations = ["model.document.Document.save.call", "model.parts.document.DocumentPart.save.call", "model.package.Package.save.call", "model.opc.package.OpcPackage.save.call"];
+var ModelSaveStage = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  archive;
+  destination;
+  get staged() {
+    return this.archive !== void 0;
+  }
+  async capture(output, save) {
+    if (output.capability !== this.context.binaryResolver?.capability)
+      throw new DocxUsageError("Unknown batch output capability token.");
+    if (output.path !== void 0) modelVfsResolver(output.path, output.capability, this.context);
+    if (this.destination && (this.destination.path !== output.path || this.destination.capability !== output.capability))
+      throw new DocxUsageError("Model saves must use the same outer destination.");
+    const chunks = [];
+    let size = 0;
+    const budget = this.context.budget;
+    await save({ async write(chunk) {
+      size += chunk.byteLength;
+      budget.check("serializedOutput", size);
+      budget.charge("retainedBytes", chunk.byteLength);
+      chunks.push(new Uint8Array(chunk));
+    } });
+    budget.charge("retainedBytes", size);
+    budget.charge("work", size);
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    this.archive = await readArchive(bytes, this.context);
+    this.destination = Object.freeze({ ...output });
+  }
+  async publish(options, context) {
+    if (!this.archive || !this.destination) throw new DocxUsageError("No model save has been staged.");
+    const path = options.inPlace ? options.input?.path : options.output;
+    if (!(options.dryRun && path === void 0) && path !== (this.destination.path ?? "-"))
+      throw new DocxUsageError("Model save output must match the outer destination.");
+    if (this.destination.path !== void 0 && this.context.binaryResolver?.filesystem !== context.filesystem)
+      throw new DocxUsageError("Model save requires the same admitted output authority.");
+    const caller = archiveSettings(context), settings = this.context;
+    const signal = AbortSignal.any([settings.signal, caller.signal]);
+    const limits = Object.fromEntries(Object.entries(settings.limits).map(([key, value]) => [key, Math.min(value, caller.limits[key])]));
+    const budget = settings.budget.lower(Object.fromEntries(Object.entries(settings.budget.limits).map(([key, value]) => [key, Math.min(value, caller.budget.limits[key])])), signal);
+    return publishDocumentArchive(this.archive, options, { ...context, limits, signal, budget, encoding: { order: "input", compression: "store" } });
+  }
+  async save(output, options = {}) {
+    const selected = modelOutput(output, options, this.context);
+    await this.publish(selected.options, { ...this.context, ...selected, encoding: { order: "input", compression: "store" } });
+  }
+};
+
+// packages/safe-bash-docx-engine/src/style-model-batch-operations.ts
+var styleActions = new Map([...packUriBatchActions, ...packageViewBatchActions]);
+function properties(prefix, owner, names, writable = names) {
+  for (const name of names) {
+    styleActions.set(`${prefix}.${name}.get`, (receiver) => {
+      if (!(receiver instanceof owner)) throw new DocxUsageError("The receiver does not support this property.");
+      return Reflect.get(receiver, name);
+    });
+    if (writable.includes(name)) styleActions.set(`${prefix}.${name}.set`, (receiver, args) => {
+      if (!(receiver instanceof owner)) throw new DocxUsageError("The receiver does not support this property.");
+      if (!Reflect.set(receiver, name, args.value)) throw new DocxUsageError("The property is not writable.");
+    });
+  }
+}
+function method(prefix, name, owner, action) {
+  styleActions.set(`${prefix}.${name}`, (receiver, args) => {
+    if (!(receiver instanceof owner)) throw new DocxUsageError("The receiver does not support this method.");
+    return action(receiver, args);
+  });
+}
+properties("model.parts.styles.StylesPart", StylesPart, ["styles"], []);
+properties("model.XmlElementView", XmlElementView, ["tag", "localName", "namespace", "attributes", "children", "text", "tail"], ["text", "tail"]);
+method("model.XmlElementView", "set_attribute.call", XmlElementView, (receiver, args) => receiver.set_attribute(args.name, args.value));
+method("model.XmlElementView", "insert.call", XmlElementView, (receiver, args) => receiver.insert(args.index, args.node));
+method("model.XmlElementView", "remove.call", XmlElementView, (receiver) => receiver.remove());
+method("model.XmlElementView", "serialize.call", XmlElementView, (receiver) => receiver.serialize());
+var styleProperties = ["name", "style_id", "priority", "hidden", "locked", "quick_style", "unhide_when_used"];
+for (const [name, owner] of [["BaseStyle", BaseStyle], ["CharacterStyle", CharacterStyle], ["ParagraphStyle", ParagraphStyle], ["_TableStyle", TableStyle], ["_NumberingStyle", BaseStyle]]) {
+  const prefix = `model.styles.style.${name}`;
+  properties(prefix, owner, [...styleProperties, "type", "builtin"], styleProperties);
+  method(prefix, "delete.call", owner, (receiver) => receiver.delete());
+  if (owner === CharacterStyle || owner === ParagraphStyle || owner === TableStyle) properties(prefix, owner, ["base_style", "font"], ["base_style"]);
+  if (owner === ParagraphStyle || owner === TableStyle) properties(prefix, owner, ["paragraph_format", "next_paragraph_style"], ["next_paragraph_style"]);
+}
+method("styles.links", "set", BaseStyle, (receiver, args) => receiver[setStyleLinks](args));
+var styles = "model.styles.styles.Styles";
+properties(styles, Styles, ["latent_styles"], []);
+method(styles, "add_style.call", Styles, (receiver, args) => receiver.add_style(args.name, args.styleType, args.builtin));
+method(styles, "default.call", Styles, (receiver, args) => receiver.default(args.styleType));
+method(styles, "get_by_id.call", Styles, (receiver, args) => receiver.get_by_id(args.styleId, args.styleType));
+method(styles, "get_style_id.call", Styles, (receiver, args) => receiver.get_style_id(args.styleOrName, args.styleType));
+method(styles, "__contains__.call", Styles, (receiver, args) => receiver.has(args.value));
+method(styles, "__getitem__.call", Styles, (receiver, args) => receiver.at(args.key));
+method(styles, "__iter__.call", Styles, (receiver) => [...receiver]);
+method(styles, "__len__.get", Styles, (receiver) => receiver.length);
+var latent = "model.styles.latent.LatentStyles";
+method(latent, "has.call", LatentStyles, (receiver, args) => receiver.has(args.name));
+properties(latent, LatentStyles, ["default_priority", "default_to_hidden", "default_to_locked", "default_to_quick_style", "default_to_unhide_when_used", "load_count"]);
+method(latent, "add_latent_style.call", LatentStyles, (receiver, args) => receiver.add_latent_style(args.name));
+method(latent, "__getitem__.call", LatentStyles, (receiver, args) => receiver.at(args.key));
+method(latent, "__iter__.call", LatentStyles, (receiver) => [...receiver]);
+method(latent, "__len__.get", LatentStyles, (receiver) => receiver.length);
+properties("model.styles.latent._LatentStyle", LatentStyle, ["name", "priority", "hidden", "locked", "quick_style", "unhide_when_used"], ["priority", "hidden", "locked", "quick_style", "unhide_when_used"]);
+method("model.styles.latent._LatentStyle", "delete.call", LatentStyle, (receiver) => receiver.delete());
+properties("model.text.run.Font", Font, ["all_caps", "bold", "complex_script", "cs_bold", "cs_italic", "double_strike", "emboss", "hidden", "imprint", "italic", "math", "no_proof", "outline", "rtl", "shadow", "small_caps", "snap_to_grid", "spec_vanish", "strike", "web_hidden", "name", "size", "underline", "highlight_color", "superscript", "subscript"]);
+properties("model.text.parfmt.ParagraphFormat", ParagraphFormat, ["alignment", "first_line_indent", "keep_together", "keep_with_next", "left_indent", "line_spacing", "line_spacing_rule", "page_break_before", "right_indent", "space_after", "space_before", "widow_control", "tab_stops"], ["alignment", "first_line_indent", "keep_together", "keep_with_next", "left_indent", "line_spacing", "line_spacing_rule", "page_break_before", "right_indent", "space_after", "space_before", "widow_control"]);
+var tabs = "model.text.tabstops.TabStops";
+method(tabs, "add_tab_stop.call", TabStops, (receiver, args) => receiver.add_tab_stop(args.position, args.alignment, args.leader));
+method(tabs, "__getitem__.get", TabStops, (receiver, args) => receiver.at(args.index));
+method(tabs, "__delitem__.call", TabStops, (receiver, args) => receiver.remove(args.index));
+method(tabs, "__iter__.call", TabStops, (receiver) => [...receiver]);
+method(tabs, "__len__.get", TabStops, (receiver) => receiver.length);
+method(tabs, "clear_all.call", TabStops, (receiver) => receiver.clear_all());
+properties("model.text.tabstops.TabStop", TabStop, ["alignment", "leader", "position"]);
+properties("model.text.run.Font", Font, ["color"], []);
+properties("model.dml.color.ColorFormat", ColorFormat, ["theme_color", "type"], ["theme_color"]);
+method("model.dml.color.ColorFormat", "rgb.get", ColorFormat, (receiver) => receiver.rgb);
+method("model.dml.color.ColorFormat", "rgb.set", ColorFormat, (receiver, args) => {
+  receiver.rgb = args.value === null ? null : args.value instanceof RGBColor ? args.value : RGBColor.from_string(args.value);
+});
+styleActions.set("model.shared.RGBColor.call", (_receiver, args) => new RGBColor(args.r, args.g, args.b));
+styleActions.set("model.shared.RGBColor.from_string.call", (_receiver, args) => RGBColor.from_string(args.rgbHexStr));
+method("model.shared.RGBColor", "__str__.call", RGBColor, (receiver) => receiver.toString());
+method("model.shared.RGBColor", "__len__.get", RGBColor, (receiver) => receiver.length);
+method("model.shared.RGBColor", "__iter__.call", RGBColor, (receiver) => [...receiver]);
+method("model.shared.RGBColor", "__getitem__.call", RGBColor, (receiver, args) => receiver.at(args.index));
+method("model.shared.RGBColor", "__getitem__.slice", RGBColor, (receiver, args) => receiver.slice(args.start, args.end));
+method("model.shared.RGBColor", "count.call", RGBColor, (receiver, args) => receiver.count(args.value));
+method("model.shared.RGBColor", "index.call", RGBColor, (receiver, args) => receiver.index(args.value, args.start, args.stop));
+method("model.shared.RGBColor", "__contains__.call", RGBColor, (receiver, args) => receiver.includes(args.channel));
+method("model.shared.RGBColor", "__reversed__.call", RGBColor, (receiver) => [...receiver.reversed()]);
+method("model.shared.RGBColor", "tuple_value_protocol.call", RGBColor, (receiver) => receiver.toArray());
+method("model.shared.RGBColor", "__eq__.call", RGBColor, (receiver, args) => receiver.equals(args.other instanceof RGBColor ? args.other : RGBColor.from_string(args.other)));
+for (const [prefix, owner] of [
+  ["model.styles.styles.Styles", Styles],
+  ["model.styles.style.BaseStyle", BaseStyle],
+  ["model.styles.style.CharacterStyle", CharacterStyle],
+  ["model.styles.style.ParagraphStyle", ParagraphStyle],
+  ["model.styles.style._TableStyle", TableStyle],
+  ["model.styles.style._NumberingStyle", BaseStyle],
+  ["model.styles.latent.LatentStyles", LatentStyles],
+  ["model.styles.latent._LatentStyle", LatentStyle],
+  ["model.text.run.Font", Font],
+  ["model.text.parfmt.ParagraphFormat", ParagraphFormat],
+  ["model.text.tabstops.TabStops", TabStops],
+  ["model.text.tabstops.TabStop", TabStop],
+  ["model.dml.color.ColorFormat", ColorFormat]
+]) {
+  properties(prefix, owner, ["element", "part"], []);
+  method(prefix, "__eq__.call", owner, (receiver, args) => receiver.equals(args.other));
+  method(prefix, "__ne__.call", owner, (receiver, args) => !receiver.equals(args.other));
+}
+for (const [name, factory, argument] of [["Length", Length, "emu"], ["Emu", Emu, "emu"], ["Inches", Inches, "inches"], ["Cm", Cm, "cm"], ["Mm", Mm, "mm"], ["Pt", Pt, "points"], ["Twips", Twips, "twips"]]) {
+  styleActions.set(`model.shared.${name}.call`, (_receiver, args) => factory(args[argument]));
+  for (const key of ["emu", "inches", "cm", "mm", "pt", "twips", "numeric_protocol"]) styleActions.set(`model.shared.${name}.${key}.get`, (receiver) => {
+    if (!isLength(receiver)) throw new DocxUsageError("Expected an owned length receiver.");
+    return receiver[key === "numeric_protocol" ? "emu" : key];
+  });
+}
+for (const [group, family, canonical] of [
+  ["section", "WD_ORIENTATION", "WD_ORIENTATION"],
+  ["section", "WD_SECTION_START", "WD_SECTION_START"],
+  ["section", "WD_HEADER_FOOTER_INDEX", "WD_HEADER_FOOTER_INDEX"],
+  ["table", "WD_CELL_VERTICAL_ALIGNMENT", "WD_CELL_VERTICAL_ALIGNMENT"],
+  ["table", "WD_TABLE_ALIGNMENT", "WD_TABLE_ALIGNMENT"],
+  ["table", "WD_ROW_HEIGHT_RULE", "WD_ROW_HEIGHT_RULE"],
+  ["table", "WD_TABLE_DIRECTION", "WD_TABLE_DIRECTION"],
+  ["text", "WD_BREAK_TYPE", "WD_BREAK_TYPE"],
+  ["shape", "WD_INLINE_SHAPE_TYPE", "WD_INLINE_SHAPE_TYPE"],
+  ["style", "WD_STYLE_TYPE", "WD_STYLE_TYPE"],
+  ["style", "WD_BUILTIN_STYLE", "WD_BUILTIN_STYLE"],
+  ["text", "WD_UNDERLINE", "WD_UNDERLINE"],
+  ["text", "WD_COLOR_INDEX", "WD_COLOR_INDEX"],
+  ["text", "WD_PARAGRAPH_ALIGNMENT", "WD_PARAGRAPH_ALIGNMENT"],
+  ["text", "WD_ALIGN_PARAGRAPH", "WD_PARAGRAPH_ALIGNMENT"],
+  ["text", "WD_LINE_SPACING", "WD_LINE_SPACING"],
+  ["text", "WD_TAB_ALIGNMENT", "WD_TAB_ALIGNMENT"],
+  ["text", "WD_TAB_LEADER", "WD_TAB_LEADER"],
+  ["dml", "MSO_THEME_COLOR", "MSO_THEME_COLOR"],
+  ["dml", "MSO_THEME_COLOR_INDEX", "MSO_THEME_COLOR"],
+  ["dml", "MSO_COLOR_TYPE", "MSO_COLOR_TYPE"]
+]) {
+  const prefix = `model.enum.${group}.${family}`;
+  const members = enumMembers(canonical);
+  const symbol = (receiver) => {
+    const found = members.find((member) => receiver !== null && typeof receiver === "object" && (Reflect.get(receiver, "enum") === member.enum || Reflect.get(receiver, "enum") === family) && Reflect.get(receiver, "name") === member.name);
+    if (!found) throw new DocxUsageError("Expected a symbol from the declared enum family.");
+    return found;
+  };
+  for (const [name, member] of Object.entries(enumFamilies[canonical].members)) styleActions.set(`${prefix}.${name}.get`, () => member);
+  styleActions.set(`${prefix}.fromValue.call`, (_receiver, args) => enumFromValue(canonical, args.value));
+  styleActions.set(`${prefix}.from_xml.call`, (_receiver, args) => enumFromXml(canonical, args.xmlValue));
+  styleActions.set(`${prefix}.name.get`, (receiver) => symbol(receiver).name);
+  styleActions.set(`${prefix}.value.get`, (receiver) => enumValue(symbol(receiver)));
+  for (const name of ["__str__", "toString"]) styleActions.set(`${prefix}.${name}.call`, (receiver) => enumString(symbol(receiver)));
+  styleActions.set(`${prefix}.xml_value.get`, (receiver) => symbol(receiver).xml_value ?? null);
+  styleActions.set(`${prefix}.to_xml.call`, (receiver, args) => {
+    symbol(receiver);
+    if (args.value === null) return null;
+    return enumToXml(canonical, typeof args.value === "number" ? args.value : symbol(args.value));
+  });
+  styleActions.set(`${prefix}.members.get`, () => new Map(Object.entries(enumFamilies[canonical].members)));
+  styleActions.set(`${prefix}.Symbol.iterator.call`, () => [...members]);
+}
+var styleModelBatchActions = new Map(
+  Object.keys(docxOperationSchemas).flatMap((id) => {
+    const action = styleActions.get(id);
+    return action ? [[id, action]] : [];
+  })
+);
+var styleModelBatchBootstrap = "model.document.Document.styles.get";
+var styleModelBatchOperations = Object.freeze([styleModelBatchBootstrap, ...modelSaveOperations, ...[...partProviderReceivers.keys()].map((type) => `model.types.${type}.part.get`), ...styleModelBatchActions.keys(), ...imageBatchActions.keys()].filter((id) => id in docxOperationSchemas));
+
+export {
+  modelSaveOperations,
+  ModelSaveStage,
+  styleModelBatchActions,
+  styleModelBatchBootstrap,
+  styleModelBatchOperations
+};