securemark 0.293.5 → 0.294.1

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';
@@ -60,6 +61,10 @@ export const block: BlockParser = reset(
       if (position === source.length) return;
       const fst = source[position];
       switch (fst) {
+        case '\n':
+          assert(source.trim() === '');
+          input.context.position = source.length;
+          return new List();
         case '=':
           if (source.startsWith('===', position)) return pagebreak(input);
           break;
@@ -113,16 +118,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 +135,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)]),
   ]));

package/src/parser/inline/autolink/hashnum.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 { emoji } from './hashtag';
@@ -21,6 +22,6 @@ export const hashnum: AutolinkParser.HashnumParser = lazy(() => rewrite(
       source => `[${source}]{ ${source.slice(1)} }`,
       unsafelink,
       false),
-      ([el]) => [define(el, { class: 'hashnum', href: null })]))),
-    ({ context: { source } }) => [[source]],
+      ([{ value }]) => new List([new Data(define(value, { class: 'hashnum', href: null }))])))),
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));

package/src/parser/inline/autolink/hashtag.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, convert, fmap, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { str } from '../../source';
@@ -19,7 +20,7 @@ export const hashtag: AutolinkParser.HashtagParser = 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]),
   union([
@@ -27,6 +28,6 @@ export const hashtag: AutolinkParser.HashtagParser = lazy(() => rewrite(
       source => `[${source}]{ ${`/hashtags/${source.slice(1)}`} }`,
       unsafelink,
       false),
-      ([el]) => [define(el, { class: 'hashtag' })]))),
-    ({ context: { source } }) => [[source]],
+      ([{ value }]) => new List([new Data(define(value, { class: 'hashtag' }))])))),
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));

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

@@ -1,5 +1,6 @@
 import { AutolinkParser } from '../../inline';
 import { State, Recursion, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, tails, some, recursion, precedence, state, constraint, verify, focus, rewrite, convert, surround, open, lazy } from '../../../combinator';
 import { unsafelink } from '../link';
 import { unescsource, str } from '../../source';
@@ -18,7 +19,7 @@ export const url: AutolinkParser.UrlParser = lazy(() => rewrite(
       url => `{ ${url} }`,
       unsafelink,
       false))),
-    ({ context: { source } }) => [[source]],
+    ({ context: { source } }) => new List([new Data(source)]),
   ])));
 
 export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => focus(
@@ -30,17 +31,17 @@ export const lineurl: AutolinkParser.UrlParser.LineUrlParser = lazy(() => focus(
         url => `{ ${url} }`,
         unsafelink,
         false))),
-      ({ context: { source } }) => [[source]],
+      ({ context: { source } }) => new List([new Data(source)]),
     ]),
   ])));
 
 const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => union([
   surround(str('('), recursion(Recursion.terminal, some(union([bracket, unescsource]), ')')), str(')'), true,
-    undefined, () => [[]], [3 | Backtrack.autolink]),
+    undefined, () => new List(), [3 | Backtrack.autolink]),
   surround(str('['), recursion(Recursion.terminal, some(union([bracket, unescsource]), ']')), str(']'), true,
-    undefined, () => [[]], [3 | Backtrack.autolink]),
+    undefined, () => new List(), [3 | Backtrack.autolink]),
   surround(str('{'), recursion(Recursion.terminal, some(union([bracket, unescsource]), '}')), str('}'), true,
-    undefined, () => [[]], [3 | Backtrack.autolink]),
+    undefined, () => new List(), [3 | Backtrack.autolink]),
   surround(str('"'), precedence(2, recursion(Recursion.terminal, some(unescsource, '"'))), str('"'), true,
-    undefined, () => [[]], [3 | Backtrack.autolink]),
+    undefined, () => new List(), [3 | Backtrack.autolink]),
 ]));

package/src/parser/inline/bracket.ts

@@ -1,10 +1,11 @@
 import { BracketParser } from '../inline';
 import { State, Recursion, Backtrack } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
