@astryxdesign/core 0.7.5 → 0.7.6-canary.0135af4

package/src/Markdown/blockNesting.test.tsx

@@ -1,124 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {render} from '@testing-library/react';
-import {Markdown} from './Markdown';
-import {parseMarkdownAst} from './parser';
-
-type Json = {type: string; value?: string; children?: Json[]};
-
-/** A list nested `levels` deep by indentation, one item per level. */
-const indentedList = (levels: number): string =>
-  Array.from({length: levels}, (_, level) => `${'  '.repeat(level)}- a`).join(
-    '\n',
-  );
-
-/** A list nested `levels` deep on one line: each item opens the next list. */
-const nestedList = (levels: number, marker = '- '): string =>
-  `${marker.repeat(levels)}a`;
-
-/** A blockquote nested `levels` deep. */
-const nestedQuote = (levels: number): string => `${'> '.repeat(levels)}a`;
-
-/** Lists and blockquotes alternating `levels` deep, on one line. */
-const mixed = (levels: number): string =>
-  `${Array.from({length: levels}, (_, level) => (level % 2 === 0 ? '> ' : '- ')).join('')}a`;
-
-/** The deepest run of lists and blockquotes, iteratively. */
-function blockDepth(nodes: ReadonlyArray<Json>): number {
-  let deepest = 0;
-  const stack: {node: Json; depth: number}[] = nodes.map(node => ({
-    node,
-    depth: 0,
-  }));
-  while (stack.length > 0) {
-    const {node, depth} = stack.pop() as {node: Json; depth: number};
-    const next =
-      node.type === 'list' || node.type === 'blockquote' ? depth + 1 : depth;
-    deepest = Math.max(deepest, next);
-    for (const child of node.children ?? []) {
-      stack.push({node: child, depth: next});
-    }
-  }
-  return deepest;
-}
-
-/**
- * The least CPU time of five runs of `run`, in milliseconds. CPU time, not
- * elapsed time: on a loaded test machine, other work stretches elapsed time
- * but not the time this parse spends computing.
- */
-function leastCpuTime(run: () => void): number {
-  run();
-  let least = Number.POSITIVE_INFINITY;
-  for (let round = 0; round < 5; round++) {
-    const started = process.cpuUsage();
-    run();
-    const used = process.cpuUsage(started);
-    least = Math.min(least, (used.user + used.system) / 1000);
-  }
-  return least;
-}
-
-describe('lists and blockquotes nest at most 100 deep', () => {
-  it('nests a list at most 100 deep, and reads deeper items as text', () => {
-    const at = (levels: number) =>
-      blockDepth(parseMarkdownAst(indentedList(levels)).children as never);
-    expect(at(50)).toBe(50);
-    expect(at(100)).toBe(100);
-    expect(at(101)).toBe(100);
-    expect(at(150)).toBe(100);
-  });
-
-  it.each([
-    ['a list 2,000 deep', nestedList(2_000)],
-    ['a list 10,000 deep', nestedList(10_000)],
-    ['an ordered list 10,000 deep', nestedList(10_000, '1. ')],
-    ['a list 500 deep by indentation', indentedList(500)],
-    ['a blockquote 2,000 deep', nestedQuote(2_000)],
-    ['a blockquote 10,000 deep', nestedQuote(10_000)],
-    ['lists and blockquotes 10,000 deep', mixed(10_000)],
-  ])('parses %s without throwing, within a time budget', (_, markdown) => {
-    expect(() => parseMarkdownAst(markdown)).not.toThrow();
-    const depth = blockDepth(parseMarkdownAst(markdown).children as never);
-    expect(depth).toBeGreaterThan(50);
-    expect(depth).toBeLessThanOrEqual(100);
-    // The budget leaves room for a loaded test machine.
-    expect(leastCpuTime(() => parseMarkdownAst(markdown))).toBeLessThan(5000);
-  });
-
-  it.each([
-    ['a list', nestedList(10_000)],
-    ['a blockquote', nestedQuote(10_000)],
-    ['lists and blockquotes', mixed(10_000)],
-  ])(
-    'renders %s nested past the cap without exhausting the stack',
-    (_, markdown) => {
-      const {container} = render(<Markdown>{markdown}</Markdown>);
-      expect(container.textContent).toContain('a');
-    },
-  );
-});
-
-describe('lazy continuation lines in deeply nested input', () => {
-  it.each([
-    ['blockquotes', `${'> '.repeat(20_000)}a\nlazy`],
-    ['lists', `${'- '.repeat(20_000)}a\nlazy`],
-    [
-      'lists and blockquotes',
-      `${Array.from({length: 20_000}, (_, level) => (level % 2 === 0 ? '> ' : '- ')).join('')}a\nlazy`,
-    ],
-    ['blockquotes, with two lazy lines', `${'> '.repeat(20_000)}a\nlazy\nmore`],
-  ])('parse %s 20,000 deep (40 KB) within 100 ms', (_, markdown) => {
-    expect(leastCpuTime(() => parseMarkdownAst(markdown))).toBeLessThan(100);
-  });
-
-  it('still continue the innermost paragraph', () => {
-    const [quote] = parseMarkdownAst('> > a\nlazy').children as never as Json[];
-    expect(quote.type).toBe('blockquote');
-    const [inner] = quote.children ?? [];
-    expect(inner.type).toBe('blockquote');
-    expect(inner.children?.[0]?.type).toBe('paragraph');
-    expect(JSON.stringify(inner.children)).toContain('lazy');
-  });
-});

