securemark 0.293.4 → 0.294.0

package/src/parser/block/extension/aside.ts

@@ -1,25 +1,29 @@
 import { ExtensionParser } from '../../block';
 import { Recursion } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { recursion, block, fence, fmap } from '../../../combinator';
 import { identity } from '../../inline/extension/indexee';
-import { invalid } from '../../util';
+import { unwrap, invalid } from '../../util';
 import { parse } from '../../api/parse';
 import { html } from 'typed-dom/dom';
 
 export const aside: ExtensionParser.AsideParser = recursion(Recursion.block, block(fmap(
   fence(/(~{3,})aside(?!\S)([^\n]*)(?:$|\n)/y, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, param]: string[], context) => {
-    if (!closer || overflow || param.trimStart()) return [html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid(
-        'aside',
-        !closer || overflow ? 'fence' : 'argument',
-        !closer ? `Missing the closing delimiter "${delim}"` :
-          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-            'Invalid argument'),
-    }, `${opener}${body}${overflow || closer}`)];
+  (nodes: List<Data<string>>, context) => {
+    const [body, overflow, closer, opener, delim, param] = unwrap(nodes);
+    if (!closer || overflow || param.trimStart()) return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid(
+          'aside',
+          !closer || overflow ? 'fence' : 'argument',
+          !closer ? `Missing the closing delimiter "${delim}"` :
+            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+              'Invalid argument'),
+      }, `${opener}${body}${overflow || closer}`))
+    ]);
     const references = html('ol', { class: 'references' });
     const document = parse(body.slice(0, -1), {
       id: '',
@@ -29,17 +33,19 @@ export const aside: ExtensionParser.AsideParser = recursion(Recursion.block, blo
     }, context);
     assert(!document.querySelector('[id]'));
     const heading = 'H1 H2 H3 H4 H5 H6'.split(' ').includes(document.firstElementChild?.tagName!) && document.firstElementChild as HTMLHeadingElement;
-    if (!heading) return [html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid('aside', 'content', 'Missing the title at the first line'),
-    }, `${opener}${body}${closer}`)];
+    if (!heading) return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid('aside', 'content', 'Missing the title at the first line'),
+      }, `${opener}${body}${closer}`))
+    ]);
     assert(identity('index', context.id, heading));
-    return [
-      html('aside', { id: identity('index', context.id, heading), class: 'aside' }, [
+    return new List([
+      new Data(html('aside', { id: identity('index', context.id, heading), class: 'aside' }, [
         document,
         html('h2', 'References'),
         references,
-      ]),
-    ];
+      ]))
+    ]);
   })));

package/src/parser/block/extension/example.ts

@@ -1,9 +1,9 @@
 import { ExtensionParser } from '../../block';
 import { Recursion } from '../../context';
-import { input, eval } from '../../../combinator/data/parser';
+import { List, Data, subinput, eval } from '../../../combinator/data/parser';
 import { recursion, block, fence, fmap } from '../../../combinator';
 import { mathblock } from '../mathblock';
-import { invalid } from '../../util';
+import { unwrap, invalid } from '../../util';
 import { parse } from '../../api/parse';
 import { html } from 'typed-dom/dom';
 
@@ -12,17 +12,20 @@ const opener = /(~{3,})(?:example\/(\S+))?(?!\S)([^\n]*)(?:$|\n)/y;
 export const example: ExtensionParser.ExampleParser = recursion(Recursion.block, block(fmap(
   fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, type = 'markdown', param]: string[], context) => {
-    if (!closer || overflow || param.trimStart()) return [html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid(
-        'example',
-        !closer || overflow ? 'fence' : 'argument',
-        !closer ? `Missing the closing delimiter "${delim}"` :
-          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-            'Invalid argument'),
-    }, `${opener}${body}${overflow || closer}`)];
+  (nodes: List<Data<string>>, context) => {
+    const [body, overflow, closer, opener, delim, type = 'markdown', param] = unwrap(nodes);
+    if (!closer || overflow || param.trimStart()) return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid(
+          'example',
+          !closer || overflow ? 'fence' : 'argument',
+          !closer ? `Missing the closing delimiter "${delim}"` :
+            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+              'Invalid argument'),
+      }, `${opener}${body}${overflow || closer}`))
+    ]);
     switch (type) {
       case 'markdown': {
         const references = html('ol', { class: 'references' });
@@ -33,29 +36,29 @@ export const example: ExtensionParser.ExampleParser = recursion(Recursion.block,
           },
         }, context);
         assert(!document.querySelector('[id]'));