-import { unshift, push } from 'spica/array';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const indexA = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*$/;
@@ -38,13 +39,13 @@ const p1 = lazy(() => surround(
   precedence(1, recursion(Recursion.bracket, some(inline, ')', [[')', 1]]))),
   str(')'),
   true,
-  ([as, bs = [], cs], { source, position, range = 0 }) => {
+  ([as, bs = new List(), cs], { source, position, range = 0 }) => {
     const str = source.slice(position - range + 1, position - 1);
     return indexA.test(str)
-      ? [[as[0], str, cs[0]]]
-      : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
+      ? new List([new Data(as.head!.value), new Data(str), new Data(cs.head!.value)])
+      : new List([new Data(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))))]);
   },
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const p2 = lazy(() => surround(
@@ -55,10 +56,10 @@ const p2 = lazy(() => surround(
   ([as, bs = [], cs], { source, position, range = 0 }) => {
     const str = source.slice(position - range + 1, position - 1);
     return indexF.test(str)
-      ? [[as[0], str, cs[0]]]
-      : [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))]];
+      ? new List([new Data(as.head!.value), new Data(str), new Data(cs.head!.value)])
+      : new List([new Data(html('span', { class: 'paren' }, defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))))]);
   },
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const s1 = lazy(() => surround(
@@ -66,7 +67,7 @@ const s1 = lazy(() => surround(
   precedence(1, recursion(Recursion.bracket, some(inline, ']', [[']', 1]]))),
   str(']'),
   true,
-  ([as, bs = [], cs], context) => {
+  ([as, bs = new List(), cs], context) => {
     if (context.state! & State.link) {
       const { source, position, range = 0 } = context;
       const head = position - range;
@@ -86,9 +87,9 @@ const s1 = lazy(() => surround(
         context.range = range;
       }
     }
-    return [push(unshift(as, bs), cs)];
+    return as.import(bs as List<Data<string>>).import(cs);
   },
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const s2 = lazy(() => surround(
@@ -97,7 +98,7 @@ const s2 = lazy(() => surround(
   str('］'),
   true,
   undefined,
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const c1 = lazy(() => surround(
@@ -106,7 +107,7 @@ const c1 = lazy(() => surround(
   str('}'),
   true,
   undefined,
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const c2 = lazy(() => surround(
@@ -115,7 +116,7 @@ const c2 = lazy(() => surround(
   str('｝'),
   true,
   undefined,
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));
 
 const d1 = lazy(() => surround(
@@ -125,5 +126,5 @@ const d1 = lazy(() => surround(
   str('"'),
   true,
   undefined,
-  ([as, bs = []]) => [unshift(as, bs)],
+  ([as, bs = new List()]) => as.import(bs as List<Data<string>>),
   [2 | Backtrack.bracket]));

package/src/parser/inline/code.ts

@@ -1,4 +1,5 @@
 import { CodeParser } from '../inline';
+import { List, Data } from '../../combinator/data/parser';
 import { open, match } from '../../combinator';
 import { Backtrack } from '../context';
 import { invalid } from '../util';
@@ -10,13 +11,13 @@ export const code: CodeParser = open(
     /(`+)(?!`)([^\n]*?)(?:((?<!`)\1(?!`))|(?=$|\n))/y,
     ([whole, opener, body, closer]) => () =>
       closer
-        ? [[html('code', { 'data-src': whole }, format(body))]]
+        ? new List([new Data(html('code', { 'data-src': whole }, format(body)))])
         : body
-          ? [[html('code', {
+          ? new List([new Data(html('code', {
               class: 'invalid',
               ...invalid('code', 'syntax', `Missing the closing symbol "${opener}"`)
-            }, whole)]]
-          : [[opener]],
+            }, whole))])
+          : new List([new Data(opener)]),
     true),
   false,
   [3 | Backtrack.bracket]);

package/src/parser/inline/deletion.ts

@@ -1,10 +1,10 @@
 import { DeletionParser } from '../inline';
 import { Recursion, Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, validate, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { blankWith } from '../visibility';
-import { repeat } from '../util';
-import { push } from 'spica/array';
+import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const deletion: DeletionParser = lazy(() => validate('~~',
@@ -16,6 +16,6 @@ export const deletion: DeletionParser = lazy(() => validate('~~',
       open('\n', some(inline, '~'), true),
     ]))),
     '~~', false,
-    ([, bs], { buffer }) => [push(buffer!, bs)],
-    ([, bs], { buffer }) => bs && [push(push(buffer!, bs), [Command.Cancel])]),
-    nodes => [html('del', defrag(nodes))]))));
+    ([, bs], { buffer }) => buffer!.import(bs),
+    ([, bs], { buffer }) => bs && buffer!.import(bs).push(new Data(Command.Cancel)) && buffer!),
+    nodes => new List([new Data(html('del', defrag(unwrap(nodes))))])))));

package/src/parser/inline/emphasis.ts

@@ -1,11 +1,12 @@
 import { EmphasisParser } from '../inline';
 import { Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { str } from '../source';
 import { tightStart, blankWith } from '../visibility';
-import { unshift } from 'spica/array';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const emphasis: EmphasisParser = lazy(() => surround(
@@ -17,5 +18,5 @@ export const emphasis: EmphasisParser = lazy(() => surround(
     open(some(inline, '*'), inline),
   ]))))),
   str('*'), false,
-  ([, bs]) => [[html('em', defrag(bs))]],
-  ([as, bs]) => bs && [unshift(as, bs)]));
+  ([, bs]) => new List([new Data(html('em', defrag(unwrap(bs))))]),
+  ([as, bs]) => bs && as.import(bs as List<Data<string>>)));