securemark 0.293.4 → 0.294.0

package/src/parser/block/heading.ts

@@ -1,15 +1,16 @@
 import { HeadingParser } from '../block';
 import { State } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, state, block, line, validate, focus, rewrite, open, fmap } from '../../combinator';
 import { inline, indexee, indexer, dataindex } from '../inline';
 import { str } from '../source';
 import { visualize, trimBlank } from '../visibility';
-import { invalid } from '../util';
+import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const segment: HeadingParser.SegmentParser = block(validate('#', focus(
   /#+[^\S\n]+\S[^\n]*(?:\n#+(?!\S)[^\n]*)*(?:$|\n)/y,
-  some(line(({ context: { source } }) => [[source]])))));
+  some(line(({ context: { source } }) => new List([new Data(source)]))))));
 
 export const heading: HeadingParser = block(rewrite(segment,
   // その他の表示制御は各所のCSSで行う。
@@ -23,11 +24,14 @@ export const heading: HeadingParser = block(rewrite(segment,
       state(State.linkers,
       visualize(trimBlank(some(union([indexer, inline]))))), true),
   ]),
-  ([h, ...ns]: [string, ...(HTMLElement | string)[]], context) => [
-    h.length <= 6
-      ? html(`h${h.length as 1}`, { 'data-index': dataindex(ns) }, defrag(ns))
-      : html(`h6`, {
+  (nodes, context) => {
+    const [h, ...ns] = unwrap(nodes) as [string, ...(HTMLElement | string)[]];
+    return new List([
+      h.length <= 6
+        ? new Data(html(`h${h.length as 1}`, { 'data-index': dataindex(nodes) }, defrag(ns)))
+        : new Data(html(`h6`, {
           class: 'invalid',
           ...invalid('heading', 'syntax', 'Heading level must be up to 6'),
-        }, context.source.slice(context.position - context.range!, context.position))
-  ]))))));
+        }, context.source.slice(context.position - context.range!, context.position)))
+    ]);
+  }))))));

package/src/parser/block/ilist.ts

@@ -1,13 +1,14 @@
 import { IListParser } from '../block';
 import { Parser } from '../../combinator/data/parser';
 import { Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, inits, some, recursion, block, line, validate, indent, rewrite, open, fallback, lazy, fmap } from '../../combinator';
 import { ulist_, fillFirstLine } from './ulist';
 import { olist_ } from './olist';
 import { inline } from '../inline';
 import { contentline } from '../source';
 import { visualize, trimBlank } from '../visibility';
-import { invalid } from '../util';
+import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const ilist: IListParser = lazy(() => block(validate(
@@ -23,21 +24,21 @@ export const ilist_: IListParser = lazy(() => block(fmap(validate(
         indent(union([ulist_, olist_, ilist_])),
       ]),
       ilistitem),
-      ns => [html('li', defrag(fillFirstLine(ns)))]),
+      ns => new List([new Data(html('li', defrag(unwrap(fillFirstLine(ns)))))])),
   ])))),
-  es => [
-    html('ul', {
+  ns => new List([
+    new Data(html('ul', {
       class: 'invalid',
       ...invalid('list', 'syntax', 'Use "-" instead of "+" or "*"'),
-    }, es),
-  ])));
+    }, unwrap(ns))),
+  ]))));
 
 export const ilistitem = rewrite(
-  inits([contentline, indent<Parser<string>>(({ context: { source } }) => [[source]])]),
-  ({ context: { source } }) => [[
-    '',
-    html('span', {
+  inits([contentline, indent<Parser<string>>(({ context: { source } }) => new List([new Data(source)]))]),
+  ({ context: { source } }) => new List([
+    new Data(''),
+    new Data(html('span', {
       class: 'invalid',
       ...invalid('list', 'syntax', 'Fix the indent or the head of the list item'),
-    }, source.replace('\n', ''))
-  ]]);
+    }, source.replace('\n', '')))
+  ]));

package/src/parser/block/mathblock.ts

@@ -1,6 +1,7 @@
 import { MathBlockParser } 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 = /(\${2,})(?!\$)([^\n]*)(?:$|\n)/y;
