@bendyline/squisq-formats 1.3.1 → 1.4.0

package/dist/pptx/index.d.ts

@@ -75,6 +75,23 @@ declare function markdownDocToPptx(doc: MarkdownDocument, options?: PptxExportOp
  */
 declare function docToPptx(doc: Doc, options?: PptxExportOptions): Promise<ArrayBuffer>;
 
+/**
+ * PPTX import — PresentationML (.pptx) → MarkdownDocument.
+ *
+ * Reuses the shared ooxml/ reader. Reads slide order from
+ * `ppt/presentation.xml` (`<p:sldIdLst>`), resolves each slide part via
+ * relationships, and converts each slide to: an H2 of the title placeholder
+ * (or "Slide N"), the remaining text as a bullet list, and any slide tables
+ * (`<a:tbl>`) as markdown tables. Text lives in the DrawingML namespace
+ * (`a:p` / `a:r` / `a:t`) inside PresentationML shapes (`p:sp`).
+ */
+
+interface PptxImportOptions {
+    /** Whether to extract embedded images as data URIs (not yet used). */
+    extractImages?: boolean;
+}
+declare function pptxToMarkdownDoc(data: ArrayBuffer | Blob, _options?: PptxImportOptions): Promise<MarkdownDocument>;
+
 /**
  * @bendyline/squisq-formats PPTX Module
  *
@@ -84,7 +101,7 @@ declare function docToPptx(doc: Doc, options?: PptxExportOptions): Promise<Array
  * Slide segmentation: each H1/H2 heading starts a new slide by default.
  * Inline formatting (bold, italic, code, links) is preserved as DrawingML runs.
  *
- * Import is not yet implemented.
+ * Includes both export and import paths.
  *
  * @example
  * ```ts
@@ -93,23 +110,8 @@ declare function docToPptx(doc: Doc, options?: PptxExportOptions): Promise<Array
  */
 
 /**
- * Options for PPTX import (placeholder).
- */
-interface PptxImportOptions {
-    /** Whether to extract embedded images as data URIs */
-    extractImages?: boolean;
-}
-/**
- * Convert a .pptx file to a MarkdownDocument.
- *
- * @throws Error — PPTX import is not yet implemented
- */
-declare function pptxToMarkdownDoc(_data: ArrayBuffer | Blob, _options?: PptxImportOptions): Promise<MarkdownDocument>;
-/**
- * Convert a .pptx file to a squisq Doc.
- *
- * @throws Error — PPTX import is not yet implemented
+ * Convert a .pptx file to a squisq Doc (via the markdown model).
  */
-declare function pptxToDoc(_data: ArrayBuffer | Blob, _options?: PptxImportOptions): Promise<Doc>;
+declare function pptxToDoc(data: ArrayBuffer | Blob, options?: PptxImportOptions): Promise<Doc>;
 
 export { type PptxExportOptions, type PptxImportOptions, docToPptx, markdownDocToPptx, pptxToDoc, pptxToMarkdownDoc };

package/dist/pptx/index.js

@@ -3,9 +3,13 @@ import {
   markdownDocToPptx,
   pptxToDoc,
   pptxToMarkdownDoc
-} from "../chunk-VN2KEOYB.js";
-import "../chunk-7DEUGIOO.js";
+} from "../chunk-I2GFTEOV.js";
+import "../chunk-6M7Z25LA.js";
+import "../chunk-PN52A5AA.js";
+import "../chunk-QSE7EWE7.js";
 import "../chunk-U4MRIFKL.js";
+import "../chunk-FMOIGA5T.js";
+import "../chunk-A3FHLTY5.js";
 export {
   docToPptx,
   markdownDocToPptx,

package/dist/xlsx/index.d.ts

@@ -1,6 +1,22 @@
 import { MarkdownDocument } from '@bendyline/squisq/markdown';
 import { Doc } from '@bendyline/squisq/schemas';
 
+/**
+ * XLSX import — SpreadsheetML (.xlsx) → MarkdownDocument.
+ *
+ * Reuses the shared ooxml/ reader (zip + DOMParser). Reads the workbook's
+ * sheet list, resolves each sheet part via relationships, pulls shared strings,
+ * and turns each worksheet's cell grid into a markdown table (first row treated
+ * as the header). By default every sheet is imported, each preceded by an H1 of
+ * the sheet name; pass `options.sheet` (index or name) to import just one.
+ */
+
+interface XlsxImportOptions {
+    /** Which sheet to import (0-based index or sheet name). Default: all sheets. */
+    sheet?: number | string;
+}
+declare function xlsxToMarkdownDoc(data: ArrayBuffer | Blob, options?: XlsxImportOptions): Promise<MarkdownDocument>;
+
 /**
  * @bendyline/squisq-formats XLSX Module (Stub)
  *
@@ -23,36 +39,21 @@ interface XlsxExportOptions {
     /** Workbook author */
     author?: string;
 }