-        return [
-          html('aside', { class: 'example', 'data-type': 'markdown' }, [
+        return new List([
+          new Data(html('aside', { class: 'example', 'data-type': 'markdown' }, [
             html('pre', { translate: 'no' }, body.slice(0, -1)),
             html('hr'),
             html('section', [document, html('h2', 'References'), references]),
-          ]),
-        ];
+          ])),
+        ]);
       }
       case 'math':
-        return [
-          html('aside', { class: 'example', 'data-type': 'math' }, [
+        return new List([
+          new Data(html('aside', { class: 'example', 'data-type': 'math' }, [
             html('pre', { translate: 'no' }, body.slice(0, -1)),
             html('hr'),
-            eval(mathblock(input(`$$\n${body}$$`, { ...context })), [])[0],
-          ]),
-        ];
+            eval(mathblock(subinput(`$$\n${body}$$`, context)))!.head!.value,
+          ])),
+        ]);
       default:
-        return [
-          html('pre', {
+        return new List([
+          new Data(html('pre', {
             class: 'invalid',
             translate: 'no',
             ...invalid('example', 'type', 'Invalid example type'),
-          }, `${opener}${body}${closer}`),
-        ];
+          }, `${opener}${body}${closer}`)),
+        ]);
     }
   })));

package/src/parser/block/extension/fig.ts

@@ -36,7 +36,7 @@ export const fig: FigParser = block(rewrite(segment, verify(convert(
   },
   union([figure]),
   false),
-  ([el]) => el.tagName === 'FIGURE')));
+  ([{ value: el }]) => el.tagName === 'FIGURE')));
 
 const parser = sequence([
   line(close(seg_label, /(?=\s).*\n/y)),

package/src/parser/block/extension/figbase.ts

@@ -1,4 +1,5 @@
 import { ExtensionParser } from '../../block';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, block, line, validate, fmap } from '../../../combinator';
 import { label } from '../../inline/extension/label';
 import { html } from 'typed-dom/dom';
@@ -6,14 +7,14 @@ import { html } from 'typed-dom/dom';
 export const figbase: ExtensionParser.FigbaseParser = block(fmap(
   validate(/\[?\$-(?:[0-9]+\.)*0\]?[^\S\n]*(?!\S|\n[^\S\n]*\S)/y,
   line(union([label]))),
-  ([el]) => {
+  ([{ value: el }]) => {
     const label = el.getAttribute('data-label')!;
     const group = label.split('-', 1)[0];
-    return [
-      html('figure', {
+    return new List([
+      new Data(html('figure', {
         'data-label': label,
         'data-group': group,
         hidden: '',
-      }),
-    ];
+      })),
+    ]);
   }));

package/src/parser/block/extension/figure.ts

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../../block';
-import { input } from '../../../combinator/data/parser';
+import { List, Data, subinput } from '../../../combinator/data/parser';
 import { union, inits, sequence, some, block, line, fence, rewrite, close, match, convert, fallback, fmap } from '../../../combinator';
 import { str, contentline, emptyline } from '../../source';
 import { label, segment as seg_label } from '../../inline/extension/label';
@@ -14,7 +14,7 @@ import { blockquote, segment as seg_blockquote } from '../blockquote';
 import { placeholder, segment_ as seg_placeholder } from './placeholder';
 import { inline, media, lineshortmedia } from '../../inline';
 import { visualize, trimBlank } from '../../visibility';
-import { invalid } from '../../util';
+import { unwrap, invalid } from '../../util';
 import { memoize } from 'spica/memoize';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -68,20 +68,24 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
       block(visualize(trimBlank(some(inline)))),
     ]),
   ]), false),
