@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-326A5G42.js

@@ -0,0 +1,328 @@
+import {
+  writePackageArchive
+} from "./chunk-YRNBIU5U.js";
+import {
+  parseXmlPart
+} from "./chunk-L3WY5ASN.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/creation.ts
+var p = "http://schemas.openxmlformats.org/presentationml/2006/main";
+var a = "http://schemas.openxmlformats.org/drawingml/2006/main";
+var r = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var ct = "application/vnd.openxmlformats-officedocument.presentationml.";
+function invalid(message) {
+  throw new OfficeError("invalid-value", message, "usage");
+}
+function fields(value, allowed) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    invalid("Expected a structured creation object.");
+  if (Object.keys(value).some((key) => !allowed.includes(key))) invalid("Unknown creation field.");
+}
+function boundText(value, maximum) {
+  if (value.length > maximum)
+    throw new OfficeError("resource-limit", "Authored XML exceeds byte limits.", "serialize");
+  let size = 0;
+  for (const ch of value) {
+    const code = ch.codePointAt(0);
+    size += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+    if (size > maximum)
+      throw new OfficeError("resource-limit", "Authored XML exceeds byte limits.", "serialize");
+  }
+  return size;
+}
+function boundedJoin(values, maximum) {
+  const chunks = [];
+  let size = 0;
+  for (const value of values) {
+    size += boundText(value, maximum - size);
+    chunks.push(value);
+  }
+  return chunks.join("");
+}
+function escaped(value, maximum) {
+  if (typeof value !== "string") invalid("Expected text.");
+  boundText(value, maximum);
+  let result = "";
+  let size = 0;
+  for (const ch of value) {
+    const code = ch.codePointAt(0);
+    if (code < 32 && code !== 9 && code !== 10 && code !== 13 || code >= 55296 && code <= 57343 || code === 65534 || code === 65535)
+      invalid("Text contains an invalid XML character.");
+    const encoded = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "\r": "&#13;",
+      "\n": "&#10;",
+      "	": "&#9;"
+    }[ch] ?? ch;
+    size += boundText(encoded, maximum - size);
+    result += encoded;
+  }
+  return result;
+}
+function dimension(value, slide = false) {
+  if (!Number.isSafeInteger(value) || value < (slide ? 914400 : 1) || value > (slide ? 51206400 : 27273042316900))
+    invalid("Invalid EMU dimension.");
+  return value;
+}
+function date(value) {
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime()) || value.getUTCFullYear() < 1 || value.getUTCFullYear() > 9999)
+    invalid("Expected a valid UTC date.");
+  return value.toISOString().slice(0, 19) + "Z";
+}
+function xml(root, body, attributes = "") {
+  return `<p:${root} xmlns:p="${p}" xmlns:a="${a}" xmlns:r="${r}"${attributes}>${body}</p:${root}>`;
+}
+function relationships(entries) {
+  return `<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${entries.map(([id, type, target]) => `<Relationship Id="${id}" Type="${type}" Target="${target}"/>`).join("")}</Relationships>`;
+}
+function shapeTree(content, name, maximum) {
+  return `<p:cSld name="${escaped(name === void 0 ? "" : name, maximum)}"><p:spTree><p:nvGrpSpPr><p:cNvPr id="1" name=""/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="0" cy="0"/><a:chOff x="0" y="0"/><a:chExt cx="0" cy="0"/></a:xfrm></p:grpSpPr>${content}</p:spTree></p:cSld>`;
+}
+function textShape(shape, index, maximum) {
+  fields(shape, ["name", "x", "y", "width", "height", "text"]);
+  for (const value of [shape.x, shape.y])
+    if (!Number.isSafeInteger(value) || Math.abs(value) > 27273042316900)
+      invalid("Invalid shape position.");
+  if (typeof shape.text !== "string") invalid("Expected shape text.");
+  boundText(shape.text, maximum);
+  const paragraphs = boundedJoin(
+    (function* () {
+      for (const paragraph of shape.text.split("\n")) {
+        yield "<a:p>";
+        let first = true;
+        for (const run of paragraph.split("\v")) {
+          if (!first) yield "<a:br/>";
+          first = false;
+          yield `<a:r><a:t>${escaped(run, maximum)}</a:t></a:r>`;
+        }
+        yield "<a:endParaRPr/></a:p>";
+      }
+    })(),
+    maximum
+  );
+  return `<p:sp><p:nvSpPr><p:cNvPr id="${index + 2}" name="${escaped(shape.name === void 0 ? "" : shape.name, maximum)}"/><p:cNvSpPr txBox="1"/><p:nvPr/></p:nvSpPr><p:spPr><a:xfrm><a:off x="${shape.x}" y="${shape.y}"/><a:ext cx="${dimension(shape.width)}" cy="${dimension(shape.height)}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:noFill/><a:ln><a:noFill/></a:ln></p:spPr><p:txBody><a:bodyPr/><a:lstStyle/>${paragraphs}</p:txBody></p:sp>`;
+}
+async function createPresentation(options, context) {
+  fields(options, [
+    "kind",
+    "dialect",
+    "width",
+    "height",
+    "slides",
+    "properties",
+    "author",
+    "timestamp"
+  ]);
+  if (context?.signal?.aborted) throw new OfficeError("cancelled", "Operation cancelled.", "admit");
+  if (!context?.xmlLimits || !context.archiveLimits || !context.limits || !context.relationshipLimits)
+    invalid("Explicit creation limits are required.");
+  if (options.dialect === "strict")
+    throw new OfficeError("unsupported-profile", "Strict creation is not supported.", "usage");
+  if (options.dialect !== void 0 && options.dialect !== "transitional")
+    invalid("Invalid dialect.");
+  const kind = options.kind === void 0 ? "pptx" : options.kind;
+  if (!["pptx", "potx", "ppsx"].includes(kind)) invalid("Invalid presentation kind.");
+  const width = dimension(options.width === void 0 ? 12192e3 : options.width, true);
+  const height = dimension(options.height === void 0 ? 6858e3 : options.height, true);
+  const slides = options.slides === void 0 ? [] : options.slides;
+  if (!Array.isArray(slides)) invalid("Expected a slide array.");
+  if (slides.length * 2 + 11 > context.archiveLimits.maxMembers || slides.length + 6 > context.relationshipLimits.maxParts || slides.length * 2 + 8 > context.relationshipLimits.maxRelationships)
+    throw new OfficeError("resource-limit", "Creation graph exceeds resource limits.", "usage");
+  const maximum = Math.min(
+    context.xmlLimits.maxBytes,
+    context.archiveLimits.maxEntryBytes,
+    context.archiveLimits.maxTotalBytes
+  );
+  const members = [];
+  const overrides = [];
+  let total = 0;
+  let nodes = 0;
+  const add = (name, content, type) => {
+    boundText(content, Math.min(maximum, context.archiveLimits.maxTotalBytes - total));
+    const bytes = new TextEncoder().encode(content);
+    total += bytes.length;
+    if (total > context.archiveLimits.maxTotalBytes)
+      throw new OfficeError("resource-limit", "Creation exceeds byte limits.", "serialize");
+    nodes += parseXmlPart(bytes, {
+      ...context.xmlLimits,
+      maxNodes: context.xmlLimits.maxNodes - nodes
+    }).nodeCount;
+    members.push({ name, bytes });
+    if (type) overrides.push(`<Override PartName="/${name}" ContentType="${type}"/>`);
+  };
+  add(
+    "_rels/.rels",
+    relationships([
+      ["rId1", `${r}/officeDocument`, "ppt/presentation.xml"],
+      [
+        "rId2",
+        "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
+        "docProps/core.xml"
+      ],
+      ["rId3", `${r}/extended-properties`, "docProps/app.xml"]
+    ])
+  );
+  const presentationRels = [
+    ["rId1", `${r}/slideMaster`, "slideMasters/slideMaster1.xml"]
+  ];
+  for (let index = 0; index < slides.length; index++) {
+    const slide = slides[index];
+    fields(slide, ["name", "shapes"]);
+    const shapes = slide.shapes === void 0 ? [] : slide.shapes;
+    if (!Array.isArray(shapes)) invalid("Expected a shape array.");
+    if (shapes.length > context.xmlLimits.maxNodes)
+      throw new OfficeError("resource-limit", "Too many shapes.", "usage");
+    add(
+      `ppt/slides/slide${index + 1}.xml`,
+      xml(
+        "sld",
+        shapeTree(
+          boundedJoin(
+            (function* () {
+              for (let shapeIndex = 0; shapeIndex < shapes.length; shapeIndex++)
+                yield textShape(shapes[shapeIndex], shapeIndex, maximum);
+            })(),
+            maximum
+          ),
+          slide.name,
+          maximum
+        ) + "<p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>"
+      ),
+      `${ct}slide+xml`
+    );
+    add(
+      `ppt/slides/_rels/slide${index + 1}.xml.rels`,
+      relationships([["rId1", `${r}/slideLayout`, "../slideLayouts/slideLayout1.xml"]])
+    );
+    presentationRels.push([`rId${index + 2}`, `${r}/slide`, `slides/slide${index + 1}.xml`]);
+  }
+  add(
+    "ppt/presentation.xml",
+    xml(
+      "presentation",
+      `<p:sldMasterIdLst><p:sldMasterId id="2147483648" r:id="rId1"/></p:sldMasterIdLst>${slides.length ? `<p:sldIdLst>${slides.map((_, i) => `<p:sldId id="${256 + i}" r:id="rId${i + 2}"/>`).join("")}</p:sldIdLst>` : ""}<p:sldSz cx="${width}" cy="${height}"/><p:notesSz cx="6858000" cy="9144000"/>`
+    ),
+    `${ct}${{ pptx: "presentation", potx: "template", ppsx: "slideshow" }[kind]}.main+xml`
+  );
+  add("ppt/_rels/presentation.xml.rels", relationships(presentationRels));
+  add(
+    "ppt/slideMasters/slideMaster1.xml",
+    xml(
+      "sldMaster",
+      shapeTree("", "Original master", maximum) + '<p:clrMap bg1="lt1" tx1="dk1" bg2="lt2" tx2="dk2" accent1="accent1" accent2="accent2" accent3="accent3" accent4="accent4" accent5="accent5" accent6="accent6" hlink="hlink" folHlink="folHlink"/><p:sldLayoutIdLst><p:sldLayoutId id="2147483649" r:id="rId1"/></p:sldLayoutIdLst><p:txStyles><p:titleStyle/><p:bodyStyle/><p:otherStyle/></p:txStyles>'
+    ),
+    `${ct}slideMaster+xml`
+  );
+  add(
+    "ppt/slideMasters/_rels/slideMaster1.xml.rels",
+    relationships([
+      ["rId1", `${r}/slideLayout`, "../slideLayouts/slideLayout1.xml"],
+      ["rId2", `${r}/theme`, "../theme/theme1.xml"]
+    ])
+  );
+  add(
+    "ppt/slideLayouts/slideLayout1.xml",
+    xml(
+      "sldLayout",
+      shapeTree("", "Blank", maximum) + "<p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>",
+      ' type="blank" preserve="1"'
+    ),
+    `${ct}slideLayout+xml`
+  );
+  add(
+    "ppt/slideLayouts/_rels/slideLayout1.xml.rels",
+    relationships([["rId1", `${r}/slideMaster`, "../slideMasters/slideMaster1.xml"]])
+  );
+  const colors = {
+    dk1: "17212B",
+    lt1: "FFFFFF",
+    dk2: "34495E",
+    lt2: "F0F4F5",
+    accent1: "176B87",
+    accent2: "B86E33",
+    accent3: "5E8062",
+    accent4: "8665A2",
+    accent5: "B54C64",
+    accent6: "4D8E95",
+    hlink: "165DCC",
+    folHlink: "7043A3"
+  };
+  const fill = '<a:solidFill><a:schemeClr val="phClr"/></a:solidFill>';
+  const fonts = '<a:latin typeface="Arial"/><a:ea typeface=""/><a:cs typeface=""/>';
+  add(
+    "ppt/theme/theme1.xml",
+    `<a:theme xmlns:a="${a}" name="Original"><a:themeElements><a:clrScheme name="Original">${Object.entries(
+      colors
+    ).map(([key, value]) => `<a:${key}><a:srgbClr val="${value}"/></a:${key}>`).join(
+      ""
+    )}</a:clrScheme><a:fontScheme name="Original"><a:majorFont>${fonts}</a:majorFont><a:minorFont>${fonts}</a:minorFont></a:fontScheme><a:fmtScheme name="Original"><a:fillStyleLst>${fill.repeat(3)}</a:fillStyleLst><a:lnStyleLst>${[12700, 25400, 38100].map((w) => `<a:ln w="${w}">${fill}<a:prstDash val="solid"/></a:ln>`).join("")}</a:lnStyleLst><a:effectStyleLst>${"<a:effectStyle><a:effectLst/></a:effectStyle>".repeat(3)}</a:effectStyleLst><a:bgFillStyleLst>${fill.repeat(3)}</a:bgFillStyleLst></a:fmtScheme></a:themeElements></a:theme>`,
+    "application/vnd.openxmlformats-officedocument.theme+xml"
+  );
+  const properties = options.properties === void 0 ? {} : options.properties;
+  const strings = {
+    category: "cp:category",
+    content_status: "cp:contentStatus",
+    identifier: "dc:identifier",
+    language: "dc:language",
+    version: "cp:version",
+    title: "dc:title",
+    subject: "dc:subject",
+    author: "dc:creator",
+    keywords: "cp:keywords",
+    comments: "dc:description",
+    last_modified_by: "cp:lastModifiedBy"
+  };
+  fields(properties, [...Object.keys(strings), "revision", "created", "modified", "last_printed"]);
+  if (options.author !== void 0 && properties.author !== void 0)
+    invalid("Author is supplied twice.");
+  if (options.timestamp !== void 0 && (properties.created !== void 0 || properties.modified !== void 0))
+    invalid("Timestamp is supplied twice.");
+  const values = {
+    ...properties,
+    ...options.author === void 0 ? {} : { author: options.author },
+    ...options.timestamp === void 0 ? {} : { created: options.timestamp, modified: options.timestamp }
+  };
+  let core = "";
+  for (const [key, tag] of Object.entries(strings)) {
+    const value = values[key];
+    if (value !== void 0) {
+      const content = escaped(value, maximum);
+      if ([...value].length > 255) invalid("Core text exceeds 255 Unicode code points.");
+      core += `<${tag}>${content}</${tag}>`;
+    }
+  }
+  if (values.revision !== void 0) {
+    if (!Number.isSafeInteger(values.revision) || values.revision < 0) invalid("Invalid revision.");
+    core += `<cp:revision>${values.revision}</cp:revision>`;
+  }
+  for (const key of ["created", "modified", "last_printed"])
+    if (values[key] !== void 0) {
+      const tag = key === "last_printed" ? "cp:lastPrinted" : `dcterms:${key}`;
+      core += `<${tag}${key === "last_printed" ? "" : ' xsi:type="dcterms:W3CDTF"'}>${date(values[key])}</${tag}>`;
+    }
+  add(
+    "docProps/core.xml",
+    `<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">${core}</cp:coreProperties>`,
+    "application/vnd.openxmlformats-package.core-properties+xml"
+  );
+  add(
+    "docProps/app.xml",
+    `<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties"><Slides>${slides.length}</Slides></Properties>`,
+    "application/vnd.openxmlformats-officedocument.extended-properties+xml"
+  );
+  add(
+    "[Content_Types].xml",
+    `<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>${overrides.join("")}</Types>`
+  );
+  return writePackageArchive(members, context, { compression: "auto" });
+}
+
+export {
+  createPresentation
+};

