securemark 0.293.5 → 0.294.1

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 } 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);
@@ -102,13 +111,13 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
                 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:
@@ -118,29 +127,29 @@ export const emstrong: EmStrongParser = lazy(() => validate('***',
                 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);

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

@@ -1,5 +1,6 @@
 import { ExtensionParser } from '../../inline';
 import { State, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, constraint, clear, surround, fmap } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
@@ -16,9 +17,12 @@ export const label: ExtensionParser.LabelParser = constraint(State.label, fmap(
     surround('[', body, ']', false, undefined, undefined, [1 | Backtrack.bracket, 1]),
     body,
   ]),
-  ([text]) => [
-    html('a', { class: 'label', 'data-label': text.slice(text[1] === '-' ? 0 : 1).toLowerCase() }, text),
-  ]));
+  ([{ value }]) => new List([
+    new Data(html('a', {
+      class: 'label',
+      'data-label': value.slice(value[1] === '-' ? 0 : 1).toLowerCase(),
+    }, value)),
+  ])));
 
 export function number(label: string, base: string): string {
   return isFixed(label)

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

@@ -1,11 +1,11 @@
 import { ExtensionParser } from '../../inline';
 import { Recursion, Backtrack } from '../../context';
+import { List, Data } from '../../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
 import { tightStart } from '../../visibility';
 import { invalid } from '../../util';
-import { unshift } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
 // Don't use the symbols already used: !#$%@&*+~=|
@@ -18,13 +18,13 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => surroun
   precedence(1, recursion(Recursion.inline,
   tightStart(some(union([inline]), ']', [[']', 1]])))),
   str(']'), false,
-  (_, context) => [[
-    html('span',
+  (_, context) => new List([
+    new Data(html('span',
       {
         class: 'invalid',
         ...invalid('extension', 'syntax', `Invalid start symbol or linebreak`),
       },
-      context.source.slice(context.position - context.range!, context.position))
-  ]],
-  ([as, bs]) => bs && [unshift(as, bs)],
+      context.source.slice(context.position - context.range!, context.position)))
+  ]),
+  ([as, bs]) => bs && as.import(bs as List<Data<string>>),
   [3 | Backtrack.bracket]));

package/src/parser/inline/html.ts

@@ -1,13 +1,12 @@
 import { HTMLParser } from '../inline';
 import { Recursion } from '../context';
-import { Ctx } from '../../combinator/data/parser';
+import { List, Data, Ctx } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, validate, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { isLooseNodeStart, blankWith } from '../visibility';
-import { invalid } from '../util';
+import { invalid, unwrap } from '../util';
 import { memoize } from 'spica/memoize';
-import { unshift, push } from 'spica/array';
 import { html as h, defrag } from 'typed-dom/dom';
 
 const tags: readonly string[] = ['wbr', 'bdo', 'bdi'];
@@ -28,10 +27,10 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
       some(union([attribute])),
       open(str(/ ?/y), str('>'), true),
       true,
-      ([as, bs = [], cs], context) =>
-        [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [], context)]],
-      ([as, bs = []], context) =>
-        [[elem(as[0].slice(1), false, unshift(as, bs), [], [], context)]]),
+      ([as, bs = new List(), cs], context) =>
+        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
+      ([as, bs = new List()], context) =>
+        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
     match(
       new RegExp(String.raw`<(${TAGS.join('|')})(?=[^\S\n]|>)`, 'y'),
       memoize(
@@ -40,8 +39,8 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
           surround(
             str(`<${tag}`), some(attribute), open(str(/ ?/y), str('>'), true),
             true,
-            ([as, bs = [], cs]) => [push(unshift(as, bs), cs)],
-            ([as, bs = []]) => [unshift(as, bs)]),
+            ([as, bs = new List(), cs]) => as.import(bs).import(cs),
+            ([as, bs = new List()]) => as.import(bs)),
           // 不可視のHTML構造が可視構造を変化させるべきでない。
           // 可視のHTMLは優先度変更を検討する。
           // このため<>は将来的に共通構造を変化させる可能性があり
@@ -53,10 +52,10 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
           ])))),
           str(`</${tag}>`),
           true,