package/src/Markdown/blockquoteMarkers.test.tsx

@@ -1,69 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {
-  createIncrementalState,
-  parseMarkdown,
-  parseMarkdownAst,
-  parseMarkdownIncremental,
-} from './parser';
-
-type Json = {type: string; value?: string; children?: Json[]};
-
-/** The document's blocks as compact markup. */
-function blocks(markdown: string): string {
-  const show = (node: Json): string =>
-    node.type === 'text'
-      ? JSON.stringify(node.value)
-      : node.children == null
-        ? node.type
-        : `${node.type}[${node.children.map(show).join(', ')}]`;
-  return (parseMarkdownAst(markdown).children as unknown as Json[])
-    .map(show)
-    .join(' | ');
-}
-
-describe('a block quote marker is up to three spaces, then `>` (CommonMark 0.31 §5.1)', () => {
-  it.each([
-    ['text right after the marker', '>a', 'blockquote[paragraph["a"]]'],
-    ['a tab after the marker', '>\ta', 'blockquote[paragraph["a"]]'],
-    ['three spaces of indentation', '   > a', 'blockquote[paragraph["a"]]'],
-    [
-      'markers without spaces, nested',
-      '>> a',
-      'blockquote[blockquote[paragraph["a"]]]',
-    ],
-    [
-      'three markers, nested three deep',
-      '>>> a',
-      'blockquote[blockquote[blockquote[paragraph["a"]]]]',
-    ],
-    [
-      'consecutive lines without spaces',
-      '>a\n>b',
-      'blockquote[paragraph["a\\nb"]]',
-    ],
-    [
-      'a quote interrupting a paragraph',
-      'text\n>quote',
-      'paragraph["text"] | blockquote[paragraph["quote"]]',
-    ],
-    ['the usual form, unchanged', '> a', 'blockquote[paragraph["a"]]'],
-  ])('reads %s', (_, markdown, expected) => {
-    expect(blocks(markdown)).toBe(expected);
-  });
-
-  it('reads four spaces of indentation as no marker', () => {
-    expect(blocks('    > a')).toBe('paragraph["    > a"]');
-  });
-
-  it('streams quotes without spaces to the full parse at every character', () => {
-    const markdown = '>a\n>b\n\n>> c\n\ntext\n   > d';
-    const state = createIncrementalState();
-    let streamed = parseMarkdownIncremental('', state);
-    for (let end = 1; end <= markdown.length; end++) {
-      streamed = parseMarkdownIncremental(markdown.slice(0, end), state);
-    }
-    expect(streamed).toEqual(parseMarkdown(markdown));
-  });
-});