@@ -14,19 +15,22 @@ export const segment_: MathBlockParser.SegmentParser = block(
 export const mathblock: MathBlockParser = block(fmap(
   fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, param]: string[], { caches: { math: cache = undefined } = {} }) => [
-    delim.length === 2 && closer && !overflow && param.trimStart() === ''
-      ? cache?.get(`${delim}\n${body}${delim}`)?.cloneNode(true) as HTMLDivElement ||
-        html('div', { class: 'math', translate: 'no' }, `${delim}\n${body}${delim}`)
-      : html('pre', {
-          class: 'invalid',
-          translate: 'no',
-          ...invalid(
-            'mathblock',
-            delim.length > 2 ? 'syntax' : !closer || overflow ? 'fence' : 'argument',
-            delim.length > 2 ? 'Invalid syntax' :
-              !closer ? `Missing the closing delimiter "${delim}"` :
-                overflow ? `Invalid trailing line after the closing delimiter "${delim}"` :
-                  'Invalid argument'),
-        }, `${opener}${body}${overflow || closer}`),
-  ]));
+  (nodes, { caches: { math: cache = undefined } = {} }) => {
+    const [body, overflow, closer, opener, delim, param] = unwrap<string>(nodes);
+    return new List([
+      delim.length === 2 && closer && !overflow && param.trimStart() === ''
+        ? new Data(cache?.get(`${delim}\n${body}${delim}`)?.cloneNode(true) as HTMLDivElement ||
+          html('div', { class: 'math', translate: 'no' }, `${delim}\n${body}${delim}`))
+        : new Data(html('pre', {
+            class: 'invalid',
+            translate: 'no',
+            ...invalid(
+              'mathblock',
+              delim.length > 2 ? 'syntax' : !closer || overflow ? 'fence' : 'argument',
+              delim.length > 2 ? 'Invalid syntax' :
+                !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/mediablock.ts

@@ -1,7 +1,8 @@
 import { MediaBlockParser } from '../block';
+import { List, Data } from '../../combinator/data/parser';
 import { union, inits, some, block, line, fallback, fmap } from '../../combinator';
 import { medialink, media, lineshortmedia } from '../inline';
-import { invalid } from '../util';
+import { unwrap, invalid } from '../util';
 import { html } from 'typed-dom/dom';
 
 export const mediablock: MediaBlockParser = block(fmap(
@@ -15,9 +16,10 @@ export const mediablock: MediaBlockParser = block(fmap(
       medialink,
       media,
       lineshortmedia,
-    ]), ({ context: { source } }) => [[html('span', {
+    ]), ({ context: { source } }) => new List([
+      new Data(html('span', {
       class: 'invalid',
       ...invalid('mediablock', 'syntax', 'Not media syntax'),
-    }, source.replace('\n', ''))]]))),
-  ]),
-  ns => [html('div', ns)]));
+    }, source.replace('\n', '')))
+    ]))))]),
+  ns => new List([new Data(html('div', unwrap(ns)))])));

package/src/parser/block/olist.ts

@@ -1,10 +1,11 @@
 import { OListParser } from '../block';
 import { Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, open, match, fallback, lazy, fmap } from '../../combinator';
 import { ulist_, checkbox, fillFirstLine } from './ulist';
 import { ilist_, ilistitem } from './ilist';
 import { inline, indexee, indexer, dataindex } from '../inline';
-import { invalid } from '../util';
+import { invalid, unwrap } from '../util';
 import { visualize, trimBlank } from '../visibility';
 import { memoize } from 'spica/memoize';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -40,17 +41,26 @@ const list = (type: string, form: string): OListParser.ListParser => fmap(
         indent(union([ulist_, olist_, ilist_])),
       ]),
       ilistitem),
-      ns => [html('li', { 'data-index': dataindex(ns), 'data-marker': ns.shift() as string || undefined }, defrag(fillFirstLine(ns)))])),
+      ns => new List([
+        new Data(html('li', {
+          'data-index': dataindex(ns),
+          'data-marker': ns.shift()?.value as string || undefined,
+        }, defrag(unwrap(fillFirstLine(ns)))))
+      ]))),
   ]))),