-          ([as, bs = [], cs], context) =>
-            [[elem(tag, true, as, bs, cs, context)]],
-          ([as, bs = []], context) =>
-            [[elem(tag, true, as, bs, [], context)]]),
+          ([as, bs = new List(), cs], context) =>
+            new List([new Data(elem(tag, true, [...unwrap(as)], bs, cs, context))]),
+          ([as, bs = new List()], context) =>
+            new List([new Data(elem(tag, true, [...unwrap(as)], bs, new List(), context))])),
       ([, tag]) => tag,
       new Map())),
     surround(
@@ -65,10 +64,10 @@ export const html: HTMLParser = lazy(() => validate(/<[a-z]+(?=[ >])/yi,
       some(union([attribute])),
       open(str(/ ?/y), str('>'), true),
       true,
-      ([as, bs = [], cs], context) =>
-        [[elem(as[0].slice(1), false, push(unshift(as, bs), cs), [], [], context)]],
-      ([as, bs = []], context) =>
-        [[elem(as[0].slice(1), false, unshift(as, bs), [], [], context)]]),
+      ([as, bs = new List(), cs], context) =>
+        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs).import(cs))], new List(), new List(), context))]),
+      ([as, bs = new List()], context) =>
+        new List([new Data(elem(as.head!.value.slice(1), false, [...unwrap(as.import(bs))], new List(), new List(), context))])),
   ])));
 
 export const attribute: HTMLParser.AttributeParser = union([
@@ -76,7 +75,7 @@ export const attribute: HTMLParser.AttributeParser = union([
   str(/ [^\s<>]+/y),
 ]);
 
-function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | string)[], cs: string[], context: Ctx): HTMLElement {
+function elem(tag: string, content: boolean, as: readonly string[], bs: List<Data<HTMLElement | string>>, cs: List<Data<string>>, context: Ctx): HTMLElement {
   assert(as.length > 0);
   assert(as[0][0] === '<');
   if (!tags.includes(tag)) return ielem('tag', `Invalid HTML tag name "${tag}"`, context);
@@ -88,7 +87,7 @@ function elem(tag: string, content: boolean, as: string[], bs: (HTMLElement | st
   const [attrs] = attributes('html', attrspecs[tag], as.slice(1, as.at(-1) === '>' ? -1 : as.length));
   if (/(?<!\S)invalid(?!\S)/.test(attrs['class'] ?? '')) return ielem('attribute', 'Invalid HTML attribute', context)
   if (as.at(-1) !== '>') return ielem('tag', `Missing the closing symbol ">"`, context);
-  return h(tag as 'span', attrs, defrag(bs));
+  return h(tag as 'span', attrs, defrag(unwrap(bs)));
 }
 
 function ielem(type: string, message: string, context: Ctx): HTMLElement {
@@ -105,7 +104,7 @@ const requiredAttributes = memoize(
 export function attributes(
   syntax: string,
   spec: Readonly<Record<string, readonly (string | undefined)[] | undefined>> | undefined,
-  params: readonly string[],
+  params: Iterable<string>,
 ): [Record<string, string | undefined>, string[]] {
   assert(spec instanceof Object === false);
   assert(!spec?.['__proto__']);
@@ -113,17 +112,17 @@ export function attributes(
   const remains = [];
   let invalidation = false;
   const attrs: Record<string, string | undefined> = {};
-  for (let i = 0; i < params.length; ++i) {
-    const param = params[i].trimStart();
-    if (param === '') continue;
-    const name = param.split('=', 1)[0];
-    const value = param !== name
-      ? param.slice(name.length + 2, -1).replace(/\\(.?)/g, '$1')
+  for (const param of params) {
+    const attr = param.trimStart();
+    if (attr === '') continue;
+    const name = attr.split('=', 1)[0];
+    const value = attr !== name
+      ? attr.slice(name.length + 2, -1).replace(/\\(.?)/g, '$1')
       : undefined;
     invalidation ||= name === '' || !spec || name in attrs;
-    if (name === '')continue;
+    if (name === '') continue;
     if (spec && name in spec && !spec[name]) {
-      remains.push(params[i]);
+      remains.push(param);
       continue;
     }
     if (spec?.[name]?.includes(value) || spec?.[name]?.length === 0 && value !== undefined) {

package/src/parser/inline/htmlentity.ts

@@ -1,4 +1,5 @@
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
+import { List, Data } from '../../combinator/data/parser';
 import { union, focus, fmap } from '../../combinator';
 import { invalid } from '../util';
 import { html } from 'typed-dom/dom';
@@ -10,20 +11,20 @@ export const unsafehtmlentity: UnsafeHTMLEntityParser = focus(
     const { source } = context;
     context.position += source.length;
     return source.length > 1 && source.at(-1) === ';'
-      ? [[parser(source) ?? source]]
-      : [[source]];
+      ? new List([new Data(parser(source) ?? source)])
+      : new List([new Data(source)]);
   });
 
 export const htmlentity: HTMLEntityParser = fmap(
   union([unsafehtmlentity]),
-  ([text]) => [
-    length === 1 || text.at(-1) !== ';'
-      ? text
-      : html('span', {
+  ([{ value }]) => new List([
+    length === 1 || value.at(-1) !== ';'
+      ? new Data(value)
+      : new Data(html('span', {
           class: 'invalid',
           ...invalid('htmlentity', 'syntax', 'Invalid HTML entity'),
-      }, text)
-  ]);
+      }, value))
+  ]));
 
 const parser = (el => (entity: string): string | undefined => {
   if (entity === '
') return ' ';

package/src/parser/inline/insertion.ts

@@ -1,10 +1,10 @@
 import { InsertionParser } 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 insertion: InsertionParser = lazy(() => validate('++',
@@ -16,6 +16,6 @@ export const insertion: InsertionParser = lazy(() => validate('++',
       open('\n', some(inline, '+'), true),
     ]))),
     '++', false,
-    ([, bs], { buffer }) => [push(buffer!, bs)],
-    ([, bs], { buffer }) => bs && [push(push(buffer!, bs), [Command.Cancel])]),
-    nodes => [html('ins', 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('ins', defrag(unwrap(nodes))))])))));

package/src/parser/inline/italic.ts

@@ -1,10 +1,10 @@
 import { ItalicParser } 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 { tightStart, blankWith } from '../visibility';
-import { repeat } from '../util';
-import { push } from 'spica/array';
+import { unwrap, repeat } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 // 可読性のため実際にはオブリーク体を指定する。
@@ -19,6 +19,6 @@ export const italic: ItalicParser = lazy(() => validate('///',
       open(some(inline, '/'), inline),
     ])))),
     '///', false,
-    ([, bs], { buffer }) => [push(buffer!, bs)],
-    ([, bs], { buffer }) => bs && [push(push(buffer!, bs), [Command.Cancel])]),
-    nodes => [html('i', 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('i', defrag(unwrap(nodes))))])))));