package/dist/safe-bash/command-chunks/chunk-36KIT4DU.js

@@ -0,0 +1,218 @@
+import {
+  SlideTransferBudget
+} from "./chunk-SCG4LK5U.js";
+import {
+  importSelectedSlides
+} from "./chunk-4QRXKUD2.js";
+import {
+  writePackageArchive
+} from "./chunk-YRNBIU5U.js";
+import {
+  validatePresentation
+} from "./chunk-XDEA3TL5.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/slide-merge-split.ts
+function fields(value, allowed) {
+  if (!value || typeof value !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Object.keys(value).some((key) => !allowed.includes(key)))
+    throw new OfficeError("invalid-value", "Invalid slide transfer options.", "usage");
+}
+function positions(value, maximum) {
+  if (!Array.isArray(value) || !value.length)
+    throw new OfficeError("invalid-value", "Slide selection must be a nonempty array.", "usage");
+  if (value.length > maximum)
+    throw new OfficeError("resource-limit", "Too many slide selections.", "usage");
+  const copy = Array.from(value);
+  if (copy.some((position) => !Number.isSafeInteger(position) || position < 1) || new Set(copy).size !== copy.length)
+    throw new OfficeError(
+      "invalid-value",
+      "Slide positions must be unique positive integers.",
+      "usage"
+    );
+  return copy;
+}
+function transferContext(context) {
+  if (!context?.limits || !context.archiveLimits || !context.xmlLimits || !context.relationshipLimits)
+    throw new OfficeError("invalid-value", "Explicit slide transfer limits are required.", "usage");
+}
+async function presentation(bytes, budget) {
+  const reader = await budget.open(bytes);
+  const limits = {
+    ...budget.context.xmlLimits,
+    ...budget.context.relationshipLimits,
+    maxBytes: Math.min(
+      budget.context.xmlLimits.maxBytes,
+      budget.context.relationshipLimits.maxBytes
+    ),
+    maxEntries: budget.context.archiveLimits.maxMembers
+  };
+  if (!validatePresentation(reader, limits).valid)
+    throw new OfficeError(
+      "invalid-opc",
+      "Slide transfer requires a valid presentation graph.",
+      "validate-intent"
+    );
+  const graph = budget.graph(reader);
+  if (graph.dangling.length)
+    throw new OfficeError(
+      "invalid-opc",
+      "Presentation contains missing referenced parts.",
+      "validate-intent"
+    );
+  const main = graph.outgoing("/").find((edge) => edge.type.endsWith("/officeDocument"))?.targetPart;
+  if (!main)
+    throw new OfficeError("invalid-opc", "Presentation part is missing.", "validate-intent");
+  const xml = budget.xml(reader.get(main));
+  const slides = xml.root.children.filter(
+    (node) => node.name.namespace === xml.root.name.namespace && node.name.localName === "sldIdLst"
+  ).flatMap(
+    (list) => list.children.filter(
+      (node) => node.name.namespace === xml.root.name.namespace && node.name.localName === "sldId"
+    )
+  );
+  return { reader, graph, main, xml, slides };
+}
+function mergeIntent(sources, options, context) {
+  if (!Array.isArray(sources) || !sources.length || !["source", "destination"].includes(options.themePolicy) || options.dimensionPolicy !== void 0 && !["reject", "destination"].includes(options.dimensionPolicy))
+    throw new OfficeError("invalid-value", "Invalid merge sources or policies.", "usage");
+  if (sources.length > context.relationshipLimits.maxParts)
+    throw new OfficeError("resource-limit", "Too many merge sources.", "usage");
+  if (options.themePolicy === "destination")
+    throw new OfficeError(
+      "unsupported-edit",
+      "Merge currently requires source theme preservation.",
+      "validate-intent"
+    );
+  const selected = options.sourceSlides === void 0 ? void 0 : positions(options.sourceSlides, context.relationshipLimits.maxParts);
+  const inputs = Array.from(sources);
+  if (inputs.some(
+    (input) => !(input instanceof Uint8Array) && (!input || typeof input !== "object" || ("path" in input ? typeof input.path !== "string" || !input.path || !input.fs || typeof input.fs.readFile !== "function" : typeof input[Symbol.asyncIterator] !== "function"))
+  ))
+    throw new OfficeError(
+      "invalid-type",
+      "Merge sources require bytes or explicit input capabilities.",
+      "usage"
+    );
+  const policy = {
+    themePolicy: options.themePolicy,
+    ...options.dimensionPolicy === void 0 ? {} : { dimensionPolicy: options.dimensionPolicy }
+  };
+  return { inputs, selected, policy };
+}
+async function mergeSlides(destination, sources, options, context) {
+  transferContext(context);
+  fields(options, ["sourceSlides", "themePolicy", "dimensionPolicy"]);
+  const { inputs, selected, policy } = mergeIntent(sources, options, context);
+  return mergeSelectedDecks(
+    destination,
+    inputs,
+    { ...policy, ...selected === void 0 ? {} : { sourceSlides: selected } },
+    context,
+    new SlideTransferBudget(context)
+  );
+}
+async function mergeSelectedDecks(destination, sources, options, context, budget) {
+  transferContext(context);
+  fields(options, ["sourceSlides", "themePolicy", "dimensionPolicy"]);
+  const { inputs, selected, policy } = mergeIntent(sources, options, context);
+  context = budget.context;
+  let result = await budget.read(destination);
+  await presentation(result, budget);
+  for (const source of inputs) {
+    const bytes = await budget.read(source);
+    const info = await presentation(bytes, budget);
+    const sourceSlides = selected ?? info.slides.map((_, index) => index + 1);
+    if (sourceSlides.some((position) => position > info.slides.length))
+      throw new OfficeError(
+        "missing-selection",
+        "Slide position is outside a source slide list.",
+        "select"
+      );
+    if (!sourceSlides.length)
+      throw new OfficeError("missing-selection", "Source has no selected slides.", "select");
+    result = await importSelectedSlides(
+      result,
+      bytes,
+      { sourceSlides, ...policy },
+      context,
+      budget
+    );
+  }
+  return result;
+}
+async function splitSlides(input, options, context) {
+  transferContext(context);
+  fields(options, ["slides"]);
+  const selected = positions(options.slides, context.relationshipLimits.maxParts);
+  return splitSelectedDecks(input, { slides: selected }, context, new SlideTransferBudget(context));
+}
+async function splitSelectedDecks(input, options, context, budget) {
+  transferContext(context);
+  fields(options, ["slides"]);
+  const selected = positions(options.slides, context.relationshipLimits.maxParts);
+  context = budget.context;
+  const source = await budget.read(input);
+  const info = await presentation(source, budget);
+  if (selected.some((position) => position > info.slides.length))
+    throw new OfficeError(
+      "missing-selection",
+      "Slide position is outside the slide list.",
+      "select"
+    );
+  let blank = info.xml;
+  for (let index = blank.root.children.length - 1; index >= 0; index--) {
+    const node = blank.root.children[index];
+    if (node.name.namespace !== blank.root.name.namespace || !["sldSz", "notesSz", "defaultTextStyle", "kinsoku"].includes(node.name.localName))
+      blank = blank.spliceChildren(blank.root, index, 1, []);
+  }
+  const relationshipNamespace = "http://schemas.openxmlformats.org/package/2006/relationships";
+  const dialect = info.graph.outgoing("/").find((edge) => edge.targetPart === info.main).type;
+  const encoder = new TextEncoder();
+  const seed = await writePackageArchive(
+    [
+      {
+        name: "[Content_Types].xml",
+        bytes: encoder.encode(
+          '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Override PartName="/ppt/presentation.xml" ContentType="application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml"/></Types>'
+        )
+      },
+      {
+        name: "_rels/.rels",
+        bytes: encoder.encode(
+          `<Relationships xmlns="${relationshipNamespace}"><Relationship Id="deck" Type="${dialect}" Target="ppt/presentation.xml"/></Relationships>`
+        )
+      },
+      { name: "ppt/presentation.xml", bytes: blank.bytes() },
+      {
+        name: "ppt/_rels/presentation.xml.rels",
+        bytes: encoder.encode(`<Relationships xmlns="${relationshipNamespace}"/>`)
+      }
+    ],
+    budget.outputContext(),
+    { compression: "auto" }
+  );
+  budget.output(seed);
+  const outputs = [];
+  for (const sourceSlide of selected) {
+    const importOptions = {
+      sourceSlides: [sourceSlide],
+      themePolicy: "source"
+    };
+    const bytes = await importSelectedSlides(seed, source, importOptions, context, budget);
+    outputs.push({
+      name: `slide-${String(outputs.length + 1).padStart(6, "0")}.pptx`,
+      sourceSlide,
+      bytes
+    });
+  }
+  return outputs;
+}
+
+export {
+  mergeSlides,
+  mergeSelectedDecks,
+  splitSlides,
+  splitSelectedDecks
+};