@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash/command-chunks/pptx-7G52EJ6L-4JACH5FB.js

@@ -0,0 +1,625 @@
+import {
+  Emu,
+  GraphicFrame,
+  Image,
+  OfficeError,
+  PP_PLACEHOLDER_TYPE,
+  Picture,
+  Presentation,
+  Pt,
+  Shape,
+  addSlide,
+  createPresentation,
+  mutateNotes,
+  mutateTextParagraphs,
+  readAnimations,
+  readCharts,
+  readImages,
+  readLayouts,
+  readNotes,
+  readObjects,
+  readPresentationText,
+  readSelectionIndex,
+  readTextParagraphs,
+  removeSlides
+} from "./chunk-AI5JAXQF.js";
+import "./chunk-6X2OX6IJ.js";
+import {
+  imageLength
+} from "./chunk-BAXU7B5Z.js";
+import "./chunk-5LU4UCBR.js";
+import "./chunk-RDV7UCYZ.js";
+import {
+  PandocError
+} from "./chunk-7OKDCM5U.js";
+import "./chunk-X4P42NYK.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-pandoc/dist/chunks/pptx-7G52EJ6L.js
+init_buffer();
+var attr = ["", [], []];
+function engineContext(context) {
+  const l = context.limits;
+  const expanded = Math.min(l.expandedBytes, l.resourceBytes, l.retainedBytes);
+  for (const key of ["expandedBytes", "resourceBytes", "retainedBytes"]) context.bound(key, 1);
+  return {
+    ...context.signal ? { signal: context.signal } : {},
+    limits: { maxBytes: Math.min(l.binaryBytes, Math.max(l.inputBytes, l.outputBytes)), maxReads: l.work, chunkBytes: 4096 },
+    archiveLimits: {
+      maxArchiveBytes: l.compressedBytes,
+      maxEntryBytes: Math.min(l.binaryBytes, expanded),
+      maxTotalBytes: expanded,
+      maxMembers: l.parts,
+      maxPathBytes: l.text,
+      maxDepth: l.depth,
+      maxPaxBytes: l.binaryBytes,
+      maxTextBytes: l.text,
+      chunkSize: 4096
+    },
+    xmlLimits: { maxBytes: l.binaryBytes, maxNodes: l.xmlNodes, maxDepth: l.xmlDepth },
+    relationshipLimits: { maxBytes: l.binaryBytes, maxParts: l.parts, maxRelationships: l.references }
+  };
+}
+function fail(context, message, code = "E_CAPABILITY") {
+  throw new PandocError(code, context.operation ?? "convert", message, "pptx");
+}
+function loss(context, message) {
+  if (!context.lossy) fail(context, message);
+  context.report({ code: "W_PRESENTATION_LOSS", operation: context.operation ?? "read", format: "pptx", message });
+}
+async function guarded(context, action) {
+  try {
+    return await action();
+  } catch (error) {
+    if (!(error instanceof OfficeError)) throw error;
+    throw new PandocError(
+      error.code === "cancelled" ? "E_CANCELLED" : error.code === "resource-limit" ? "E_LIMIT" : "E_PARSE",
+      context.operation ?? "convert",
+      error.message,
+      "pptx"
+    );
+  }
+}
+function setting(document, key, fallback, context) {
+  const value = document.metadata[key];
+  if (!value) return fallback;
+  if (value.t !== "MetaString") fail(context, `${key} requires a string`, "E_OPTION");
+  return value.c;
+}
+function slideLevel(document, context) {
+  const value = setting(document, "pptx-slide-level", "1", context);
+  if (!["1", "2", "3", "4", "5", "6"].includes(value)) fail(context, "pptx-slide-level requires an explicit integer from 1 to 6", "E_OPTION");
+  return Number(value);
+}
+function slides(document, level) {
+  const result = [];
+  let current;
+  for (const block of document.blocks) {
+    if (block.t === "Div" && block.c[0][1].includes("slide")) {
+      current = { title: void 0, blocks: [], notes: [] };
+      result.push(current);
+      for (const child of block.c[1]) {
+        if (child.t === "Header" && child.c[0] === level && current.title === void 0 && !current.blocks.length) current.title = child.c[2];
+        else if (child.t === "Div" && child.c[0][1].includes("notes")) current.notes.push(...child.c[1]);
+        else current.blocks.push(child);
+      }
+    } else if (block.t === "Header" && block.c[0] === level) {
+      current = { title: block.c[2], blocks: [], notes: [] };
+      result.push(current);
+    } else if (block.t === "HorizontalRule") {
+      current = { title: void 0, blocks: [], notes: [] };
+      result.push(current);
+    } else {
+      if (!current) {
+        current = { title: void 0, blocks: [], notes: [] };
+        result.push(current);
+      }
+      if (block.t === "Div" && block.c[0][1].includes("notes")) current.notes.push(...block.c[1]);
+      else current.blocks.push(block);
+    }
+  }
+  return result;
+}
+function plainContent(nodes, context) {
+  if (nodes.some((n) => !["Str", "Space", "SoftBreak", "LineBreak", "Code"].includes(n.t))) fail(context, "Notes require plaintext; rich content is unsupported");
+  return plain(nodes, context);
+}
+function plain(nodes, context) {
+  return nodes.map((node) => {
+    context.checkpoint();
+    switch (node.t) {
+      case "Str":
+        return node.c;
+      case "Space":
+      case "SoftBreak":
+        return " ";
+      case "LineBreak":
+        return "\v";
+      case "Code":
+        return node.c[1];
+      case "Link":
+      case "Span":
+        return plain(node.c[1], context);
+      case "Emph":
+      case "Strong":
+      case "Strikeout":
+      case "Superscript":
+      case "Subscript":
+      case "Underline":
+        return plain(node.c, context);
+      case "Quoted":
+        return (node.c[0] === "SingleQuote" ? "\u2018" : "\u201C") + plain(node.c[1], context) + (node.c[0] === "SingleQuote" ? "\u2019" : "\u201D");
+      default:
+        return fail(context, `Unsupported PPTX inline: ${node.t}`);
+    }
+  }).join("");
+}
+function writeInline(paragraph, nodes, context) {
+  paragraph.clear();
+  const add = (inlines, style = {}) => {
+    for (const node of inlines) {
+      context.checkpoint();
+      if (node.t === "Strong") add(node.c, { ...style, bold: true });
+      else if (node.t === "Emph") add(node.c, { ...style, italic: true });
+      else if (node.t === "Strikeout") add(node.c, { ...style, strike: "single" });
+      else if (node.t === "Underline") add(node.c, { ...style, underline: true });
+      else if (node.t === "Superscript" || node.t === "Subscript") add(node.c, { ...style, baseline: node.t === "Superscript" ? 30 : -25 });
+      else if (node.t === "Quoted") add([{ t: "Str", c: node.c[0] === "SingleQuote" ? "\u2018" : "\u201C" }, ...node.c[1], { t: "Str", c: node.c[0] === "SingleQuote" ? "\u2019" : "\u201D" }], style);
+      else if (node.t === "Span") add(node.c[1], style);
+      else if (node.t === "Link") {
+        if (!node.c[2][0] || node.c[2][0].startsWith("#")) fail(context, "Internal document links require slide target resolution");
+        add(node.c[1], { ...style, url: node.c[2][0] });
+      } else if (node.t === "LineBreak") paragraph.add_line_break();
+      else {
+        const run = paragraph.add_run();
+        run.text = plain([node], context);
+        run.font.bold = style.bold ?? false;
+        run.font.italic = style.italic ?? false;
+        run.font.size = new Pt(style.baseline ? 14 : 20);
+        if (style.strike) run.font.strike = style.strike;
+        if (style.baseline) run.font.baseline = style.baseline;
+        if (style.underline) run.font.underline = true;
+        if (node.t === "Code") run.font.name = "Courier New";
+        if (style.url) run.hyperlink.address = style.url;
+      }
+    }
+  };
+  add(nodes);
+}
+function referenceBox(layout, types, fallback, width, height, context) {
+  const matches = layout?.placeholders.filter((p) => types.includes(p.type)) ?? [];
+  if (matches.length > 1) fail(context, "Ambiguous reference content placeholders");
+  const placeholder = matches[0];
+  if (!placeholder) return { box: fallback, placeholder };
+  const { x, y, width: w, height: h } = placeholder;
+  if (x === null || y === null || w === null || h === null || ![x, y, w, h].every(Number.isSafeInteger) || x < 0 || y < 0 || w <= 0 || h <= 0 || x + w > width || y + h > height)
+    fail(context, "Missing or overflowing reference placeholder geometry");
+  return { box: { x, y, width: w, height: h }, placeholder };
+}
+var pptxWriter = {
+  format: "pptx",
+  imageResources: "embed",
+  async write(document, context) {
+    return guarded(context, async () => {
+      const ec = engineContext(context);
+      const content = slides(document, slideLevel(document, context));
+      context.report({ code: "W_LAYOUT_UNMEASURED", operation: context.operation ?? "write", format: "pptx", message: "Text is preserved within authored-content and geometry limits; text fit is unmeasured and may overflow. No rendering engine is used." });
+      context.bound("pages", content.length);
+      const reference = setting(document, "pptx-reference", "", context);
+      const selectedLayouts = [];
+      let bytes;
+      if (reference) {
+        if (!context.resources) fail(context, "Reference deck requires an explicit resource capability", "E_RESOURCE");
+        bytes = await context.resources.resolve(reference, void 0, context.signal);
+        context.bound("inputBytes", bytes.byteLength);
+        const layoutRecords = await readLayouts(bytes, ec);
+        if ((await readSelectionIndex(bytes, ec)).slides.length)
+          bytes = await removeSlides(bytes, { selection: { kind: "slide", all: true }, referencePolicy: "remove" }, ec);
+        for (const item of content) {
+          const kind = item.title ? item.blocks.length ? "title-body" : "title-only" : "blank";
+          const name = setting(document, `pptx-layout-${kind}`, { "title-body": "Title and Content", "title-only": "Title Only", blank: "Blank" }[kind], context);
+          const matches = layoutRecords.filter((l) => l.name === name);
+          if (matches.length !== 1) fail(context, `Missing or ambiguous reference layout: ${name}`);
+          if (!["blank", "titleOnly", "title", "tx", "obj"].includes(matches[0].type)) fail(context, `Unsupported reference layout type: ${matches[0].type}; only single-column layouts are supported`);
+          selectedLayouts.push(matches[0]);
+          bytes = await addSlide(bytes, { layout: matches[0].part }, ec);
+        }
+      } else bytes = await createPresentation({ width: 12192e3, height: 6858e3 }, ec);
+      const model = await Presentation(bytes, ec);
+      const width = model.slide_width.emu, height = model.slide_height.emu;
+      const margin = Math.round(width * 0.05), bodyWidth = width - margin * 2;
+      const bullets = [];
+      for (const [index, item] of content.entries()) {
+        await context.cooperate();
+        const slide = reference ? model.slides.get(index) : model.slides.add_slide(model.slide_layouts.get(0));
+        const layout = selectedLayouts[index];
+        const body = referenceBox(layout, ["body", "obj"], { x: margin, y: 14e5, width: bodyWidth, height: height - 19e5 }, width, height, context).box;
+        if (reference) {
+          for (const shape of slide.shapes) if (shape instanceof Shape && shape.is_placeholder && shape.has_text_frame) shape.text_frame.clear();
+        }
+        let y = body.y;
+        const paragraph = (nodes, level = 0, bullet) => {
+          const text = plain(nodes, context);
+          if (text.length > 800 || y + 45e4 > body.y + body.height || body.width - level * 3e5 <= 0) fail(context, "PPTX content exceeds the conservative paragraph/geometry admission policy");
+          context.charge("objects", 1);
+          const shape = slide.shapes.add_textbox(new Emu(body.x + level * 3e5), new Emu(y), new Emu(body.width - level * 3e5), new Emu(45e4));
+          writeInline(shape.text_frame.paragraphs[0], nodes, context);
+          shape.text_frame.paragraphs[0].level = level;
+          shape.name = `Pandoc paragraph ${shape.shape_id}`;
+          if (bullet) bullets.push({ slide: index + 1, shape: shape.name, level, bullet });
+          y += 5e5;
+          return shape;
+        };
+        if (item.title) {
+          const { box, placeholder } = referenceBox(layout, ["title", "ctrTitle"], { x: margin, y: 4e5, width: bodyWidth, height: 8e5 }, width, height, context);
+          const native = placeholder ? [...slide.shapes].find((shape) => shape instanceof Shape && shape.is_placeholder && shape.has_text_frame && shape.placeholder_format.idx === placeholder.index && shape.placeholder_format.type === PP_PLACEHOLDER_TYPE.from_xml(placeholder.type)) : void 0;
+          const title = native instanceof Shape ? native : slide.shapes.add_textbox(new Emu(box.x), new Emu(box.y), new Emu(box.width), new Emu(box.height));
+          title.left = new Emu(box.x);
+          title.top = new Emu(box.y);
+          title.width = new Emu(box.width);
+          title.height = new Emu(box.height);
+          title.name = "Pandoc slide title";
+          title.text_frame.clear();
+          writeInline(title.text_frame.paragraphs[0], item.title, context);
+          for (const run of title.text_frame.paragraphs[0].runs) run.font.size = new Pt(30);
+        }
+        const blocks = async (nodes, level = 0, bullet) => {
+          let firstParagraph = true;
+          for (const block of nodes) {
+            await context.cooperate();
+            if (level > 8) fail(context, "PPTX lists support at most nine levels");
+            switch (block.t) {
+              case "Para":
+              case "Plain": {
+                if (block.c.length > 1 && block.c.some((node) => node.t === "Image")) {
+                  const fragments = [];
+                  let pending = [];
+                  for (const node of block.c) {
+                    if (node.t === "Image") {
+                      if (pending.length) fragments.push({ t: "Para", c: pending });
+                      fragments.push({ t: "Para", c: [node] });
+                      pending = [];
+                    } else pending.push(node);
+                  }
+                  if (pending.length) fragments.push({ t: "Para", c: pending });
+                  await blocks(fragments, level, firstParagraph ? bullet : void 0);
+                  firstParagraph = false;
+                  break;
+                }
+                const image = block.c.length === 1 && block.c[0].t === "Image" ? block.c[0] : void 0;
+                if (!image) {
+                  const shape = paragraph(block.c, level, firstParagraph ? bullet : void 0);
+                  if (bullet && !firstParagraph) shape.name = "Pandoc list continuation";
+                  firstParagraph = false;
+                  break;
+                }
+                if (bullet && firstParagraph) {
+                  paragraph([], level, bullet);
+                  firstParagraph = false;
+                }
+                const id = image.c[2][0];
+                const media = document.resources.find((r) => r.id === id)?.bytes ?? await context.resources?.resolve(id, void 0, context.signal);
+                if (!media) fail(context, `Missing image resource: ${id}`, "E_RESOURCE");
+                const asset = new Image(media);
+                if (!["image/png", "image/jpeg"].includes(asset.content_type)) fail(context, "Only PNG and JPEG pictures are supported");
+                const attrs = Object.fromEntries(image.c[0][2]);
+                const naturalWidth = asset.size[0] * 914400 / asset.dpi[0];
+                const naturalHeight = asset.size[1] * 914400 / asset.dpi[1];
+                let w = imageLength(attrs.width, naturalWidth, context, "pptx"), h = imageLength(attrs.height, naturalHeight, context, "pptx");
+                if (attrs.width && !attrs.height) h = Math.round(w * naturalHeight / naturalWidth);
+                if (attrs.height && !attrs.width) w = Math.round(h * naturalWidth / naturalHeight);
+                if (Math.abs(w / h - naturalWidth / naturalHeight) > 0.01) fail(context, "Picture dimensions must preserve aspect ratio");
+                if (attrs.width || attrs.height) {
+                  if (w > body.width || y + h > body.y + body.height) fail(context, "Explicit image dimensions overflow the slide");
+                } else {
+                  const scale = Math.min(1, body.width / w, (body.y + body.height - y) / h);
+                  w = Math.round(w * scale);
+                  h = Math.round(h * scale);
+                }
+                context.charge("images", 1);
+                const picture = await slide.shapes.add_picture(media, new Emu(body.x), new Emu(y), new Emu(w), new Emu(h));
+                picture.name = plain(image.c[1], context);
+                y += h + 5e5;
+                break;
+              }
+              case "Header":
+                paragraph(block.c[2], level);
+                break;
+              case "CodeBlock": {
+                for (const line of block.c[1].split("\n")) {
+                  paragraph([{ t: "Code", c: [block.c[0], line] }], level, firstParagraph ? bullet : void 0);
+                  firstParagraph = false;
+                }
+                break;
+              }
+              case "HorizontalRule":
+                paragraph([{ t: "Str", c: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }], level);
+                break;
+              case "Div":
+              case "BlockQuote": {
+                const before = y;
+                await blocks(block.t === "Div" ? block.c[1] : block.c, block.t === "Div" ? level : level + 1, firstParagraph ? bullet : void 0);
+                if (y !== before) firstParagraph = false;
+                break;
+              }
+              case "BulletList":
+                for (const item2 of block.c) await blocks(item2, bullet ? level + 1 : level, { kind: "character", character: "\u2022" });
+                break;
+              case "OrderedList":
+                if (!["Decimal", "DefaultStyle"].includes(block.c[0][1])) fail(context, "Only decimal numbered lists are supported");
+                if (!["Period", "DefaultDelim"].includes(block.c[0][2])) fail(context, "Only period-delimited numbered lists are supported");
+                for (const [i, item2] of block.c[1].entries()) await blocks(item2, bullet ? level + 1 : level, { kind: "numbered", scheme: "arabicPeriod", startAt: block.c[0][0] + i });
+                break;
+              case "Table": {
+                if (bullet || block.c[1][0]?.length || block.c[1][1].length) fail(context, "Table captions and tables in lists are unsupported");
+                if (block.c[2].some(([alignment, width2]) => alignment !== "AlignDefault" || width2.t !== "ColWidthDefault"))
+                  fail(context, "Explicit table column alignment and widths are unsupported");
+                if (block.c[3][1].length > 1 || block.c[5][1].length)
+                  fail(context, "Multiple table header rows and table footers are unsupported");
+                const rows = [...block.c[3][1], ...block.c[4].flatMap((body2) => {
+                  if (body2[1] || body2[2].length) fail(context, "Intermediate table headers and row headers are unsupported");
+                  return body2[3];
+                }), ...block.c[5][1]];
+                const count = block.c[2].length;
+                const h = rows.length * 45e4;
+                if (!rows.length || !count || y + h > body.y + body.height) fail(context, "Table geometry overflows the slide");
+                const table = slide.shapes.add_table(rows.length, count, new Emu(body.x), new Emu(y), new Emu(body.width), new Emu(h)).table;
+                table.first_row = block.c[3][1].length > 0;
+                for (const [r, row] of rows.entries()) {
+                  if (row[1].length !== count) fail(context, "PPTX tables require rectangular unmerged rows");
+                  for (const [c, cell] of row[1].entries()) {
+                    if (cell[2] !== 1 || cell[3] !== 1 || cell[1] !== "AlignDefault") fail(context, "Table spans and explicit alignment are unsupported");
+                    const frame = table.cell(r, c).text_frame;
+                    frame.clear();
+                    for (const [i, block2] of cell[4].entries()) {
+                      if (block2.t !== "Plain" && block2.t !== "Para") fail(context, "Table cells require paragraphs");
+                      writeInline(i ? frame.add_paragraph() : frame.paragraphs[0], block2.c, context);
+                    }
+                  }
+                }
+                y += h + 5e5;
+                break;
+              }
+              default:
+                fail(context, `Unsupported PPTX block: ${block.t}`, "E_UNSUPPORTED_FEATURE");
+            }
+          }
+        };
+        await blocks(item.blocks);
+      }
+      let output = await model.save();
+      for (const edit of bullets) {
+        await context.cooperate();
+        output = (await mutateTextParagraphs(output, {
+          select: { kind: "slide", position: { coordinateSystem: "one-based", value: edit.slide } },
+          shape: edit.shape,
+          paragraph: 0,
+          bullet: edit.bullet,
+          level: edit.level
+        }, ec)).bytes;
+      }
+      for (const [i, item] of content.entries()) if (item.notes.length) {
+        const text = item.notes.map((b) => {
+          if (b.t !== "Para" && b.t !== "Plain") fail(context, "Speaker notes require plain paragraphs");
+          return plainContent(b.c, context);
+        }).join("\n");
+        output = (await mutateNotes(output, "add", { selection: { kind: "slide", position: { coordinateSystem: "one-based", value: i + 1 } }, text }, ec)).bytes;
+      }
+      context.bound("outputBytes", output.byteLength);
+      return { kind: "binary", bytes: output };
+    });
+  }
+};
+var pptxReader = {
+  format: "pptx",
+  async read(input, context) {
+    return guarded(context, async () => {
+      const ec = engineContext(context);
+      const index = await readSelectionIndex(input.bytes, ec);
+      context.bound("pages", index.slides.length);
+      for (const animation of await readAnimations(input.bytes, {}, ec)) if (animation.xml.length) loss(context, `Animations on slide ${animation.slide} cannot be converted`);
+      if ((await readCharts(input.bytes, {}, ec)).length) loss(context, "Charts cannot be converted");
+      const objects = await readObjects(input.bytes, ec);
+      if (objects.objects.length) loss(context, "Embedded objects cannot be converted");
+      const model = await Presentation(input.bytes, ec);
+      const text = await readPresentationText(input.bytes, {}, ec);
+      const formats = await readTextParagraphs(input.bytes, {}, ec);
+      const notes = await readNotes(input.bytes, {}, ec);
+      const pictures = await readImages(input.bytes, { scope: "slides" }, ec);
+      const resources = [];
+      const blocks = [];
+      for (const [i, slide] of [...model.slides].entries()) {
+        await context.cooperate();
+        const visible = [];
+        let activeList;
+        for (const shape of slide.shapes) {
+          if (shape instanceof Picture) {
+            activeList = void 0;
+            const occurrence = pictures.occurrences.find((p) => p.location.owner === slide.part.partname && p.shapeId === String(shape.shape_id));
+            if (!occurrence || occurrence.external || !["image/png", "image/jpeg"].includes(occurrence.contentType ?? "") || Object.values(occurrence.crop).some((v) => v !== 0)) {
+              loss(context, "External, cropped or unsupported pictures cannot be converted");
+              continue;
+            }
+            if (!shape.width || !shape.height) fail(context, "Picture dimensions are unavailable");
+            const id = `pptx-image-${i + 1}-${shape.shape_id}.${shape.image.ext}`;
+            const bytes = shape.image.blob;
+            context.charge("images", 1);
+            context.charge("resourceBytes", bytes.byteLength);
+            resources.push({ id, bytes });
+            visible.push({ t: "Para", c: [{ t: "Image", c: [["", [], [["width", `${shape.width.inches}in`], ["height", `${shape.height.inches}in`]]], [{ t: "Str", c: occurrence.altText ?? shape.name }], [id, occurrence.title ?? ""]] }] });
+            continue;
+          }
+          if (shape instanceof GraphicFrame && shape.has_table) {
+            activeList = void 0;
+            const table = shape.table;
+            const rows = [];
+            for (let r = 0; r < table.rows.length; r++) {
+              const cells = [];
+              for (let c = 0; c < table.columns.length; c++) {
+                const cell = table.cell(r, c);
+                if (cell.is_spanned || cell.span_width !== 1 || cell.span_height !== 1) fail(context, "Merged presentation tables are unsupported");
+                cells.push([attr, "AlignDefault", 1, 1, cell.text.split("\n").map((text2) => ({ t: "Plain", c: [{ t: "Str", c: text2 }] }))]);
+              }
+              rows.push([attr, cells]);
+            }
+            const header = table.first_row ? rows.splice(0, 1) : [];
+            visible.push({ t: "Table", c: [attr, [null, []], [...table.columns].map(() => ["AlignDefault", { t: "ColWidthDefault" }]), [attr, header], [[attr, 0, [], rows]], [attr, []]] });
+            continue;
+          }
+          if (!shape.has_text_frame) {
+            activeList = void 0;
+            loss(context, "Non-text slide content is not yet supported");
+            continue;
+          }
+          const segment = text.segments.find((s) => s.location.owner === slide.part.partname && s.location.objectId === String(shape.shape_id));
+          if (!segment) continue;
+          for (const [p, paragraph] of segment.paragraphs.entries()) {
+            if (!paragraph.text) continue;
+            let runIndex = 0;
+            const inlines = paragraph.inlines.map((inline) => {
+              if (inline.kind === "break") return { t: "LineBreak" };
+              let value = { t: "Str", c: inline.kind === "field" ? inline.cachedText : inline.text };
+              if (inline.kind === "run") {
+                const run = shape.text_frame.paragraphs[p]?.runs[runIndex++];
+                if (run?.font.bold) value = { t: "Strong", c: [value] };
+                if (run?.font.italic) value = { t: "Emph", c: [value] };
+                if (run?.hyperlink.address) value = { t: "Link", c: [attr, [value], [run.hyperlink.address, ""]] };
+              }
+              return value;
+            });
+            const format = formats.find((f) => f.location.owner === segment.location.owner && f.location.objectId === segment.location.objectId && f.paragraph === p)?.formatting;
+            const bullet = format?.bullet;
+            if (shape.name === "Pandoc list continuation" && activeList) {
+              const item = activeList.levels[format?.level ?? 0]?.items.at(-1);
+              if (!item) fail(context, "List continuation without a parent item");
+              item.push({ t: "Para", c: inlines });
+              continue;
+            }
+            if (bullet && bullet.kind !== "none") {
+              if (bullet.kind === "numbered" && bullet.scheme !== "arabicPeriod")
+                loss(context, `Numbering scheme ${bullet.scheme} on slide ${i + 1} cannot be converted without decimal-period projection`);
+              const kind = bullet.kind === "numbered" ? "numbered" : "bullet";
+              const level = format?.level ?? 0;
+              if (!activeList) {
+                if (level !== 0) fail(context, "Nested list without a parent item");
+                activeList = { levels: [] };
+              }
+              if (level > activeList.levels.length) fail(context, "List nesting skips a level");
+              const previous = activeList.levels[level];
+              const restart = bullet.kind === "numbered" && bullet.startAt !== void 0 && previous?.nextNumber !== bullet.startAt;
+              if (!previous || previous.kind !== kind || restart) {
+                const items = [];
+                const root = kind === "bullet" ? { t: "BulletList", c: items } : { t: "OrderedList", c: [[bullet.kind === "numbered" ? bullet.startAt ?? 1 : 1, "Decimal", "Period"], items] };
+                if (level === 0) visible.push(root);
+                else {
+                  const parent = activeList.levels[level - 1].items.at(-1);
+                  if (!parent) fail(context, "Nested list without a parent item");
+                  parent.push(root);
+                }
+                activeList.levels[level] = { kind, items };
+              }
+              activeList.levels.length = level + 1;
+              activeList.levels[level].items.push([{ t: "Plain", c: inlines }]);
+              if (bullet.kind === "numbered") {
+                const state = activeList.levels[level];
+                state.nextNumber = (bullet.startAt ?? state.nextNumber ?? 1) + 1;
+              }
+            } else {
+              activeList = void 0;
+              const title = shape.name === "Pandoc slide title" || shape.is_placeholder && [1, 3].includes(shape.placeholder_format.type);
+              visible.push(title ? { t: "Header", c: [1, attr, inlines] } : { t: "Para", c: inlines });
+            }
+          }
+        }
+        const note = notes.find((n) => n.slide === i + 1);
+        if (note?.text !== null && note?.text !== void 0) visible.push({ t: "Div", c: [["", ["notes"], []], note.text.split("\n").map((text2) => ({ t: "Para", c: [{ t: "Str", c: text2 }] }))] });
+        blocks.push({ t: "Div", c: [[`slide-${i + 1}`, ["slide"], [["data-pptx-order", "structural"]]], visible] });
+      }
+      return { blocks, metadata: {}, resources };
+    });
+  }
+};
+export {
+  pptxReader,
+  pptxWriter
+};
+/*!
+MIT License
+
+Copyright © 2017-2019 Benoit Giannangeli
+Copyright © 2017-2025 Daurnimator
+Copyright © 1994–2017 Lua.org, PUC-Rio.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+/*!
+Copyright (c) 2007-present, Alexandru Mărășteanu <hello@alexei.ro>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of this software nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+/*!
+	Copyright (c) 2009-2019 Frank Bennett
+
+	This program is free software: you can redistribute it and/or
+	modify it under EITHER
+
+      * the terms of the Common Public Attribution License (CPAL) as
+	    published by the Open Source Initiative, either version 1 of
+	    the CPAL, or (at your option) any later version; OR
+
+      * the terms of the GNU Affero General Public License (AGPL)
+        as published by the Free Software Foundation, either version
+        3 of the AGPL, or (at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Affero General Public License for more details.
+
+	You should have received copies of the Common Public Attribution
+    License and of the GNU Affero General Public License along with
+    this program.  If not, see <https://opensource.org/licenses/> or
+    <http://www.gnu.org/licenses/> respectively.
+
+*/

package/dist/safe-bash/command-chunks/python-worker-source-TYOFJMCW.js

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: package/dist/safe-bash/command-chunks/python-worker-source-TYOFJMCW.js
+size: 33621051 bytes
+sha256: ec9a12977986b8e6f97ec46c9d7dc684df5ca946b0dffd513534c302ddefc25c