-  es => [format(html('ol', es), type, form)]);
+  ns => new List([new Data(format(html('ol', unwrap(ns)), type, form))]));
 
 const heads = {
   '.': focus(
     openers['.'],
-    ({ context: { source } }) => [[source.trimEnd().split('.', 1)[0] + '.']]),
+    ({ context: { source } }) => new List([
+      new Data(source.trimEnd().split('.', 1)[0] + '.')
+    ])),
   '(': focus(
     openers['('],
-    ({ context: { source } }) => [[source.trimEnd().replace(/^\($/, '(1)').replace(/^\((\w+)$/, '($1)')]]),
+    ({ context: { source } }) => new List([
+      new Data(source.trimEnd().replace(/^\($/, '(1)').replace(/^\((\w+)$/, '($1)'))
+    ])),
 } as const;
 
 function idx(value: string): number {

package/src/parser/block/pagebreak.ts

@@ -1,7 +1,8 @@
 import { PagebreakParser } from '../block';
+import { List, Data } from '../../combinator/data/parser';
 import { block, line, focus } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
 export const pagebreak: PagebreakParser = block(line(focus(
   /={3,}[^\S\n]*(?:$|\n)/y,
-  () => [[html('hr')]])));
+  () => new List([new Data(html('hr'))]))));

package/src/parser/block/paragraph.ts

@@ -1,9 +1,11 @@
 import { ParagraphParser } from '../block';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, block, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { visualize, trimBlankEnd } from '../visibility';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const paragraph: ParagraphParser = block(fmap(
   visualize(trimBlankEnd(some(union([inline])))),
-  ns => [html('p', defrag(ns))]));
+  ns => new List([new Data(html('p', defrag(unwrap(ns))))])));

package/src/parser/block/reply/cite.ts

@@ -1,4 +1,5 @@
 import { ReplyParser } from '../../block';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, line, focus, open, fmap } from '../../../combinator';
 import { anchor } from '../../inline/autolink/anchor';
 import { str } from '../../source';
@@ -14,20 +15,24 @@ export const cite: ReplyParser.CiteParser = line(fmap(
       anchor,
       // Subject page representation.
       // リンクの実装は後で検討
-      focus(/>>#\S*(?=\s*$)/y, ({ context: { source } }) => [[html('a', { class: 'anchor' }, source)]]),
-      focus(/>>https?:\/\/\S+(?=\s*$)/y, ({ context: { source } }) => [[html('a', { class: 'anchor', href: source.slice(2).trimEnd(), target: '_blank' }, source)]]),
-      focus(/>>.+(?=\s*$)/y, ({ context: { source } }) => [[source]]),
+      focus(/>>#\S*(?=\s*$)/y, ({ context: { source } }) => new List([new Data(html('a', { class: 'anchor' }, source))])),
+      focus(/>>https?:\/\/\S+(?=\s*$)/y, ({ context: { source } }) => new List([new Data(html('a', { class: 'anchor', href: source.slice(2).trimEnd(), target: '_blank' }, source))])),
+      focus(/>>.+(?=\s*$)/y, ({ context: { source } }) => new List([new Data(source)])),
     ])),
-  ([quotes, node]: [string, HTMLElement | string]) => [
-    html('span',
-      typeof node === 'object'
-        ? { class: 'cite' }
-        : { class: 'cite invalid', ...invalid('cite', 'syntax', 'Invalid syntax') },
-      defrag([
-        `${quotes}>`,
+  nodes => {
+    const quotes = nodes.head!.value as string;
+    const node = nodes.last!.value;
+    return new List([
+      new Data(html('span',
         typeof node === 'object'
-          ? define(node, { 'data-depth': `${quotes.length + 1}` }, node.innerText.slice(1))
-          : node.slice(1),
-      ])),
-    html('br'),
-  ]));
+          ? { class: 'cite' }
+          : { class: 'cite invalid', ...invalid('cite', 'syntax', 'Invalid syntax') },
+        defrag([
+          `${quotes}>`,
+          typeof node === 'object'
+            ? define(node, { 'data-depth': `${quotes.length + 1}` }, node.innerText.slice(1))
+            : node.slice(1),
+        ]))),
+      new Data(html('br')),
+    ]);
+  }));

package/src/parser/block/reply/quote.ts

@@ -1,9 +1,10 @@
 import { ReplyParser } from '../../block';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, some, block, validate, rewrite, convert, lazy, fmap } from '../../../combinator';
 import { math } from '../../inline/math';
 import { autolink } from '../../inline/autolink';
 import { linebreak, unescsource, anyline } from '../../source';