package/src/Markdown/characterReferences.test.ts

@@ -1,47 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {decodeMarkdownCharacterReferences} from './characterReferences';
-import {parseInline} from './parser';
-
-/** Character reference cases every surface decodes the same way (spec:AST-061 DEC-5). */
-const CHARACTER_REFERENCE_CASES: ReadonlyArray<readonly [string, string]> = [
-  ['&copy;', '©'],
-  ['&#169;', '©'],
-  ['&#xA9;', '©'],
-  ['&#XA9;', '©'],
-  ['&amp;copy;', '&copy;'],
-  ['Fish &amp; chips', 'Fish & chips'],
-  ['&NotEqualTilde;', '\u2242\u0338'],
-  ['&unknown;', '&unknown;'],
-  ['&copy', '&copy'],
-  ['& copy;', '& copy;'],
-  ['&#0;', '\uFFFD'],
-  ['&#xD800;', '\uFFFD'],
-  ['&#x110000;', '\uFFFD'],
-  ['&#12345678;', '&#12345678;'],
-  ['a&nbsp;b', 'a\u00A0b'],
-  ['no references', 'no references'],
-];
-
-describe('decodeMarkdownCharacterReferences (spec:AST-061 DEC-5)', () => {
-  it('decodes valid references and leaves everything else as written', () => {
-    for (const [source, decoded] of CHARACTER_REFERENCE_CASES) {
-      expect(decodeMarkdownCharacterReferences(source), source).toBe(decoded);
-    }
-  });
-
-  it('decodes exactly as Markdown renders text', () => {
-    for (const [source] of CHARACTER_REFERENCE_CASES) {
-      const rendered = parseInline(source)
-        .map(node => ('content' in node ? node.content : ''))
-        .join('');
-      expect(decodeMarkdownCharacterReferences(source), source).toBe(rendered);
-    }
-  });
-
-  it('returns the same string when there is nothing to decode', () => {
-    const text = 'plain & simple';
-    expect(decodeMarkdownCharacterReferences(text)).toBe(text);
-  });
-});

package/src/Markdown/codeSpans.test.tsx

@@ -1,65 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {parseInlineAst, parseMarkdownAst} from './parser';
-
-type Json = {type: string; value?: string; children?: Json[]};
-
-/** Each inline node as `code(…)` or its text, in order. */
-function spans(markdown: string): string[] {
-  const out: string[] = [];
-  const visit = (node: Json) => {
-    if (node.type === 'inlineCode') {
-      out.push(`code(${node.value})`);
-    } else if (node.type === 'text') {
-      out.push(node.value ?? '');
-    } else {
-      (node.children ?? []).forEach(visit);
-    }
-  };
-  (parseInlineAst(markdown) as unknown as Json[]).forEach(visit);
-  return out;
-}
-
-describe('code spans close at a backtick string of the same length (CommonMark 0.31 §6.1)', () => {
-  it.each([
-    ['`foo`', ['code(foo)']],
-    ['``foo`bar``', ['code(foo`bar)']],
-    ['`one`` & two`', ['code(one`` & two)']],
-    ['`foo``bar``', ['`foo', 'code(bar)']],
-    ['````x````', ['code(x)']],
-    ['````x``` y````', ['code(x``` y)']],
-    ['```foo``', ['```foo``']],
-    ['`foo', ['`foo']],
-    ['a `` b ` c `` d', ['a ', 'code( b ` c )', ' d']],
-    [
-      '`a` and ``b`` and `c`',
-      ['code(a)', ' and ', 'code(b)', ' and ', 'code(c)'],
-    ],
-  ])('reads %j', (markdown, expected) => {
-    expect(spans(markdown)).toEqual(expected);
-  });
-
-  it('closes a span in a table cell at the same length, with an escaped pipe as a pipe', () => {
-    const table = parseMarkdownAst('| a |\n| --- |\n| ``x`y \\| z`` |\n')
-      .children[0] as unknown as Json;
-    const cell = table.children?.[1]?.children?.[0];
-    expect(cell?.children).toEqual([{type: 'inlineCode', value: 'x`y | z'}]);
-  });
-
-  it('finds every closer in linear time, even with no closer for most strings', () => {
-    // Backtick strings of every length up to 400, none with a closer but the
-    // last pair: a scan per string would read the rest of the text each time.
-    const markdown = `${Array.from({length: 400}, (_, n) => `${'`'.repeat(n + 1)}a`).join(' ')} \`\`\`\`\`b\`\`\`\`\``;
-    parseInlineAst(markdown);
-    let fastest = Number.POSITIVE_INFINITY;
-    for (let round = 0; round < 3; round++) {
-      const started = performance.now();
-      parseInlineAst(markdown);
-      fastest = Math.min(fastest, performance.now() - started);
-    }
-    // Alone it takes a few milliseconds; the budget leaves room for a
-    // loaded test machine.
-    expect(fastest).toBeLessThan(1000);
-  });
-});