-/**
- * Options for XLSX import (placeholder).
- */
-interface XlsxImportOptions {
-    /** Which sheet to import (0-based index or name). Default: 0 */
-    sheet?: number | string;
-}
 /**
  * Convert a MarkdownDocument to a .xlsx Blob.
  *
- * @throws Error — XLSX support is not yet implemented
+ * @throws Error — XLSX export is not yet implemented
  */
 declare function markdownDocToXlsx(_doc: MarkdownDocument, _options?: XlsxExportOptions): Promise<Blob>;
 /**
  * Convert a squisq Doc to a .xlsx Blob.
  *
- * @throws Error — XLSX support is not yet implemented
+ * @throws Error — XLSX export is not yet implemented
  */
 declare function docToXlsx(_doc: Doc, _options?: XlsxExportOptions): Promise<Blob>;
 /**
- * Convert a .xlsx file to a MarkdownDocument.
- *
- * @throws Error — XLSX support is not yet implemented
- */
-declare function xlsxToMarkdownDoc(_data: ArrayBuffer | Blob, _options?: XlsxImportOptions): Promise<MarkdownDocument>;
-/**
- * Convert a .xlsx file to a squisq Doc.
- *
- * @throws Error — XLSX support is not yet implemented
+ * Convert a .xlsx file to a squisq Doc (via the markdown table model).
  */
-declare function xlsxToDoc(_data: ArrayBuffer | Blob, _options?: XlsxImportOptions): Promise<Doc>;
+declare function xlsxToDoc(data: ArrayBuffer | Blob, options?: XlsxImportOptions): Promise<Doc>;
 
 export { type XlsxExportOptions, type XlsxImportOptions, docToXlsx, markdownDocToXlsx, xlsxToDoc, xlsxToMarkdownDoc };

package/dist/xlsx/index.js

@@ -3,7 +3,8 @@ import {
   markdownDocToXlsx,
   xlsxToDoc,
   xlsxToMarkdownDoc
-} from "../chunk-67KIJHV2.js";
+} from "../chunk-L53YIGYS.js";
+import "../chunk-FMOIGA5T.js";
 export {
   docToXlsx,
   markdownDocToXlsx,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/squisq-formats",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Document format converters — DOCX, PDF, OOXML import/export",
   "license": "MIT",
   "author": "Bendyline",
@@ -52,6 +52,11 @@
       "import": "./dist/xlsx/index.js",
       "default": "./dist/xlsx/index.js"
     },