-import { linearize } from '../../util';
+import { unwrap } from '../../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const syntax = />+[^\S\n]/y;
@@ -11,7 +12,8 @@ export const syntax = />+[^\S\n]/y;
 export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(
   rewrite(
     some(validate(syntax, anyline)),
-    linearize(convert(
+    convert(
+      // TODO: インデント数を渡してインデント数前の行頭確認を行う実装に置き換える
       source => source.replace(/(?<=^>+[^\S\n])/mg, '\r'),
       some(union([
         // quote補助関数が残した数式をパースする。
@@ -20,9 +22,9 @@ export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(
         linebreak,
         unescsource,
       ])),
-      false), -1)),
-  (ns: [string, ...(string | HTMLElement)[]]) => [
-    html('span', { class: 'quote' }, defrag(ns)),
-    html('br'),
-  ]),
+      false)),
+  (ns, { source, position }) => new List([
+    new Data(source[position - 1] === '\n' ? ns.pop()!.value as HTMLBRElement : html('br')),
+    new Data(html('span', { class: 'quote' }, defrag(unwrap(ns)))),
+  ].reverse())),
   false));

package/src/parser/block/reply.ts

@@ -1,11 +1,12 @@
 import { ReplyParser } from '../block';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, block, validate, rewrite, fmap } from '../../combinator';
 import { cite, syntax as csyntax } from './reply/cite';
 import { quote, syntax as qsyntax } from './reply/quote';
 import { inline } from '../inline';
 import { anyline } from '../source';
-import { linearize } from '../util';
 import { visualize, trimBlankNodeEnd } from '../visibility';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const delimiter = new RegExp(`${csyntax.source}|${qsyntax.source}`, 'y');
@@ -16,6 +17,9 @@ export const reply: ReplyParser = block(validate(csyntax, fmap(
     quote,
     rewrite(
       some(anyline, delimiter),
-      visualize(linearize(some(inline), 1))),
+      visualize(fmap(some(inline), (ns, { source, position }) =>
+        source[position - 1] === '\n'
+          ? ns
+          : ns.push(new Data(html('br'))) && ns)))
   ])),
-  ns => [html('p', trimBlankNodeEnd(defrag(ns)))])));
+  ns => new List([new Data(html('p', defrag(unwrap(trimBlankNodeEnd(ns)))))]))));

package/src/parser/block/sidefence.ts

@@ -1,20 +1,21 @@
 import { SidefenceParser } from '../block';
 import { Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, block, focus, rewrite, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
-import { invalid } from '../util';
+import { unwrap, invalid } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
 export const sidefence: SidefenceParser = lazy(() => block(fmap(focus(
   /(?=\|+(?:[^\S\n]|\n\|))(?:\|+(?:[^\S\n][^\n]*)?(?:$|\n))+$/y,
   union([source])),
-  ([el]) => [
-    define(el, {
+  ([{ value }]) => new List([
+    new Data(define(value, {
       class: 'invalid',
       ...invalid('sidefence', 'syntax', 'Reserved syntax'),
-    }),
-  ])));
+    })),
+  ]))));
 
 const opener = /(?=\|\|+(?:$|\s))/y;
 const unindent = (source: string) => source.replace(/(?<=^|\n)\|(?:[^\S\n]|(?=\|*(?:$|\s)))|\n$/g, '');
@@ -26,6 +27,6 @@ const source: SidefenceParser.SourceParser = lazy(() => fmap(
       convert(unindent, source, false, true)),
     rewrite(
       some(contentline, opener),
-      convert(unindent, fmap(autolink, ns => [html('pre', defrag(ns))]), false, true)),
+      convert(unindent, fmap(autolink, ns => new List([new Data(html('pre', defrag(unwrap(ns))))])), false, true)),
   ]))),
-  ns => [html('blockquote', ns)]));
+  ns => new List([new Data(html('blockquote', unwrap(ns)))])));

package/src/parser/block/table.ts

@@ -1,9 +1,10 @@
 import { TableParser } from '../block';
+import { List, Data } from '../../combinator/data/parser';
 import { union, sequence, some, block, line, validate, focus, rewrite, surround, open, close, fallback, lazy, fmap } from '../../combinator';
 import { inline, media, medialink, shortmedia } from '../inline';
 import { contentline } from '../source';
 import { trimBlank } from '../visibility';