package/src/Markdown/emphasis.test.tsx

@@ -1,214 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {render} from '@testing-library/react';
-import {Markdown} from './Markdown';
-import {parseInlineAst, parseMarkdownAst} from './parser';
-
-type Json = {
-  readonly type: string;
-  readonly value?: string;
-  readonly url?: string;
-  readonly children?: ReadonlyArray<Json>;
-};
-
-const escapeHtml = (text: string): string =>
-  text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-
-/** Inline content as the HTML CommonMark's examples show. */
-function html(markdown: string): string {
-  const write = (node: Json): string => {
-    const inner = () => (node.children ?? []).map(write).join('');
-    switch (node.type) {
-      case 'text':
-        return escapeHtml(node.value ?? '');
-      case 'inlineCode':
-        return `<code>${escapeHtml(node.value ?? '')}</code>`;
-      case 'emphasis':
-        return `<em>${inner()}</em>`;
-      case 'strong':
-        return `<strong>${inner()}</strong>`;
-      case 'link':
-        return `<a href="${node.url ?? ''}">${inner()}</a>`;
-      case 'break':
-        return '<br />\n';
-      default:
-        return inner();
-    }
-  };
-  return (parseInlineAst(markdown) as unknown as ReadonlyArray<Json>)
-    .map(write)
-    .join('');
-}
-
-/**
- * CommonMark 0.31.2 §6.2 examples, by example number. Each pairs a run of
- * `*` or `_` by its flanking, its character, and the rule of three.
- */
-const COMMONMARK: ReadonlyArray<readonly [number, string, string]> = [
-  [350, '*foo bar*', '<em>foo bar</em>'],
-  [351, 'a * foo bar*', 'a * foo bar*'],
-  [352, 'a*"foo"*', 'a*&quot;foo&quot;*'.replace(/&quot;/g, '"')],
-  [354, 'foo*bar*', 'foo<em>bar</em>'],
-  [355, '5*6*78', '5<em>6</em>78'],
-  [356, '_foo bar_', '<em>foo bar</em>'],
-  [357, '_ foo bar_', '_ foo bar_'],
-  [359, 'foo_bar_', 'foo_bar_'],
-  [360, '5_6_78', '5_6_78'],
-  [361, 'пристаням_стремятся_', 'пристаням_стремятся_'],
-  [363, 'foo-_(bar)_', 'foo-<em>(bar)</em>'],
-  [364, '_foo*', '_foo*'],
-  [365, '*foo bar *', '*foo bar *'],
-  [368, '*foo*bar', '<em>foo</em>bar'],
-  [374, '_foo_bar_baz_', '<em>foo_bar_baz</em>'],
-  [378, '**foo bar**', '<strong>foo bar</strong>'],
-  [386, 'foo**bar**', 'foo<strong>bar</strong>'],
-  [
-    390,
-    '__foo, __bar__, baz__',
-    '<strong>foo, <strong>bar</strong>, baz</strong>',
-  ],
-  [413, '*foo **bar** baz*', '<em>foo <strong>bar</strong> baz</em>'],
-  [414, '*foo**bar**baz*', '<em>foo<strong>bar</strong>baz</em>'],
-  [415, '*foo**bar*', '<em>foo**bar</em>'],
-  [416, '***foo** bar*', '<em><strong>foo</strong> bar</em>'],
-  [417, '*foo **bar***', '<em>foo <strong>bar</strong></em>'],
-  [418, '*foo**bar***', '<em>foo<strong>bar</strong></em>'],
-  [
-    420,
-    'foo******bar*********baz',
-    'foo<strong><strong><strong>bar</strong></strong></strong>***baz',
-  ],
-  [
-    421,
-    '*foo **bar *baz* bim** bop*',
-    '<em>foo <strong>bar <em>baz</em> bim</strong> bop</em>',
-  ],
-  [422, '*foo [*bar*](/url)*', '<em>foo <a href="/url"><em>bar</em></a></em>'],
-  [423, '** is not an empty emphasis', '** is not an empty emphasis'],
-  [
-    424,
-    '**** is not an empty strong emphasis',
-    '**** is not an empty strong emphasis',
-  ],
-  [442, '**foo*', '*<em>foo</em>'],
-  [443, '*foo**', '<em>foo</em>*'],
-  [449, '*foo _bar* baz_', '<em>foo _bar</em> baz_'],
-  [
-    450,
-    '*foo __bar *baz bim__ bam*',
-    '<em>foo <strong>bar *baz bim</strong> bam</em>',
-  ],
-  [451, '**foo **bar baz**', '**foo <strong>bar baz</strong>'],
-  [452, '*foo *bar baz*', '*foo <em>bar baz</em>'],
-  [453, '*[bar*](/url)', '*<a href="/url">bar*</a>'],
-  [459, '*a `*`*', '<em>a <code>*</code></em>'],
-  [460, '_a `_`_', '<em>a <code>_</code></em>'],
-];
-
-describe('emphasis and strong (CommonMark 0.31.2 §6.2)', () => {
-  it.each(COMMONMARK)('example %i: %j', (_, markdown, expected) => {
-    expect(html(markdown)).toBe(expected);
-  });
-
-  it('keeps an escaped delimiter literal inside emphasis', () => {
-    expect(html('*a\\*b*')).toBe('<em>a*b</em>');
-    expect(html('**a\\*\\*b**')).toBe('<strong>a**b</strong>');
-  });
-
-  it('draws `***x***` as strong outside emphasis, as Markdown always has', () => {
-    expect(html('***both***')).toBe('<strong><em>both</em></strong>');
-    expect(html('foo***bar***baz')).toBe('foo<strong><em>bar</em></strong>baz');
-  });
-});
-
-describe('strong inside emphasis, as RichText writes it (spec:AST-061 FR7)', () => {
-  it.each([
-    ['*see **bold***', '<em>see <strong>bold</strong></em>'],
-    ['*see **bold** more*', '<em>see <strong>bold</strong> more</em>'],
-    ['**bold *both***', '<strong>bold <em>both</em></strong>'],
-    ['_see __bold__ more_', '<em>see <strong>bold</strong> more</em>'],
-    [
-      '*see **bold** and **more***',
-      '<em>see <strong>bold</strong> and <strong>more</strong></em>',
-    ],
-  ])('reads %j', (markdown, expected) => {
-    expect(html(markdown)).toBe(expected);
-  });
-
-  it('renders the strong inside the emphasis', () => {
-    const {container} = render(
-      <Markdown>{'Keep *see **bold** more* here.'}</Markdown>,
-    );
-    const emphasis = container.querySelector('em');
-    expect(emphasis?.textContent).toBe('see bold more');
-    expect(emphasis?.querySelector('strong')?.textContent).toBe('bold');
-    expect(container.textContent).not.toContain('*');
-  });
-});
-
-/**
- * The fastest of three parses of `markdown`, in milliseconds, after one
- * warm-up parse: the minimum is the least disturbed by other work running on
- * the same machine.
- */
-function parseTime(markdown: string): number {
-  parseMarkdownAst(markdown);
-  let fastest = Number.POSITIVE_INFINITY;
-  for (let round = 0; round < 3; round++) {
-    const started = performance.now();
-    parseMarkdownAst(markdown);
-    fastest = Math.min(fastest, performance.now() - started);
-  }
-  return fastest;
-}
-
-describe('pathological emphasis', () => {
-  const nestedStrongEmph = (levels: number): string =>
-    `${'*a **a '.repeat(levels)}b${' a** a*'.repeat(levels)}`;
-
-  it('nests up to 100 levels exactly', () => {
-    expect(html(nestedStrongEmph(50))).toBe(
-      `${'<em>a <strong>a '.repeat(50)}b${' a</strong> a</em>'.repeat(50)}`,
-    );
-  });
-
-  it('keeps runs past 100 levels as text, around the nesting it allows', () => {
-    expect(html(nestedStrongEmph(51))).toBe(
-      `*a **a ${'<em>a <strong>a '.repeat(50)}b${' a</strong> a</em>'.repeat(50)} a** a*`,
-    );
-  });
-
-  it.each([
-    ['nested strong emph', nestedStrongEmph, 5_000],
-    ['openers with no closers', (n: number) => '*a **a '.repeat(n), 7_000],
-    [
-      'openers, then as many closers',
-      (n: number) => `${'*a '.repeat(n)}${'b* '.repeat(n)}`,
-      4_000,
-    ],
-    ['closers with no openers', (n: number) => ' a*'.repeat(n), 15_000],
-    [
-      'runs whose lengths sum to a multiple of three',
-      (n: number) => `${'a**b'.repeat(n)}${'c* '.repeat(n)}`,
-      7_000,
-    ],
-  ] as const)(
-    'parses %s without throwing, within a time budget',
-    (_, input, size) => {
-      const large = input(size * 2);
-      expect(() => parseMarkdownAst(large)).not.toThrow();
-      // Alone, the largest of these parses in about 0.1 s. The budget leaves
-      // room for a loaded test machine running other suites in parallel; the
-      // quadratic pass took 20 to 200 seconds on the nested inputs.
-      expect(parseTime(large)).toBeLessThan(5000);
-    },
-    60_000,
-  );
-
-  it('renders 10,000 levels of nesting without exhausting the stack', () => {
-    const {container} = render(<Markdown>{nestedStrongEmph(10_000)}</Markdown>);
-    expect(container.querySelectorAll('em').length).toBe(50);
-    expect(container.querySelectorAll('strong').length).toBe(50);
-  });
-});