-  ([label, param, content, ...caption]: [HTMLAnchorElement, string, ...HTMLElement[]]) => [
-    html('figure',
-      attributes(label.getAttribute('data-label')!, param, content, caption),
-      [
-        html('figcaption', [
-          html('span', { class: 'figindex' }),
-          html('span', { class: 'figtext' }, defrag(caption)),
-        ]),
-        html('div', [content]),
-      ])
-  ])),
+  nodes => {
+    const [label, param, content, ...caption] = unwrap(nodes) as [HTMLAnchorElement, string, ...HTMLElement[]];
+    return new List([
+      new Data(html('figure',
+        attributes(label.getAttribute('data-label')!, param, content, caption),
+        [
+          html('figcaption', [
+            html('span', { class: 'figindex' }),
+            html('span', { class: 'figtext' }, defrag(caption)),
+          ]),
+          html('div', [content]),
+        ]))
+    ]);
+  })),
   fmap(
     fence(/(~{3,})(?:figure|\[?\$\S*)(?!\S)[^\n]*(?:$|\n)/y, 300),
-    ([body, overflow, closer, opener, delim]: string[], context) => {
+    (nodes, context) => {
+      const [body, overflow, closer, opener, delim] = unwrap<string>(nodes);
       const violation =
         !closer && [
           'fence',
@@ -91,7 +95,7 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
           'fence',
           `Invalid trailing line after the closing delimiter "${delim}"`,
         ] ||
-        !seg_label(input(opener.match(/^~+(?:figure[^\S\n]+)?(\[?\$\S+)/)?.[1] ?? '', { ...context })) && [
+        !seg_label(subinput(opener.match(/^~+(?:figure[^\S\n]+)?(\[?\$\S+)/)?.[1] ?? '', context)) && [
           'label',
           'Invalid label',
         ] ||
@@ -103,13 +107,13 @@ export const figure: FigureParser = block(fallback(rewrite(segment, fmap(
           'content',
           'Invalid content',
         ];
-      return [
-        html('pre', {
+      return new List([
+        new Data(html('pre', {
           class: 'invalid',
           translate: 'no',
           ...invalid('figure', violation[0], violation[1]),
-        }, `${opener}${body}${overflow || closer}`),
-      ];
+        }, `${opener}${body}${overflow || closer}`)),
+      ]);
     })));
 
 function attributes(label: string, param: string, content: HTMLElement, caption: readonly HTMLElement[]): Record<string, string | undefined> {

package/src/parser/block/extension/message.ts

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../../block';
-import { input, eval } from '../../../combinator/data/parser';
+import { List, Data, subinput, eval } from '../../../combinator/data/parser';
 import { union, block, fence, fmap } from '../../../combinator';
 import { segment } from '../../segment';
 import { emptyline } from '../../source';
@@ -13,8 +13,8 @@ import { sidefence } from '../sidefence';
 import { blockquote } from '../blockquote';
 import { mediablock } from '../mediablock';
 import { paragraph } from '../paragraph';
-import { invalid } from '../../util';
-import { unshift, push } from 'spica/array';
+import { unwrap, invalid } from '../../util';
+import { push } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
 import MessageParser = ExtensionParser.MessageParser;
@@ -22,34 +22,45 @@ import MessageParser = ExtensionParser.MessageParser;
 export const message: MessageParser = block(fmap(
   fence(/(~{3,})message\/(\S+)([^\n]*)(?:$|\n)/y, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, type, param]: string[], context) => {
-    if (!closer || overflow || param.trimStart()) return [html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid(
-        'message',
-        !closer || overflow ? 'fence' : 'argument',
-        !closer ? `Missing the closing delimiter "${delim}"` :
-          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-            'Invalid argument'),
-    }, `${opener}${body}${overflow || closer}`)];
+  (nodes: List<Data<string>>, context) => {
+    const [body, overflow, closer, opener, delim, type, param] = unwrap(nodes);
+    if (!closer || overflow || param.trimStart()) return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid(
+          'message',
+          !closer || overflow ? 'fence' : 'argument',
+          !closer ? `Missing the closing delimiter "${delim}"` :
+            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+              'Invalid argument'),
+      }, `${opener}${body}${overflow || closer}`))
+    ]);
     switch (type) {
       case 'note':
       case 'caution':
       case 'warning':
         break;
       default:
-        return [html('pre', {
-          class: 'invalid',
-          translate: 'no',
-          ...invalid('message', 'type', 'Invalid message type'),
-        }, `${opener}${body}${closer}`)];
+        return new List([
+          new Data(html('pre', {
+            class: 'invalid',
+            translate: 'no',
+            ...invalid('message', 'type', 'Invalid message type'),
+          }, `${opener}${body}${closer}`))
+        ]);
     }
-    return [
-      html('section', { class: `message`, 'data-type': type }, unshift(
-        [html('h1', title(type))],
-        [...segment(body)].reduce((acc, seg) => push(acc, eval(content(input(seg, { ...context })), [])), []))),
-    ];
+    return new List([
+      new Data(html('section',
+        {
+          class: `message`,
+          'data-type': type,
+        },
+        [...segment(body)].reduce(
+          (acc, seg) =>
+            push(acc, unwrap(eval(content(subinput(seg, context)))!)),
+          [html('h1', title(type))])))
+    ]);
   }));
 
 function title(type: string): string {

package/src/parser/block/extension/placeholder.ts

@@ -1,6 +1,7 @@
 import { ExtensionParser } from '../../block';
+import { List, Data } from '../../../combinator/data/parser';
 import { block, fence, clear, fmap } from '../../../combinator';
-import { invalid } from '../../util';
+import { unwrap, invalid } from '../../util';
 import { html } from 'typed-dom/dom';
 
 const opener = /(~{3,})(?!~)[^\n]*(?:$|\n)/y;
@@ -13,15 +14,18 @@ export const segment_: ExtensionParser.PlaceholderParser.SegmentParser = block(
 
 export const placeholder: ExtensionParser.PlaceholderParser = block(fmap(
   fence(opener, Infinity),
-  ([body, overflow, closer, opener, delim]) => [
-    html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid(
-        'extension',
-        'fence',
-        !closer ? `Missing the closing delimiter "${delim}"` :
-          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-            'Invalid argument'),
-    }, `${opener}${body}${overflow || closer}`),
-  ]));
+  nodes => {
+    const [body, overflow, closer, opener, delim] = unwrap(nodes);
+    return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid(
+          'extension',
+          'fence',
+          !closer ? `Missing the closing delimiter "${delim}"` :
+            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+              'Invalid argument'),
+      }, `${opener}${body}${overflow || closer}`)),
+    ]);
+  }));

