securemark 0.293.5 → 0.294.0

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

package/src/parser/inline/emstrong.test.ts

@@ -10,12 +10,12 @@ describe('Unit: parser/inline/emstrong', () => {
 
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('***'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('***a'), ctx), [['***', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('***a ***'), ctx), [['***', 'a', ' ', '***'], '']);
-      assert.deepStrictEqual(inspect(parser('***a  ***'), ctx), [['***', 'a', ' ', '***'], '']);
-      assert.deepStrictEqual(inspect(parser('***a\n***'), ctx), [['***', 'a', '<br>', '***'], '']);
-      assert.deepStrictEqual(inspect(parser('***a\\ ***'), ctx), [['***', 'a', ' ', '***'], '']);
-      assert.deepStrictEqual(inspect(parser('***a\\\n***'), ctx), [['***', 'a', '<br>', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a'), ctx), [['***a'], '']);
+      assert.deepStrictEqual(inspect(parser('***a ***'), ctx), [['***a', ' ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a  ***'), ctx), [['***a', ' ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a\n***'), ctx), [['***a', '<br>', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a\\ ***'), ctx), [['***a', ' ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('***a\\\n***'), ctx), [['***a', '<br>', '***'], '']);
       assert.deepStrictEqual(inspect(parser('*** ***'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('*** a***'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('*** a ***'), ctx), undefined);
@@ -43,7 +43,7 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('***a*'), ctx), [['**', '<em>a</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b'), ctx), [['**', '<em>a</em>', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b*'), ctx), [['**', '<em>a</em>', 'b'], '*']);
-      assert.deepStrictEqual(inspect(parser('***a*b*c'), ctx), [['**', '<em>a</em>', 'b*c'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*b*c'), ctx), [['**', '<em>a</em>', 'b', '*', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b*c*'), ctx), [['**', '<em>a</em>', 'b', '<em>c</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*b*c**'), ctx), [['**', '<em>a</em>', 'b', '<em>c</em>'], '*']);
       assert.deepStrictEqual(inspect(parser('***a*b*c***'), ctx), [['<strong><em>a</em>b<em>c</em></strong>'], '']);
@@ -53,7 +53,7 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('***a**b'), ctx), [['*', '<strong>a</strong>', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*'), ctx), [['<em><strong>a</strong>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b**'), ctx), [['<em><strong>a</strong>b</em>'], '*']);
-      assert.deepStrictEqual(inspect(parser('***a**b**c'), ctx), [['*', '<strong>a</strong>', 'b**c'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**b**c'), ctx), [['*', '<strong>a</strong>', 'b', '**', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b**c*'), ctx), [['<em><strong>a</strong>b**c</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b**c**'), ctx), [['*', '<strong>a</strong>', 'b', '<strong>c</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b**c***'), ctx), [['<em><strong>a</strong>b<strong>c</strong></em>'], '']);
@@ -66,8 +66,8 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('***a*\\ **b****'), ctx), [['<strong><em>a</em> <strong>b</strong></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*&Tab;**b****'), ctx), [['<strong><em>a</em>\t<strong>b</strong></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a*<wbr>**b****'), ctx), [['<strong><em>a</em><wbr><strong>b</strong></strong>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a*b **'), ctx), [['**', '<em>a</em>', 'b **'], '']);
-      assert.deepStrictEqual(inspect(parser('***a*b\\ **'), ctx), [['**', '<em>a</em>', 'b **'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*b **'), ctx), [['**', '<em>a</em>', 'b', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser('***a*b\\ **'), ctx), [['**', '<em>a</em>', 'b', ' ', '**'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*'), ctx), [['<em><strong>a</strong>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**b*c'), ctx), [['<em><strong>a</strong>b</em>'], 'c']);
       assert.deepStrictEqual(inspect(parser('***a**b*c**'), ctx), [['<em><strong>a</strong>b</em>'], 'c**']);
@@ -77,8 +77,8 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('***a**\\ *b**'), ctx), [['<em><strong>a</strong> <em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**&Tab;*b**'), ctx), [['<em><strong>a</strong>\t<em>b</em></em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**<wbr>*b**'), ctx), [['<em><strong>a</strong><wbr><em>b</em></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('***a**b *'), ctx), [['*', '<strong>a</strong>', 'b *'], '']);
-      assert.deepStrictEqual(inspect(parser('***a**b\\ *'), ctx), [['*', '<strong>a</strong>', 'b *'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**b *'), ctx), [['*', '<strong>a</strong>', 'b', ' ', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('***a**b\\ *'), ctx), [['*', '<strong>a</strong>', 'b', ' ', '*'], '']);
       assert.deepStrictEqual(inspect(parser('***a*'), ctx), [['**', '<em>a</em>'], '']);
       assert.deepStrictEqual(inspect(parser('***a**'), ctx), [['*', '<strong>a</strong>'], '']);
       assert.deepStrictEqual(inspect(parser('***a***'), ctx), [['<em><strong>a</strong></em>'], '']);
@@ -108,12 +108,12 @@ describe('Unit: parser/inline/emstrong', () => {
       assert.deepStrictEqual(inspect(parser('******a*****b*'), ctx), [['<em><strong><em><strong>a</strong></em></strong>b</em>'], '']);
       assert.deepStrictEqual(inspect(parser('******a******'), ctx), [['<em><strong><em><strong>a</strong></em></strong></em>'], '']);
       assert.deepStrictEqual(inspect(parser('******a******b'), ctx), [['<em><strong><em><strong>a</strong></em></strong></em>'], 'b']);
-      assert.deepStrictEqual(inspect(parser('******a*b'), ctx), [['***', '**', '<em>a</em>', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b *'), ctx), [['***', '**', '<em>a</em>', 'b *'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b **'), ctx), [['***', '**', '<em>a</em>', 'b **'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b ***'), ctx), [['***', '**', '<em>a</em>', 'b ***'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b ****'), ctx), [['***', '**', '<em>a</em>', 'b ****'], '']);
-      assert.deepStrictEqual(inspect(parser('******a*b *****'), ctx), [['***', '**', '<em>a</em>', 'b *****'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b'), ctx), [['*****', '<em>a</em>', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b *'), ctx), [['*****', '<em>a</em>', 'b', ' ', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b **'), ctx), [['*****', '<em>a</em>', 'b', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b ***'), ctx), [['*****', '<em>a</em>', 'b', ' ', '***'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b ****'), ctx), [['*****', '<em>a</em>', 'b', ' ', '****'], '']);
+      assert.deepStrictEqual(inspect(parser('******a*b *****'), ctx), [['*****', '<em>a</em>', 'b', ' ', '*****'], '']);
     });
 
   });

package/src/parser/inline/emstrong.ts

@@ -1,14 +1,13 @@
 import { EmStrongParser, EmphasisParser, StrongParser } from '../inline';
 import { Recursion, Command } from '../context';
-import { Result, Node, Context, IntermediateParser } from '../../combinator/data/parser';
+import { Result, List, Data, Node, Context, IntermediateParser, eval } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, validate, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
 import { str } from '../source';
 import { tightStart, blankWith } from '../visibility';
-import { repeat } from '../util';
-import { unshift, push } from 'spica/array';
+import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const substrong: IntermediateParser<StrongParser> = lazy(() => some(union([
@@ -36,10 +35,10 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
     str(/\*{1,3}/y), false,
     ([, bs, cs], context): Result<Node<EmStrongParser>, Context<EmStrongParser>> => {
       assert(cs.length === 1);
-      const { buffer } = context;
-      switch (cs[0]) {
+      const { buffer = new List() } = context;
+      switch (cs.head!.value) {
         case '***':
-          return [bs];
+          return bs;
         case '**':
           return bind<EmphasisParser>(
             subemphasis,
@@ -47,13 +46,18 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
               const { source } = context;
               if (source.startsWith('*', context.position)) {
                 context.position += 1;
-                return [[html('em', push(push(buffer!, [html('strong', defrag(bs))]), defrag(ds))), Command.Separator]];
+                buffer.push(new Data(html('strong', defrag(unwrap(bs)))));
+                buffer.import(ds);
+                return new List([new Data(html('em', defrag(unwrap(buffer)))), new Data(Command.Separator)]);
               }
               else {
-                return [prepend('*', push(push(push(buffer!, [html('strong', defrag(bs))]), defrag(ds)), [Command.Separator]))];
+                buffer.push(new Data(html('strong', defrag(unwrap(bs)))));
+                buffer.import(ds);
+                buffer.push(new Data(Command.Separator));
+                return prepend('*', buffer);
               }
             })
-            ({ context }) ?? [prepend('*', push(push(buffer!, [html('strong', defrag(bs))]), [Command.Separator]))];
+            ({ context }) ?? prepend('*', buffer.import(new List([new Data(html('strong', defrag(unwrap(bs)))), new Data(Command.Separator)])));
         case '*':
           return bind<StrongParser>(
             substrong,
@@ -61,19 +65,24 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
               const { source } = context;
               if (source.startsWith('**', context.position)) {
                 context.position += 2;
-                return [[html('strong', push(push(buffer!, [html('em', defrag(bs))]), defrag(ds))), Command.Separator]];
+                buffer.push(new Data(html('em', defrag(unwrap(bs)))));
+                buffer.import(ds);
+                return new List([new Data(html('strong', defrag(unwrap(buffer)))), new Data(Command.Separator)]);
               }
               else {
-                return [prepend('**', push(push(push(buffer!, [html('em', defrag(bs))]), defrag(ds)), [Command.Separator]))];
+                buffer.push(new Data(html('em', defrag(unwrap(bs)))));
+                buffer.import(ds);
+                buffer.push(new Data(Command.Separator));
+                return prepend('**', buffer);
               }
             })
-            ({ context }) ?? [prepend('**', push(push(buffer!, [html('em', defrag(bs))]), [Command.Separator]))];
+            ({ context }) ?? prepend('**', buffer.import(new List([new Data(html('em', defrag(unwrap(bs)))), new Data(Command.Separator)])));
       }
       assert(false);
     },
-    ([, bs], { buffer }) => bs && [push(push(buffer!, bs), [Command.Cancel])]),
+    ([, bs], { buffer }) => bs && buffer!.import(bs) && buffer!.push(new Data(Command.Cancel)) && buffer!),
     // 3以上の`*`に対してemの適用を保証する
-    nodes => [html('em', [html('strong', defrag(nodes))])],
+    nodes => new List([new Data(html('em', [html('strong', defrag(unwrap(nodes)))]))]),
     (nodes, context, prefix, postfix, state) => {
       context.position += postfix;
       assert(postfix < 3);
@@ -82,10 +91,10 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
           case 0:
             break;
           case 1:
-            nodes = [html('em', defrag(nodes))];
+            nodes = new List([new Data(html('em', defrag(unwrap(nodes))))]);
             break;
           case 2:
-            nodes = [html('strong', defrag(nodes))];
+            nodes = new List([new Data(html('strong', defrag(unwrap(nodes))))]);
             break;
           default:
             assert(false);
@@ -96,51 +105,51 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
           case 0:
             break;
           case 1:
-            nodes = bind<EmphasisParser>(
+            nodes = eval(bind<EmphasisParser>(
               subemphasis,
               ds => {
                 const { source } = context;
                 if (source.startsWith('*', context.position)) {
                   context.position += 1;
-                  return [[html('em', push(nodes, defrag(ds)))]];
+                  return new List([new Data(html('em', defrag(unwrap(nodes.import(ds)))))]);
                 }
                 else {
-                  return [prepend('*', push(nodes, defrag(ds)))];
+                  return prepend('*', nodes.import(ds));
                 }
               })
-              ({ context })?.[0] ?? prepend('*', nodes);
+              ({ context })) ?? prepend('*', nodes);
             prefix -= 1;
             break;
           case 2:
-            nodes = bind<StrongParser>(
+            nodes = eval(bind<StrongParser>(
               substrong,
               ds => {
                 const { source } = context;
                 if (source.startsWith('**', context.position)) {
                   context.position += 2;
-                  return [[html('strong', push(nodes, defrag(ds)))]];
+                  return new List([new Data(html('strong', defrag(unwrap(nodes.import(ds)))))]);
                 }
                 else {
-                  return [prepend('**', push(nodes, defrag(ds)))];
+                  return prepend('**', nodes.import(ds));
                 }
               })
-              ({ context })?.[0] ?? prepend('**', nodes);
+              ({ context })) ?? prepend('**', nodes);
             prefix -= 2;
             break;
         }
       }
       if (prefix > postfix) {
-        nodes = push(['*'.repeat(prefix - postfix)], nodes);
+        nodes = prepend('*'.repeat(prefix - postfix), nodes);
       }
-      return [nodes];
+      return nodes;
     }))));
 
-function prepend<N>(prefix: string, nodes: N[]): N[] {
-  if (typeof nodes[0] === 'string') {
-    nodes[0] = prefix + nodes[0] as N;
+function prepend<N>(prefix: string, nodes: List<Data<N>>): List<Data<N>> {
+  if (typeof nodes.head?.value === 'string') {
+    nodes.head.value = prefix + nodes.head.value as N;
   }
   else {
-    unshift([prefix], nodes);
+    nodes.unshift(new Data(prefix as N));
   }
   return nodes;
 }

package/src/parser/inline/extension/index.ts

@@ -1,12 +1,13 @@
 import { ExtensionParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, inits, some, precedence, state, constraint, validate, surround, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { unsafehtmlentity } from '../htmlentity';
 import { txt, str } from '../../source';
 import { tightStart, trimBlankNodeEnd } from '../../visibility';
-import { unshift } from 'spica/array';
+import { unwrap } from '../../util';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
@@ -23,23 +24,23 @@ export const index: IndexParser = lazy(() => constraint(State.index, fmap(indexe
   false,
   ([, bs], context) =>
     context.linebreak === 0 && trimBlankNodeEnd(bs).length > 0
-      ? [[html('a', { 'data-index': dataindex(bs) }, defrag(bs))]]
+      ? new List([new Data(html('a', { 'data-index': dataindex(bs) }, defrag(unwrap(bs))))])
       : undefined,
   undefined,
   [3 | Backtrack.bracket])),
   ns => {
     if (ns.length === 1) {
-      const el = ns[0] as HTMLElement;
-      return [
-        define(el, {
+      const el = ns.head!.value as HTMLElement;
+      return new List([
+        new Data(define(el, {
           id: el.id ? null : undefined,
           class: 'index',
           href: el.id ? `#${el.id}` : undefined,
-        })
-      ];
+        }))
+      ]);
     }
     else {
-      assert(ns.at(-1) === '');
+      assert(ns.last?.value === '');
       ns.pop();
       return ns;
     }
@@ -54,21 +55,23 @@ export const signature: IndexParser.SignatureParser = lazy(() => validate('|', s
   /(?=])/y,
   false,
   ([, ns], context) => {
-    const index = identity('index', undefined, ns.join(''))?.slice(7);
+    const index = identity('index', undefined, ns.foldl((acc, { value }) => acc + value, ''))?.slice(7);
     return index && context.linebreak === 0
-      ? [[html('span', { class: 'indexer', 'data-index': index })]]
+      ? new List([new Data(html('span', { class: 'indexer', 'data-index': index }))])
       : undefined;
   },
-  ([as, bs]) => bs && [unshift(as, bs)],
+  ([as, bs]) => bs && as.import(bs),
   [3 | Backtrack.bracket])));
 
-export function dataindex(ns: readonly (string | HTMLElement)[]): string | undefined {
-  if (ns.length === 0) return;
-  for (let i = ns.length; i--;) {
-    const node = ns[i];
-    if (typeof node === 'string') return;
-    if (i === ns.length - 1 && ['UL', 'OL'].includes(node.tagName)) continue;
-    if (!node.classList.contains('indexer')) return;
-    return node.getAttribute('data-index') ?? undefined;
+export function dataindex(nodes: List<Data<string | HTMLElement>>): string | undefined {
+  let node = nodes.last;
+  if (typeof node?.value !== 'object') return;
+  switch (node.value.tagName) {
+    case 'UL':
+    case 'OL':
+      node = node.prev;
+      if (typeof node?.value !== 'object') return;
   }
+  if (!node.value.classList.contains('indexer')) return;
+  return node.value.getAttribute('data-index') ?? undefined;
 }

package/src/parser/inline/extension/indexee.ts

@@ -1,5 +1,5 @@
 import { MarkdownParser } from '../../../../markdown';
-import { Parser } from '../../../combinator/data/parser';
+import { Parser, List, Data } from '../../../combinator/data/parser';
 import { fmap } from '../../../combinator';
 import { define } from 'typed-dom/dom';
 
@@ -7,7 +7,7 @@ export function indexee<P extends Parser<unknown, MarkdownParser.Context>>(parse
 export function indexee(parser: Parser<HTMLElement, MarkdownParser.Context>): Parser<HTMLElement> {
   return fmap(parser, (ns, { id }) =>
     ns.length === 1
-      ? [define(ns[0], { id: identity('index', id, ns[0]), 'data-index': null })]
+      ? new List([new Data(define(ns.head!.value, { id: identity('index', id, ns.head!.value), 'data-index': null }))])
       : ns);
 }
 

package/src/parser/inline/extension/indexer.ts

@@ -1,4 +1,5 @@
 import { ExtensionParser } from '../../inline';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, focus, surround } from '../../../combinator';
 import { signature } from './index';
 import { html } from 'typed-dom/dom';
@@ -13,6 +14,6 @@ export const indexer: ExtensionParser.IndexerParser = surround(
   /\s\[(?=\|\S)/y,
   union([
     signature,
-    focus(/\|(?=\])/y, () => [[html('span', { class: 'indexer', 'data-index': '' })]]),
+    focus(/\|(?=\])/y, () => new List([new Data(html('span', { class: 'indexer', 'data-index': '' }))])),
   ]),
   /\]\s*$/y);