package/src/Markdown/fenceInfo.test.tsx

@@ -1,47 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {parseMarkdownAst} from './parser';
-
-type Json = {type: string; lang?: string | null; meta?: string; value?: string};
-
-/** The first block's language, meta, and code. */
-function code(markdown: string): {
-  lang: string | null;
-  meta: string | null;
-  value: string;
-} {
-  const [block] = parseMarkdownAst(markdown).children as unknown as Json[];
-  return {
-    lang: block.lang ?? null,
-    meta: block.meta ?? null,
-    value: block.value ?? '',
-  };
-}
-
-describe("a fence's info string (CommonMark 0.31 §4.5)", () => {
-  it.each([
-    ['~~~ js\nx\n~~~\n', {lang: 'js', meta: null, value: 'x'}],
-    ['``` js\nx\n```\n', {lang: 'js', meta: null, value: 'x'}],
-    [
-      '~~~   python title="a.py"\nx\n~~~\n',
-      {lang: 'python', meta: 'title="a.py"', value: 'x'},
-    ],
-    [
-      '``` {.haskell .numberLines}\nx\n```\n',
-      {lang: '{.haskell', meta: '.numberLines}', value: 'x'},
-    ],
-    [
-      '~~~python title="a.py"\nx\n~~~\n',
-      {lang: 'python', meta: 'title="a.py"', value: 'x'},
-    ],
-    ['~~~c++ \nx\n~~~\n', {lang: 'c++', meta: null, value: 'x'}],
-    ['~~~\nx\n~~~\n', {lang: null, meta: null, value: 'x'}],
-    ['~~~   \nx\n~~~\n', {lang: null, meta: null, value: 'x'}],
-  ])(
-    'reads the language of %j from its first word, after any spaces',
-    (markdown, expected) => {
-      expect(code(markdown)).toEqual(expected);
-    },
-  );
-});