package/src/parser/block/extension/table.ts

@@ -1,12 +1,12 @@
-import { max, min, isArray } from 'spica/alias';
+import { max, min } from 'spica/alias';
 import { ExtensionParser } from '../../block';
-import { Node, eval, input } from '../../../combinator/data/parser';
+import { List, Data, subinput, eval } from '../../../combinator/data/parser';
 import { union, subsequence, inits, some, block, line, validate, fence, rewrite, clear, surround, open, convert, dup, lazy, fmap } from '../../../combinator';
 import { inline, medialink, media, lineshortmedia } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
-import { invalid } from '../../util';
+import { unwrap, invalid } from '../../util';
 import { visualize, trimBlank, trimBlankEnd } from '../../visibility';
-import { unshift, splice } from 'spica/array';
+import { splice } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import TableParser = ExtensionParser.TableParser;
@@ -25,40 +25,49 @@ export const segment_: TableParser.SegmentParser = block(
 export const table: TableParser = block(fmap(
   fence(opener, 10000),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, type, param]: string[], context) => {
-    if (!closer || overflow || param.trimStart()) return [html('pre', {
-      class: 'invalid',
-      translate: 'no',
-      ...invalid(
-        'table',
-        !closer || overflow ? 'fence' : 'argument',
-        !closer ? `Missing the closing delimiter "${delim}"` :
-          overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-            'Invalid argument'),
-    }, `${opener}${body}${overflow || closer}`)];
+  (nodes: List<Data<string>>, context) => {
+    const [body, overflow, closer, opener, delim, type, param] = unwrap(nodes);
+    if (!closer || overflow || param.trimStart()) return new List([
+      new Data(html('pre', {
+        class: 'invalid',
+        translate: 'no',
+        ...invalid(
+          'table',
+          !closer || overflow ? 'fence' : 'argument',
+          !closer ? `Missing the closing delimiter "${delim}"` :
+            overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
+              'Invalid argument'),
+      }, `${opener}${body}${overflow || closer}`))
+    ]);
     switch (type) {
       case 'grid':
       case undefined:
-        return (eval(parser(input(body, { ...context }))) ?? [html('table')])
-          .map(el => define(el, { 'data-type': type }));
+        return (eval(parser(subinput(body, context))) ?? new List([new Data(html('table'))]))
+          .foldl(
+            (acc, { value }) => acc.push(new Data(define(value, { 'data-type': type }))) && acc,
+            new List());
       default:
-        return [html('pre', {
-          class: 'invalid',
-          translate: 'no',
-          ...invalid('table', 'argument', 'Invalid table type'),
-        }, `${opener}${body}${closer}`)];
+        return new List([
+          new Data(html('pre', {
+            class: 'invalid',
+            translate: 'no',
+            ...invalid('table', 'argument', 'Invalid table type'),
+          }, `${opener}${body}${closer}`))
+        ]);
     }
   }));
 
 const parser: TableParser = lazy(() => block(fmap(
   some(union([row])),
-  rows => [html('table', format(rows))])));
+  rows => new List([
+    new Data(html('table', format([...unwrap(rows)])))
+  ]))));
 
 const row: RowParser = lazy(() => dup(fmap(
   subsequence([
-    dup(union([
+    union([
       align,
-    ])),
+    ]),
     some(union([
       head,
       data,
@@ -66,13 +75,13 @@ const row: RowParser = lazy(() => dup(fmap(
       emptyline,
     ])),
   ]),
-  ns => !isArray(ns[0]) ? unshift([[[]]], ns) : ns)));
+  ns => Array.isArray(ns.head?.value) ? ns : ns.unshift(new Data([[]])) && ns)));
 
 const alignment = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)/y;
 
 const align: AlignParser = line(fmap(
   union([str(alignment)]),
-  ([s]) => s.split('/').map(s => s.split(''))));
+  ([{ value }]) => new List([new Data(value.split('/').map(s => s.split('')) as [string[], string[]?])])));
 
 const delimiter = /[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)|[#:](?:(?!:\D|0)\d*:(?!0)\d*)?(?:!+[+]?)?(?=\s)/y;
 
@@ -91,11 +100,11 @@ const head: CellParser.HeadParser = block(fmap(open(
           media,
           lineshortmedia,
         ]),
-        /\s*$/y)),
+        /[^\S\n]*(?:$|\n)/y)),
       open(/(?:[^\S\n]*\n|\s)/y, visualize(trimBlank(some(inline))), true),
     ])),
   true),