-import { invalid } from '../util';
+import { unwrap, invalid } from '../util';
 import { duffReduce } from 'spica/duff';
 import { push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
@@ -19,32 +20,32 @@ export const table: TableParser = lazy(() => block(fmap(validate(
     row(some(align), false),
     some(row(some(data), true)),
   ])),
-  rows => [
-    html('table', [
-      html('thead', [rows.shift()!]),
-      html('tbody', format(rows)),
-    ]),
-  ])));
+  rows => new List([
+    new Data(html('table', [
+      html('thead', [rows.shift()!.value]),
+      html('tbody', unwrap(format(rows))),
+    ])),
+  ]))));
 
 const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => fallback(fmap(
   line(surround(/(?=\|)/y, some(union([parser])), /[|\\]?\s*$/y, optional)),
-  es => [html('tr', es)]),
-  rewrite(contentline, ({ context: { source } }) => [[
-    html('tr', {
+  ns => new List([new Data(html('tr', unwrap(ns)))])),
+  rewrite(contentline, ({ context: { source } }) => new List([
+    new Data(html('tr', {
       class: 'invalid',
       ...invalid('table-row', 'syntax', 'Missing the start symbol of the table row'),
-    }, [html('td', source.replace('\n', ''))])
-  ]]));
+    }, [html('td', source.replace('\n', ''))]))
+  ])));
 
 const align: AlignParser = fmap(open(
   '|',
   union([
     focus(/:-+:?/y, ({ context: { source } }) =>
-      [[source.at(-1) === ':' ? 'center' : 'start']]),
+      new List([new Data(source.at(-1) === ':' ? 'center' : 'start')])),
     focus(/-+:?/y, ({ context: { source } }) =>
-      [[source.at(-1) === ':' ? 'end' : '']]),
+      new List([new Data(source.at(-1) === ':' ? 'end' : '')])),
   ])),
-  ns => [html('td', defrag(ns))]);
+  ns => new List([new Data(html('td', defrag(unwrap(ns))))]));
 
 const cell: CellParser = surround(
   /\|\s*(?=\S)/y,
@@ -58,18 +59,18 @@ const cell: CellParser = surround(
 
 const head: CellParser.HeadParser = fmap(
   cell,
-  ns => [html('th', defrag(ns))]);
+  ns => new List([new Data(html('th', defrag(unwrap(ns))))]));
 
 const data: CellParser.DataParser = fmap(
   cell,
-  ns => [html('td', defrag(ns))]);
+  ns => new List([new Data(html('td', defrag(unwrap(ns))))]));
 
-function format(rows: HTMLTableRowElement[]): HTMLTableRowElement[] {
-  const aligns = rows[0].className === 'invalid'
+function format(rows: List<Data<HTMLTableRowElement>>): List<Data<HTMLTableRowElement>> {
+  const aligns = rows.head!.value.className === 'invalid'
     ? []
-    : duffReduce(rows.shift()!.children, (acc, el) => push(acc, [el.textContent!]), [] as string[]);
-  for (let i = 0; i < rows.length; ++i) {
-    for (let cols = rows[i].children, len = cols.length, j = 0; j < len; ++j) {
+    : duffReduce(rows.shift()!.value.children, (acc, el) => push(acc, [el.textContent!]), [] as string[]);
+  for (const { value: row } of rows) {
+    for (let cols = row.children, len = cols.length, j = 0; j < len; ++j) {
       if (j > 0 && !aligns[j]) {
         aligns[j] = aligns[j - 1];
       }

package/src/parser/block/ulist.ts

@@ -1,11 +1,12 @@
 import { UListParser } from '../block';
 import { Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, inits, subsequence, some, recursion, block, line, validate, indent, focus, open, fallback, lazy, fmap } from '../../combinator';
 import { olist_ } from './olist';
 import { ilist_, ilistitem } from './ilist';
 import { inline, indexer, indexee, dataindex } from '../inline';
 import { visualize, trimBlank } from '../visibility';
-import { unshift } from 'spica/array';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const ulist: UListParser = lazy(() => block(validate(
@@ -24,22 +25,25 @@ export const ulist_: UListParser = lazy(() => block(fmap(validate(
         indent(union([ulist_, olist_, ilist_])),
       ]),
       ilistitem),
-      ns => [html('li', { 'data-index': dataindex(ns) }, defrag(fillFirstLine(ns)))])),
+      ns => new List([new Data(html('li', { 'data-index': dataindex(ns) }, defrag(unwrap(fillFirstLine(ns)))))]))),
   ])))),
-  es => [format(html('ul', es))])));
+  ns => new List([new Data(format(html('ul', unwrap(ns))))]))));
 
 export const checkbox = focus(
   /\[[xX ]\](?=$|[ \n])/y,
-  ({ context: { source } }) => [[
-    html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐'),
-  ]]);
+  ({ context: { source } }) => new List([
+    new Data(html('span', { class: 'checkbox' }, source[1].trimStart() ? '☑' : '☐')),
+  ]));
 
