securemark 0.293.5 → 0.294.0

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)))])));

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.ts

@@ -1,8 +1,9 @@
 import { MarkdownParser } from '../../markdown';
+import { List, Data } from '../combinator/data/parser';
 import { union, inits, some, block, line, validate, focus, rewrite, clear, convert, lazy, fmap } from '../combinator';
 import { segment } from './segment';
 import { str } from './source';
-import { invalid } from './util';
+import { unwrap, invalid } from './util';
 import { normalize } from './api/normalize';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -18,7 +19,7 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
         else {
           context.position = source.length;
         }
-        return [[]];
+        return new List();
       },
       block(
         union([
@@ -28,24 +29,23 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
             normalize(source.slice(source.indexOf('\n') + 1, source.trimEnd().lastIndexOf('\n'))).replace(/(\S)\s+$/mg, '$1'),
             fmap(
               some(union([field])),
-              es => [
-                html('aside', { class: 'header' }, [
-                  html('details', { open: '' }, defrag([
-                    html('summary', 'Header'),
-                    ...es,
-                  ])),
-                ]),
-              ]), false))),
+              ns => new List([
+                new Data(html('aside', { class: 'header' }, [
+                  html('details',
+                    { open: '' },
+                    defrag(unwrap(ns.unshift(new Data(html('summary', 'Header'))) && ns))),
+                ])),
+              ])), false))),
           ({ context }) => {
             const { source, position } = context;
             context.position += source.length;
-            return [[
-              html('pre', {
+            return new List([
+              new Data(html('pre', {
                 class: 'invalid',
                 translate: 'no',
                 ...invalid('header', 'syntax', 'Invalid syntax'),
-              }, normalize(source.slice(position))),
-            ]];
+              }, normalize(source.slice(position)))),
+            ]);
           },
         ]))),
     clear(str(/[^\S\v\f\r\n]*\r?\n/y)),
@@ -54,12 +54,12 @@ export const header: MarkdownParser.HeaderParser = lazy(() => validate(
 const field: MarkdownParser.HeaderParser.FieldParser = line(({ context: { source, position } }) => {
   const name = source.slice(position, source.indexOf(':', position));
   const value = source.slice(position + name.length + 1).trim();
-  return [[
-    html('span', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
+  return new List([
+    new Data(html('span', { class: 'field', 'data-name': name.toLowerCase(), 'data-value': value }, [
       html('span', { class: 'field-name' }, name),
       ': ',
       html('span', { class: 'field-value' }, value),
       '\n',
-    ]),
-  ]];
+    ])),
+  ]);
 });

package/src/parser/inline/annotation.ts

@@ -1,8 +1,10 @@
 import { AnnotationParser } from '../inline';
 import { State, Backtrack } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, precedence, state, constraint, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const annotation: AnnotationParser = lazy(() => constraint(State.annotation, surround(
@@ -13,7 +15,7 @@ export const annotation: AnnotationParser = lazy(() => constraint(State.annotati
   false,
   ([, ns], context) =>
     context.linebreak === 0
-      ? [[html('sup', { class: 'annotation' }, [html('span', defrag(trimBlankNodeEnd(ns)))])]]
+      ? new List([new Data(html('sup', { class: 'annotation' }, [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))])
       : undefined,
   undefined,
   [1 | Backtrack.bracket, 3 | Backtrack.doublebracket])));

package/src/parser/inline/autolink/account.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, tails, state, constraint, rewrite, open, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { str } from '../../source';
@@ -26,6 +27,6 @@ export const account: AutolinkParser.AccountParser = lazy(() => rewrite(
         } }`,
       unsafelink,
       false),
-      ([el]) => [define(el, { class: 'account' })]))),
-    ({ context: { source } }) => [[source]],
+      ([{ value }]) => new List([new Data(define(value, { class: 'account' }))])))),
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));

package/src/parser/inline/autolink/anchor.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, state, constraint, rewrite, open, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { str } from '../../source';
@@ -30,6 +31,6 @@ export const anchor: AutolinkParser.AnchorParser = lazy(() => rewrite(
         } }`,
       unsafelink,
       false),
-      ([el]) => [define(el, { class: 'anchor' })]))),
-    ({ context: { source } }) => [[source]],
+      ([{ value }]) => new List([new Data(define(value, { class: 'anchor' }))])))),
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));

package/src/parser/inline/autolink/channel.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, tails, sequence, some, state, constraint, verify, rewrite, open, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { emoji } from './hashtag';
@@ -24,7 +25,7 @@ export const channel: AutolinkParser.ChannelParser = lazy(() => rewrite(
         str(new RegExp([
           /(?!['_])(?:[^\p{C}\p{S}\p{P}\s]|emoji|'(?=[0-9A-Za-z])|_(?=[^'\p{C}\p{S}\p{P}\s]|emoji))+(?![0-9a-z@]|>>|:\S|[^\p{C}\p{S}\p{P}\s]|emoji)/yu.source,
         ].join('').replace(/emoji/g, emoji), 'yu')),
-        ([source]) => !/^[0-9]{1,4}$|^[0-9]{5}/.test(source)),
+        ([{ value }]) => !/^[0-9]{1,4}$|^[0-9]{5}/.test(value)),
       false,
       [3 | Backtrack.autolink])),
   ]),
@@ -38,10 +39,10 @@ export const channel: AutolinkParser.ChannelParser = lazy(() => rewrite(
         } }`,
       unsafelink,
       false),
-      ([el], { source, position, range = 0 }) => {
+      ([{ value: el }], { source, position, range = 0 }) => {
         const src = source.slice(position - range, position);
         const url = `${el.getAttribute('href')}?ch=${src.slice(src.indexOf('#') + 1).replace(/#/g, '+')}`;
-        return [define(el, { class: 'channel', href: url }, src)];
+        return new List([new Data(define(el, { class: 'channel', href: url }, src))]);
       }))),
-    ({ context: { source } }) => [[source]],
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));

package/src/parser/inline/autolink/email.ts

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, state, constraint, verify, rewrite, open } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
@@ -10,11 +11,11 @@ export const email: AutolinkParser.EmailParser = rewrite(
   open(/(?<![0-9a-z][_.+-]?)(?=[0-9a-z])/yi,
     verify(
       str(/[0-9a-z](?:[_.+-](?=[0-9a-z])|[0-9a-z]){0,255}@[0-9a-z](?:(?:[0-9a-z]|-(?=[0-9a-z])){0,61}[0-9a-z])?(?:\.[0-9a-z](?:(?:[0-9a-z]|-(?=[0-9a-z])){0,61}[0-9a-z])?)*(?![0-9a-z@#]|>>|:\S)/yi),
-      ([source]) => source.length <= 255),
+      ([{ value }]) => value.length <= 255),
     false,
     [3 | Backtrack.autolink]),
   union([
     constraint(State.autolink, state(State.autolink,
-      ({ context: { source } }) => [[html('a', { class: 'email', href: `mailto:${source}` }, source)]])),
-    ({ context: { source } }) => [[source]],
+      ({ context: { source } }) => new List([new Data(html('a', { class: 'email', href: `mailto:${source}` }, source))]))),
+    ({ context: { source } }) => new List([new Data(source)]),
   ]));