-  ns => [html('th', attributes(ns.shift()! as string), defrag(ns))]),
+  ns => new List([new Data(html('th', attributes(ns.shift()!.value as string), defrag(unwrap(ns))))])),
   false);
 
 const data: CellParser.DataParser = block(fmap(open(
@@ -113,11 +122,11 @@ const data: CellParser.DataParser = block(fmap(open(
           media,
           lineshortmedia,
         ]),
-        /\s*$/y)),
+        /[^\S\n]*(?:$|\n)/y)),
       open(/(?:[^\S\n]*\n|\s)/y, visualize(trimBlankEnd(some(inline))), true),
     ])),
   true),
-  ns => [html('td', attributes(ns.shift()! as string), defrag(ns))]),
+  ns => new List([new Data(html('td', attributes(ns.shift()!.value as string), defrag(unwrap(ns))))])),
   false);
 
 const dataline: CellParser.DatalineParser = line(
@@ -157,7 +166,7 @@ function attributes(source: string): Record<string, string | undefined> {
   };
 }
 
-function format(rows: Node<RowParser>[]): HTMLTableSectionElement[] {
+function format(rows: List<Data<[string[], string[]?] | HTMLTableCellElement>>[]): HTMLTableSectionElement[] {
   const thead = html('thead');
   const tbody = html('tbody');
   const tfoot = html('tfoot');
@@ -167,13 +176,11 @@ function format(rows: Node<RowParser>[]): HTMLTableSectionElement[] {
   let ranges: Record<number, Record<number, HTMLTableCellElement>> = {};
   let verticalHighlightExtensions = 0n;
   let verticalHighlightLevels: string[] = [];
-  ROW:
-  for (let i = 0; i < rows.length; ++i) {
+
+  let cnt = 0;
+  for (const list of rows) ROW: for (let i = cnt++; i < cnt; ++i) {
     // Copy to make them retryable.
-    const [[[...as], [...vs] = []], ...cells] = rows[i];
-    assert(as !== rows[i][0]?.[0]);
-    assert(vs !== rows[i][0]?.[1]);
-    assert(cells !== rows[i]);
+    const [{ value: [[...as], [...vs] = []] }, ...cells] = list as any as [Data<[string[], string[]?]>, ...Data<HTMLTableCellElement>[]];
     let isBody = target === tfoot
       ? false
       : undefined;
@@ -248,7 +255,7 @@ function format(rows: Node<RowParser>[]): HTMLTableSectionElement[] {
       const isVirtual = !!ranges[i]?.[j];
       const cell = isVirtual
         ? splice(cells, j, 0, undefined) && ranges[i][j]
-        : cells[j];
+        : cells[j].value;
       const isHeadCell = cell.tagName === 'TH';
       heads |= isHeadCell ? 1n << jn : 0n;
       highlights |= cell.className === 'highlight' ? 1n << jn : 0n;
@@ -326,7 +333,7 @@ function format(rows: Node<RowParser>[]): HTMLTableSectionElement[] {
         const lHighlight = ~lHeadCellIndex && horizontalHighlights & 1n << lHeadCellIndex;
         const rHighlight = ~rHeadCellIndex && horizontalHighlights & 1n << rHeadCellIndex;
         for (let i = 0, m = 1n; i < cells.length; ++i, m <<= 1n) {
-          const cell = cells[i];
+          const cell = cells[i]?.value;
           if (!cell) continue;
           if (heads & m) continue;
           assert(cell.tagName === 'TD');

package/src/parser/block/heading.test.ts

@@ -1,16 +1,11 @@
-import { heading, segment } from './heading';
-import { input, eval } from '../../combinator/data/parser';
+import { heading } from './heading';
+import { input } from '../../combinator/data/parser';
 import { some } from '../../combinator';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/block/heading', () => {
   describe('heading', () => {
-    const parser = (source: string) => {
-      const result = segment(input(source, ctx));
-      return result
-        ? [eval(result).flatMap(seg => eval<HTMLElement | string>(heading(input(seg, {})), [seg]))] as const
-        : some(heading)(input(source, ctx));
-    };
+    const parser = (source: string) => some(heading)(input(source, ctx));
     const { context: ctx } = input('', {});
 
     it('invalid', () => {
@@ -54,10 +49,6 @@ describe('Unit: parser/block/heading', () => {
       assert.deepStrictEqual(inspect(parser('# a[[b]]'), ctx), [['<h1 id="index::a[[b]]">a[[b]]</h1>'], '']);
       assert.deepStrictEqual(inspect(parser('## a[[b]]'), ctx), [['<h2 id="index::a[[b]]">a[[b]]</h2>'], '']);
       assert.deepStrictEqual(inspect(parser('###### a'), ctx), [['<h6 id="index::a">a</h6>'], '']);
-      assert.deepStrictEqual(inspect(parser('# a\n##'), ctx), [['<h1 id="index::a">a</h1>', '##'], '']);
-      assert.deepStrictEqual(inspect(parser('# a\n## '), ctx), [['<h1 id="index::a">a</h1>', '## '], '']);
-      assert.deepStrictEqual(inspect(parser('# a\n## b'), ctx), [['<h1 id="index::a">a</h1>', '<h2 id="index::b">b</h2>'], '']);
-      assert.deepStrictEqual(inspect(parser('# a\n##\n## b'), ctx), [['<h1 id="index::a">a</h1>', '##\n', '<h2 id="index::b">b</h2>'], '']);
     });
 
     it('indexer', () => {