securemark 0.293.5 → 0.294.1

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 } 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 (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', () => {

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,8 +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 { unwrap } from '../../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const syntax = />+[^\S\n]/y;
@@ -21,8 +23,8 @@ export const quote: ReplyParser.QuoteParser = lazy(() => block(fmap(
         unescsource,
       ])),
       false)),
-  (ns: [string, ...(string | HTMLElement)[]], { source, position }) => [
-    source[position - 1] === '\n' ? ns.pop() as HTMLBRElement : html('br'),
-    html('span', { class: 'quote' }, defrag(ns)),
-  ].reverse()),
+  (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 { visualize, trimBlankNodeEnd } from '../visibility';
-import { push } from 'spica/array';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const delimiter = new RegExp(`${csyntax.source}|${qsyntax.source}`, 'y');
@@ -17,6 +18,8 @@ export const reply: ReplyParser = block(validate(csyntax, fmap(
     rewrite(
       some(anyline, delimiter),
       visualize(fmap(some(inline), (ns, { source, position }) =>
-        source[position - 1] === '\n' ? ns : push(ns, [html('br')])))),
+        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)))])));