-export function fillFirstLine(ns: (HTMLElement | string)[]): (HTMLElement | string)[] {
-  return ns.length === 1
-      && typeof ns[0] === 'object'
-      && ['UL', 'OL'].includes(ns[0].tagName)
-    ? unshift([html('br')], ns)
-    : ns;
+export function fillFirstLine(nodes: List<Data<string | HTMLElement>>): List<Data<string | HTMLElement>> {
+  const node = nodes.head?.value;
+  if (typeof node !== 'object') return nodes;
+  switch (node.tagName) {
+    case 'UL':
+    case 'OL':
+      nodes.unshift(new Data(html('br')));
+  }
+  return nodes;
 }
 
 function format(list: HTMLUListElement): HTMLUListElement {

package/src/parser/block.ts

@@ -1,5 +1,6 @@
 import { MarkdownParser } from '../../markdown';
 import { Recursion, Command } from './context';
+import { List, Data } from '../combinator/data/parser';
 import { union, reset, open, fallback, recover } from '../combinator';
 import { MAX_SEGMENT_SIZE } from './segment';
 import { emptyline } from './source';
@@ -113,16 +114,16 @@ function error(parser: BlockParser): BlockParser {
   return recover<BlockParser>(fallback(
     open(Command.Error, ({ context: { source, position } }) => { throw new Error(source.slice(position).split('\n', 1)[0]); }),
     parser),
-    ({ context: { source, position, id } }, reason) => [[
-      html('h1',
+    ({ context: { source, position, id } }, reason) => new List([
+      new Data(html('h1',
         {
           id: id !== '' ? `error:${rnd0Z(8)}` : undefined,
           class: 'error',
         },
         reason instanceof Error
           ? `${reason.name}: ${reason.message}`
-          : `UnknownError: ${reason}`),
-      html('pre',
+          : `UnknownError: ${reason}`)),
+      new Data(html('pre',
         {
           class: 'error',
           translate: 'no',
@@ -130,6 +131,6 @@ function error(parser: BlockParser): BlockParser {
         source.slice(position)
           .replace(reg, '')
           .slice(0, 1001)
-          .replace(/^(.{997}).{4}$/s, '$1...') || undefined),
-    ]]);
+          .replace(/^(.{997}).{4}$/s, '$1...') || undefined)),
+    ]));
 }

package/src/parser/header.test.ts

@@ -21,7 +21,8 @@ describe('Unit: parser/header', () => {
       assert.deepStrictEqual(inspect(parser('---\n\n---'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('---\n \n---'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('---\n-\n---'), ctx), [['<pre class="invalid" translate="no">---\n-\n---</pre>'], '']);
-      assert.deepStrictEqual(inspect(parser('----\na: b\n----'), ctx), [['<pre class="invalid" translate="no">----\na: b\n----</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('---\na: b\n----'), ctx), [['<pre class="invalid" translate="no">---\na: b\n----</pre>'], '']);
+      assert.deepStrictEqual(inspect(parser('----\na: b\n---'), ctx), [['<pre class="invalid" translate="no">----\na: b\n---</pre>'], '']);
       assert.deepStrictEqual(inspect(parser(`---\n${'a: b\n'.repeat(101)}---`), ctx), [[`<pre class="invalid" translate="no">---\n${'a: b\n'.repeat(101)}---</pre>`], '']);
     });
 
@@ -30,6 +31,7 @@ describe('Unit: parser/header', () => {
       assert.deepStrictEqual(inspect(parser('---\na: b\n---\n'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
       assert.deepStrictEqual(inspect(parser('---\na: b\nC: D e\n---\n'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span><span class="field" data-name="c" data-value="D e"><span class="field-name">C</span>: <span class="field-value">D e</span>\n</span></details></aside>'], '']);
       assert.deepStrictEqual(inspect(parser('--- \r\na: b \r\n--- \r\n \r\n \r\na'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], ' \r\na']);
+      assert.deepStrictEqual(inspect(parser('----\na: b\n----'), ctx), [['<aside class="header"><details open=""><summary>Header</summary><span class="field" data-name="a" data-value="b"><span class="field-name">a</span>: <span class="field-value">b</span>\n</span></details></aside>'], '']);
     });
 
   });