+    "./csv": {
+      "types": "./dist/csv/index.d.ts",
+      "import": "./dist/csv/index.js",
+      "default": "./dist/csv/index.js"
+    },
     "./ooxml": {
       "types": "./dist/ooxml/index.d.ts",
       "import": "./dist/ooxml/index.js",
@@ -84,7 +89,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@bendyline/squisq": "1.4.1",
+    "@bendyline/squisq": "1.5.0",
     "jszip": "3.10.1",
     "pdf-lib": "1.17.1",
     "pdfjs-dist": "4.10.38"

package/src/__tests__/csvImport.test.ts

@@ -0,0 +1,51 @@
+/**
+ * Tests for CSV import/export: csvToMarkdownDoc, markdownDocToCsv, parseCsv.
+ */
+
+import { describe, expect, it } from 'vitest';
+import type { MarkdownTable, MarkdownText } from '@bendyline/squisq/markdown';
+import { csvToMarkdownDoc, markdownDocToCsv, parseCsv } from '../csv/index';
+
+function cellValue(table: MarkdownTable, row: number, col: number): string {
+  const cell = table.children[row]?.children[col];
+  const first = cell?.children[0] as MarkdownText | undefined;
+  return first?.value ?? '';
+}
+
+describe('parseCsv', () => {
+  it('parses quoted fields, escaped quotes, and embedded delimiters', () => {
+    const rows = parseCsv('a,b,c\n"x,y","he said ""hi""",z\n');
+    expect(rows).toEqual([
+      ['a', 'b', 'c'],
+      ['x,y', 'he said "hi"', 'z'],
+    ]);
+  });
+
+  it('handles CRLF line endings', () => {
+    expect(parseCsv('a,b\r\n1,2\r\n')).toEqual([
+      ['a', 'b'],
+      ['1', '2'],
+    ]);
+  });
+});
+
+describe('csvToMarkdownDoc', () => {
+  it('builds a table with a header row by default', async () => {
+    const doc = await csvToMarkdownDoc('Name,Age\nAlice,30\n"Bob, Jr.",40\n');
+    expect(doc.type).toBe('document');
+    const table = doc.children[0] as MarkdownTable;
+    expect(table.type).toBe('table');
+    expect(table.children).toHaveLength(3);
+    expect(table.children[0]!.children[0]!.isHeader).toBe(true);
+    expect(cellValue(table, 0, 0)).toBe('Name');
+    expect(cellValue(table, 0, 1)).toBe('Age');
+    expect(cellValue(table, 2, 0)).toBe('Bob, Jr.');
+    expect(cellValue(table, 2, 1)).toBe('40');
+  });
+
+  it('round-trips through markdownDocToCsv', async () => {
+    const csv = 'Name,Age\r\nAlice,30\r\n"Bob, Jr.",40';
+    const doc = await csvToMarkdownDoc(csv);
+    expect(markdownDocToCsv(doc)).toBe(csv);
+  });
+});

package/src/__tests__/exportThemeReconciliation.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Export theme reconciliation.
+ *
+ * Every export format must honor the theme the document selects in its
+ * frontmatter (`squisq-theme`) — including an inline custom theme stored in
+ * `squisq-custom-themes` — without an explicit `themeId` option. This guards
+ * the fix that made PDF/EPUB read the frontmatter theme like PPTX/DOCX/HTML,
+ * and that custom themes resolve doc-scoped in exports (no global register).
+ */
+
+import { describe, it, expect } from 'vitest';
+import JSZip from 'jszip';
+import { compileTheme } from '@bendyline/squisq/schemas';
+import { writeCustomThemesToFrontmatter } from '@bendyline/squisq/doc';
+import { parseMarkdown } from '@bendyline/squisq/markdown';
+import { markdownDocToPptx } from '../pptx/export';
+import { markdownDocToDocx } from '../docx/export';
+import { markdownDocToPdf } from '../pdf/export';
+import { markdownDocToEpub } from '../epub/export';
+import { markdownDocToPlainHtml } from '../html/plainHtml';
+
+const brand = compileTheme({
+  id: 'custom-brand',
+  name: 'Brand',
+  seedColors: { primary: '#ff0088', background: '#123456', text: '#abcdef' },
+});
+
+const withTheme = parseMarkdown(`---
+title: Audit
+squisq-theme: custom-brand
+squisq-custom-themes: ${writeCustomThemesToFrontmatter([brand])}
+---
+
+# Heading One
+
+Body with a [link](https://example.com).
+`);
+
+const noTheme = parseMarkdown('# Heading One\n\nBody.\n');
+
+/** Concatenate the text of every XML/CSS/HTML entry in a ZIP export. */
+async function zipText(buf: ArrayBuffer): Promise<string> {
+  const zip = await JSZip.loadAsync(buf);
+  let text = '';
+  for (const name of Object.keys(zip.files)) {
+    if (/\.(xml|css|html|xhtml|rels)$/i.test(name)) {
+      text += await zip.files[name].async('string');
+    }
+  }
+  return text.toLowerCase();
+}
+
+describe('export theme reconciliation (frontmatter-only custom theme)', () => {
+  it('HTML applies the frontmatter custom theme colors', () => {
+    const html = markdownDocToPlainHtml(withTheme, {}).toLowerCase();
+    expect(html).toContain('123456'); // background
+    expect(html).toContain('abcdef'); // text
+  });
+
+  it('PPTX applies the frontmatter custom theme colors', async () => {
+    const text = await zipText(await markdownDocToPptx(withTheme, {}));
+    expect(text).toContain('123456');
+  });
+
+  it('DOCX applies the frontmatter custom theme colors', async () => {
+    const text = await zipText(await markdownDocToDocx(withTheme, {}));
+    expect(text).toContain('123456');
+  });
+
+  it('EPUB applies the frontmatter custom theme colors (frontmatter fallback)', async () => {
+    const text = await zipText(await markdownDocToEpub(withTheme, {}));
+    expect(text).toContain('123456');
+  });
+
+  it('PDF themes from frontmatter — themed output differs from un-themed', async () => {
+    const themed = new Uint8Array(await markdownDocToPdf(withTheme, {}));
+    const plain = new Uint8Array(await markdownDocToPdf(noTheme, {}));
+    const differs = themed.length !== plain.length || !themed.every((b, i) => b === plain[i]);
+    expect(differs).toBe(true);
+  });
+
+  it('an explicit themeId option still overrides the frontmatter theme', async () => {
+    const bare = await zipText(await markdownDocToPptx(withTheme, { themeId: 'standard' }));
+    // The custom background must NOT appear when the caller forces 'standard'.
+    expect(bare).not.toContain('123456');
+  });
+});

package/src/__tests__/htmlImport.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import { htmlToMarkdown, htmlToMarkdownDocSync } from '../html/import.js';
+
+describe('htmlToMarkdown', () => {
+  it('converts headings and paragraphs', () => {
+    const md = htmlToMarkdown('<h1>Title</h1><p>Hello <strong>world</strong>.</p>');
+    expect(md).toContain('# Title');
+    expect(md).toContain('Hello **world**.');
+  });
+
+  it('converts links and inline code', () => {
+    const md = htmlToMarkdown(
+      '<p>See <a href="https://x.test">site</a> and <code>npm i</code></p>',
+    );
+    expect(md).toContain('[site](https://x.test)');
+    expect(md).toContain('`npm i`');
+  });
+
+  it('converts unordered and ordered lists', () => {
+    const md = htmlToMarkdown('<ul><li>a</li><li>b</li></ul><ol><li>one</li><li>two</li></ol>');
+    expect(md).toMatch(/[-*]\s+a/);
+    expect(md).toMatch(/[-*]\s+b/);
+    expect(md).toMatch(/1\.\s+one/);
+  });
+
+  it('converts blockquotes and tables', () => {
+    const md = htmlToMarkdown(
+      '<blockquote><p>quoted</p></blockquote>' +
+        '<table><thead><tr><th>H</th></tr></thead><tbody><tr><td>cell</td></tr></tbody></table>',
+    );
+    expect(md).toContain('> quoted');
+    expect(md).toContain('cell');
+  });
+
+  it('drops scripts and styles (sanitized by default)', () => {
+    const md = htmlToMarkdown('<p>safe</p><script>alert(1)</script><style>.x{color:red}</style>');
+    expect(md).toContain('safe');
+    expect(md).not.toContain('alert(1)');
+    expect(md).not.toContain('color:red');
+  });
+
+  it('strips javascript: links via sanitizer', () => {
+    const md = htmlToMarkdown('<a href="javascript:alert(1)">click</a>');
+    expect(md).not.toContain('javascript:alert(1)');
+  });
+
+  it('builds a document node tree', () => {
+    const doc = htmlToMarkdownDocSync('<h2>Hi</h2>');
+    expect(doc.type).toBe('document');
+    expect(doc.children[0]?.type).toBe('heading');
+  });
+
+  it('handles unwrapped div/span containers', () => {
+    const md = htmlToMarkdown('<div><span>plain </span><em>text</em></div>');
+    expect(md).toContain('plain *text*');
+  });
+});

package/src/__tests__/plainHtml.test.ts

@@ -43,6 +43,12 @@ describe('markdownDocToPlainHtml', () => {
     );
   });
 