package/src/Markdown/imageAlt.test.tsx

@@ -1,84 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {parseInlineAst, parseMarkdownAst} from './parser';
-
-type Json = {type: string; alt?: string; children?: Json[]};
-
-/** Every image's alt text, in order, searched iteratively. */
-function alts(nodes: ReadonlyArray<Json>): string[] {
-  const found: string[] = [];
-  const stack = [...nodes].reverse();
-  while (stack.length > 0) {
-    const node = stack.pop() as Json;
-    if (node.type === 'image') {
-      found.push(node.alt ?? '');
-    }
-    stack.push(...[...(node.children ?? [])].reverse());
-  }
-  return found;
-}
-
-const inlineAlts = (markdown: string): string[] =>
-  alts(parseInlineAst(markdown) as unknown as Json[]);
-
-const documentAlts = (markdown: string): string[] =>
-  alts(parseMarkdownAst(markdown).children as unknown as Json[]);
-
-describe("an image's alt text is its description as plain text (CommonMark 0.31 §6.4)", () => {
-  it.each([
-    ['code', '![`a]b`](u)', ['a]b']],
-    ['emphasis, strong, and code', '![*a* **b** `c`](u)', ['a b c']],
-    ['a link', '![a [b](u) c](v)', ['a b c']],
-    ['an image', '![a ![b](u) c](v)', ['a b c']],
-    ['escapes and character references', '![&amp; \\* x](u)', ['& * x']],
-    ['plain text, unchanged', '![a photo](u)', ['a photo']],
-    [
-      'a hard break as a line ending',
-      '![first  \nsecond](u)',
-      ['first\nsecond'],
-    ],
-    [
-      'a backslash hard break as a line ending',
-      '![first\\\nsecond](u)',
-      ['first\nsecond'],
-    ],
-    ['a soft break as a line ending', '![first\nsecond](u)', ['first\nsecond']],
-    [
-      'a hard break inside emphasis',
-      '![*first  \nsecond*](u)',
-      ['first\nsecond'],
-    ],
-  ])('reads %s: %j', (_, markdown, expected) => {
-    expect(inlineAlts(markdown)).toEqual(expected);
-  });
-
-  it('reads a reference image the same way', () => {
-    expect(documentAlts('![*a*][r]\n\n[r]: /i.png')).toEqual(['a']);
-  });
-
-  it('reads an image on its own line the same way', () => {
-    expect(documentAlts('![*a* `b`](/i.png)')).toEqual(['a b']);
-  });
-
-  it('reads a description ten images deep, and keeps the source deeper', () => {
-    const nested = (levels: number) =>
-      `${'!['.repeat(levels)}*a*${'](u)'.repeat(levels)}`;
-    expect(inlineAlts(nested(10))[0]).toBe('a');
-    expect(inlineAlts(nested(12))[0]).toContain('*a*');
-  });
-
-  it('reads images nested 20,000 deep without exhausting the stack, in time', () => {
-    const markdown = `${'!['.repeat(20_000)}a${'](u)'.repeat(20_000)}`;
-    expect(() => parseInlineAst(markdown)).not.toThrow();
-    let fastest = Number.POSITIVE_INFINITY;
-    for (let round = 0; round < 3; round++) {
-      const started = performance.now();
-      parseInlineAst(markdown);
-      fastest = Math.min(fastest, performance.now() - started);
-    }
-    // Alone it takes about 40 ms; the budget leaves room for a loaded test
-    // machine.
-    expect(fastest).toBeLessThan(1000);
-  });
-});