+  it('renders unsafe markdown links as inert text by default', () => {
+    const html = render('[x](javascript:alert(1))');
+    expect(html).toContain('<p>x</p>');
+    expect(html).not.toContain('javascript:');
+  });
+
   it('renders ordered and unordered lists', () => {
     const html = render('- one\n- two\n\n1. first\n2. second');
     expect(html).toContain('<ul>');
@@ -112,6 +118,31 @@ describe('markdownDocToPlainHtml', () => {
     expect(html).not.toContain('src="resized.png"');
   });
 
+  it('sanitizes raw HTML by default', () => {
+    const html = render(
+      '<div><img src="x.jpg" onerror="alert(1)"><script>alert(1)</script><span onclick="alert(1)">ok</span></div>',
+    );
+    expect(html).toContain('<img src="x.jpg" />');
+    expect(html).toContain('<span>ok</span>');
+    expect(html).not.toContain('<script>');
+    expect(html).not.toContain('onerror');
+    expect(html).not.toContain('onclick');
+    expect(html).not.toContain('javascript:');
+  });
+
+  it('strips raw HTML when requested', () => {
+    const html = render('<div><span>hidden</span></div>', { htmlPolicy: 'strip' });
+    expect(html).not.toContain('<span>hidden</span>');
+    expect(html).not.toContain('hidden');
+  });
+
+  it('preserves raw HTML only with the trusted opt-in', () => {
+    const html = render('<div><span onclick="alert(1)">ok</span></div>', {
+      htmlPolicy: 'trusted',
+    });
+    expect(html).toContain('<div><span onclick="alert(1)">ok</span></div>');
+  });
+
   it('escapes quotes in href and src attributes', () => {
     const html = render('![a](a"b.jpg)\n\n[c](d"e)');
     expect(html).toContain('&quot;');

package/src/__tests__/pptxExport.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest';
+import type { MarkdownBlockNode, MarkdownDocument } from '@bendyline/squisq/markdown';
+import type { Transition } from '@bendyline/squisq/schemas';
+import { TRANSITION_TYPES } from '@bendyline/squisq/schemas';
+import { markdownDocToPptx } from '../pptx/export';
+import { openPackage, getPartXml } from '../ooxml/reader';
+import { NS_PML, NS_PML_2010 } from '../ooxml/namespaces';
+
+function docWithSecondSlideTransition(transition: Transition): MarkdownDocument {
+  return {
+    type: 'document',
+    children: [
+      {
+        type: 'heading',
+        depth: 2,
+        children: [{ type: 'text', value: 'One' }],
+      },
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: 'Intro' }],
+      },
+      {
+        type: 'heading',
+        depth: 2,
+        children: [{ type: 'text', value: 'Two' }],
+        attributes: {
+          params: {
+            transition: transition.type,
+            ...(transition.duration !== undefined
+              ? { transitionDuration: String(transition.duration) }
+              : {}),
+            ...(transition.direction ? { transitionDirection: transition.direction } : {}),
+          },
+          blockMeta: { transition },
+        },
+      },
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: 'Body' }],
+      },
+    ],
+  };
+}
+
+function docWithAllTransitions(): MarkdownDocument {
+  const children: MarkdownBlockNode[] = [
+    {
+      type: 'heading',
+      depth: 2,
+      children: [{ type: 'text', value: 'Transition Gallery' }],
+    },
+    {
+      type: 'paragraph',
+      children: [{ type: 'text', value: 'Intro slide before transition checks.' }],
+    },
+  ];
+
+  for (const type of TRANSITION_TYPES) {
+    const transition: Transition = { type, duration: 0.8 };
+    children.push(
+      {
+        type: 'heading',
+        depth: 2,
+        children: [{ type: 'text', value: type }],
+        attributes: {
+          params: { transition: type, transitionDuration: '0.8' },
+          blockMeta: { transition },
+        },
+      },
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: `Transition token: ${type}` }],
+      },
+    );
+  }
+
+  return { type: 'document', children };
+}
+
+describe('markdownDocToPptx transitions', () => {
+  it('writes valid transition XML for every shared transition token', async () => {
+    const pkg = await openPackage(await markdownDocToPptx(docWithAllTransitions()));
+
+    for (let i = 0; i < TRANSITION_TYPES.length; i++) {
+      const type = TRANSITION_TYPES[i];
+      const slide = await getPartXml(pkg, `ppt/slides/slide${i + 2}.xml`);
+      expect(slide, type).not.toBeNull();
+
+      const transitions = slide!.getElementsByTagNameNS(NS_PML, 'transition');
+      if (type === 'cut') {
+        expect(transitions, type).toHaveLength(0);
+        continue;
+      }
+
+      expect(transitions, type).toHaveLength(1);
+      expect(transitions[0].getAttribute('spd'), type).toBe('med');
+
+      const childElements = Array.from(transitions[0].childNodes).filter(
+        (node): node is Element => node.nodeType === 1,
+      );
+      expect(childElements, type).toHaveLength(1);
+      expect([NS_PML, NS_PML_2010], type).toContain(childElements[0].namespaceURI);
+
+      if (childElements[0].namespaceURI === NS_PML_2010) {
+        expect(slide!.documentElement.getAttribute('mc:Ignorable'), type).toContain('p14');
+      }
+    }
+  });
+
+  it('writes standard PresentationML transition XML', async () => {
+    const md = docWithSecondSlideTransition({
+      type: 'checkerboard',
+      duration: 1.3,
+      direction: 'vertical',
+    });
+
+    const pkg = await openPackage(await markdownDocToPptx(md));
+    const slide = await getPartXml(pkg, 'ppt/slides/slide2.xml');
+    const transition = slide!.getElementsByTagNameNS(NS_PML, 'transition')[0];
+    const checker = transition.getElementsByTagNameNS(NS_PML, 'checker')[0];
+
+    expect(transition.getAttribute('spd')).toBe('slow');
+    expect(checker.getAttribute('dir')).toBe('vert');
+  });
+
+  it('writes PowerPoint 2010 transition XML when needed', async () => {
+    const md = docWithSecondSlideTransition({ type: 'flash', duration: 0.4 });
+
+    const pkg = await openPackage(await markdownDocToPptx(md));
+    const slide = await getPartXml(pkg, 'ppt/slides/slide2.xml');
+    const transition = slide!.getElementsByTagNameNS(NS_PML, 'transition')[0];
+    const flash = transition.getElementsByTagNameNS(NS_PML_2010, 'flash')[0];
+
+    expect(transition.getAttribute('spd')).toBe('fast');
+    expect(flash).toBeDefined();
+    expect(slide!.documentElement.getAttribute('mc:Ignorable')).toBe('p14');
+  });
+});

package/src/__tests__/pptxImport.test.ts

@@ -0,0 +1,70 @@
+/**
+ * Tests for PPTX import: pptxToMarkdownDoc. Builds a minimal .pptx fixture with
+ * the shared OOXML writer, then imports it.
+ */
+
+import { describe, expect, it } from 'vitest';
+import type {
+  MarkdownHeading,
+  MarkdownList,
+  MarkdownParagraph,
+  MarkdownText,
+} from '@bendyline/squisq/markdown';
+import { NS_DRAWINGML, NS_PML, NS_R, REL_OFFICE_DOCUMENT, REL_SLIDE } from '../ooxml/namespaces';
+import { createPackage } from '../ooxml/writer';
+import { xmlDeclaration } from '../ooxml/xmlUtils';
+import { pptxToMarkdownDoc } from '../pptx/import';
+
+async function buildTestPptx(): Promise<ArrayBuffer> {
+  const pkg = createPackage();
+
+  pkg.addPart(
+    'ppt/presentation.xml',
+    `${xmlDeclaration()}<p:presentation xmlns:p="${NS_PML}" xmlns:r="${NS_R}">` +
+      `<p:sldIdLst><p:sldId id="256" r:id="rId1"/></p:sldIdLst></p:presentation>`,
+    'application/xml',
+  );
+  pkg.addPart(
+    'ppt/slides/slide1.xml',
+    `${xmlDeclaration()}<p:sld xmlns:p="${NS_PML}" xmlns:a="${NS_DRAWINGML}"><p:cSld><p:spTree>` +
+      `<p:sp><p:nvSpPr><p:nvPr><p:ph type="title"/></p:nvPr></p:nvSpPr>` +
+      `<p:txBody><a:p><a:r><a:t>My Title</a:t></a:r></a:p></p:txBody></p:sp>` +
+      `<p:sp><p:txBody>` +
+      `<a:p><a:r><a:t>First bullet</a:t></a:r></a:p>` +
+      `<a:p><a:r><a:t>Second bullet</a:t></a:r></a:p>` +
+      `</p:txBody></p:sp>` +
+      `</p:spTree></p:cSld></p:sld>`,
+    'application/xml',
+  );
+
+  pkg.addRelationship('', {
+    id: 'rId1',
+    type: REL_OFFICE_DOCUMENT,
+    target: 'ppt/presentation.xml',
+  });
+  pkg.addRelationship('ppt/presentation.xml', {
+    id: 'rId1',
+    type: REL_SLIDE,
+    target: 'slides/slide1.xml',
+  });
+
+  return pkg.toArrayBuffer();
+}
+
+describe('pptxToMarkdownDoc', () => {
+  it('imports a slide as a heading + bullet list', async () => {
+    const doc = await pptxToMarkdownDoc(await buildTestPptx());
+    expect(doc.type).toBe('document');
+
+    const heading = doc.children[0] as MarkdownHeading;
+    expect(heading.type).toBe('heading');
+    expect(heading.depth).toBe(2);
+    expect((heading.children[0] as MarkdownText).value).toBe('My Title');
+
+    const list = doc.children[1] as MarkdownList;
+    expect(list.type).toBe('list');
+    expect(list.children).toHaveLength(2);
+    const firstItemPara = list.children[0]!.children[0] as MarkdownParagraph;
+    expect((firstItemPara.children[0] as MarkdownText).value).toBe('First bullet');
+  });
+});