securemark 0.293.4 → 0.294.0

package/src/parser/inline/ruby.ts

@@ -1,11 +1,11 @@
 import { RubyParser } from '../inline';
 import { Backtrack } from '../context';
-import { eval } from '../../combinator/data/parser';
+import { List, Data, eval } from '../../combinator/data/parser';
 import { inits, surround, setBacktrack, dup, lazy, bind } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { txt } from '../source';
 import { isTightNodeStart } from '../visibility';
-import { unshift, push } from 'spica/array';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const ruby: RubyParser = lazy(() => bind(
@@ -14,8 +14,8 @@ export const ruby: RubyParser = lazy(() => bind(
       '[', text, ']',
       false,
       ([, ns]) => {
-        ns && ns.at(-1) === '' && ns.pop();
-        return isTightNodeStart(ns) ? [ns] : undefined;
+        ns && ns.last?.value === '' && ns.pop();
+        return isTightNodeStart(ns) ? ns : undefined;
       },
       undefined,
       [1 | Backtrack.bracket, 3 | Backtrack.ruby])),
@@ -24,48 +24,49 @@ export const ruby: RubyParser = lazy(() => bind(
       false, undefined, undefined,
       [1 | Backtrack.bracket, 3 | Backtrack.ruby])),
   ]),
-  ([texts, rubies], context) => {
+  ([{ value: texts }, { value: rubies = undefined } = {}], context) => {
     if (rubies === undefined) {
       const head = context.position - context.range!;
       return void setBacktrack(context, [2 | Backtrack.ruby], head);
     }
     switch (true) {
-      case rubies.length <= texts.length:
-        return [[
-          html('ruby', defrag(texts
-            .reduce((acc, _, i) =>
-              push(acc, unshift(
-                [texts[i]],
-                i < rubies.length && rubies[i]
-                  ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
-                  : [html('rt')]))
-            , []))),
-        ]];
-      case texts.length === 1 && [...texts[0]].length >= rubies.length:
-        return [[
-          html('ruby', defrag([...texts[0]]
-            .reduce((acc, _, i, texts) =>
-              push(acc, unshift(
-                [texts[i]],
-                i < rubies.length && rubies[i]
-                  ? [html('rp', '('), html('rt', rubies[i]), html('rp', ')')]
-                  : [html('rt')]))
-            , []))),
-        ]];
+      case texts.length >= rubies.length:
+        return new List([
+          new Data(html('ruby', defrag(unwrap([...zip(texts, rubies)]
+            .reduce((acc, [{ value: text = '' } = {}, { value: ruby = '' } = {}]) =>
+              acc.import(
+                ruby
+                  ? new List([new Data(text), new Data(html('rp', '(')), new Data(html('rt', ruby)), new Data(html('rp', ')'))])
+                  : new List([new Data(text), new Data(html('rt'))]))
+            , new List<Data<string | HTMLElement>>()))))),
+        ]);
+      case texts.length === 1 && [...texts.head!.value].length >= rubies.length:
+        return new List([
+          new Data(html('ruby', defrag(unwrap([...zip(new List([...texts.head!.value].map(char => new Data(char))), rubies)]
+            .reduce((acc, [{ value: text = '' } = {}, { value: ruby = '' } = {}]) =>
+              acc.import(
+                ruby
+                  ? new List([new Data(text), new Data(html('rp', '(')), new Data(html('rt', ruby)), new Data(html('rp', ')'))])
+                  : new List([new Data(text), new Data(html('rt'))]))
+            , new List<Data<string | HTMLElement>>()))))),
+        ]);
       default:
         assert(rubies.length > 0);
-        return [[
-          html('ruby', defrag(unshift(
-            [texts.join(' ')],
-            [html('rp', '('), html('rt', rubies.join(' ').trim()), html('rp', ')')]))),
-        ]];
+        return new List([
+          new Data(html('ruby', defrag(unwrap(new List<Data<string | HTMLElement>>([
+            new Data(texts.foldr(({ value }, acc) => value + ' ' + acc, '').slice(0, -1)),
+            new Data(html('rp', '(')),
+            new Data(html('rt', rubies.foldr(({ value }, acc) => value + ' ' + acc, '').trim())),
+            new Data(html('rp', ')')),
+          ]))))),
+        ]);
     }
   }));
 
 const text: RubyParser.TextParser = input => {
   const { context } = input;
   const { source } = context;
-  const acc = [''];
+  const acc = new List([new Data('')]);
   let state = false;
   context.sequential = true;
   for (let { position } = context; position < source.length; position = context.position) {
@@ -75,41 +76,37 @@ const text: RubyParser.TextParser = input => {
       case '&': {
         const result = unsafehtmlentity(input) ?? txt(input)!;
         assert(result);
-        acc[acc.length - 1] += eval(result)[0];
+        acc.last!.value += eval(result).head!.value;
         continue;
       }
       default: {
         if (source[position].trimStart() === '') {
-          state ||= acc.at(-1)!.trimStart() !== '';
-          acc.push('');
+          state ||= acc.last!.value.trimStart() !== '';
+          acc.push(new Data(''));
           context.position += 1;
           continue;
         }
         const result = txt(input)!;
         assert(result);
-        acc[acc.length - 1] += eval(result)[0] ?? source.slice(position, context.position);
+        acc.last!.value += eval(result).head?.value ?? '';
         continue;
       }
     }
   }
   context.sequential = false;
-  state ||= acc.at(-1)!.trimStart() !== '';
+  state ||= acc.last!.value.trimStart() !== '';
   return state
-    ? [acc]
+    ? acc
     : undefined;
 };
 
-//function attributes(texts: string[], rubies: string[]): Record<string, string> {
-//  let attrs: Record<string, string> | undefined;
-//  for (const ss of [texts, rubies]) {
-//    for (let i = 0; i < ss.length; ++i) {
-//      if (!ss[i].includes(Command.Error)) continue;
-//      ss[i] = ss[i].replace(CmdRegExp.Error, '');
-//      attrs ??= {
-//        class: 'invalid',
-//        ...invalid('ruby', ss === texts ? 'content' : 'argument', 'Invalid HTML entity'),
-//      };
-//    }
-//  }
-//  return attrs ?? {};
-//}
+function* zip<N extends List.Node>(a: List<N>, b: List<N>): Iterable<[N | undefined, N | undefined]> {
+  const ia = a[Symbol.iterator]();
+  const ib = b[Symbol.iterator]();
+  while (true) {
+    const ra = ia.next();
+    const rb = ib.next();
+    if (ra.done) break;
+    yield [ra.value, rb.value];
+  }
+}

package/src/parser/inline/strong.ts

@@ -1,11 +1,12 @@
 import { StrongParser } 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 { emphasis } from './emphasis';
 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 strong: StrongParser = lazy(() => surround(
@@ -17,5 +18,5 @@ export const strong: StrongParser = lazy(() => surround(
     open(some(inline, '*'), inline),
   ]))))),
   str('**'), false,
-  ([, bs]) => [[html('strong', defrag(bs))]],
-  ([as, bs]) => bs && [unshift(as, bs)]));
+  ([, bs]) => new List([new Data(html('strong', defrag(unwrap(bs))))]),
+  ([as, bs]) => bs && as.import(bs as List<Data<string>>)));

package/src/parser/inline/template.ts

@@ -1,9 +1,9 @@
 import { TemplateParser } from '../inline';
 import { Recursion, Backtrack } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, surround, lazy } from '../../combinator';
 import { escsource, str } from '../source';
-import { invalid } from '../util';
-import { unshift, push } from 'spica/array';
+import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const template: TemplateParser = lazy(() => surround(
@@ -12,35 +12,36 @@ export const template: TemplateParser = lazy(() => surround(
   some(union([bracket, escsource]), '}')),
   str('}}'),
   true,
-  ([as, bs = [], cs]) =>
-    [[html('span', { class: 'template' }, defrag(push(unshift(as, bs), cs)))]],
+  ([as, bs = new List(), cs]) => new List([
+    new Data(html('span', { class: 'template' }, defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))))
+  ]),
   ([, bs], context) =>
-    bs && [[
-      html('span',
+    bs && new List([
+      new Data(html('span',
         {
           class: 'invalid',
           ...invalid('template', 'syntax', `Missing the closing symbol "}}"`),
         },
-        context.source.slice(context.position - context.range!, context.position))
-    ]],
+        context.source.slice(context.position - context.range!, context.position)))
+    ]),
   [3 | Backtrack.doublebracket, 3 | Backtrack.escbracket]));
 
 const bracket: TemplateParser.BracketParser = lazy(() => union([
   surround(str('('), recursion(Recursion.terminal, some(union([bracket, escsource]), ')')), str(')'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
   surround(str('['), recursion(Recursion.terminal, some(union([bracket, escsource]), ']')), str(']'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
   surround(str('{'), recursion(Recursion.terminal, some(union([bracket, escsource]), '}')), str('}'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
   surround(
     str('"'),
     precedence(2, recursion(Recursion.terminal, some(escsource, /["\n]/y, [['"', 2], ['\n', 3]]))),
     str('"'),
     true,
-    ([as, bs = [], cs], context) =>
+    ([as, bs = new List(), cs], context) =>
       context.linebreak === 0
-        ? [push(unshift(as, bs), cs)]
-        : (context.position -= 1, [unshift(as, bs)]),
-    ([as, bs]) => bs && [unshift(as, bs)],
+        ? as.import(bs as List<Data<string>>).import(cs)
+        : (context.position -= 1, as.import(bs as List<Data<string>>)),
+    ([as, bs]) => bs && as.import(bs as List<Data<string>>),
     [3 | Backtrack.escbracket]),
 ]));

package/src/parser/inline.test.ts

@@ -56,9 +56,9 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('**a*b***'), ctx), [['<strong>a<em>b</em></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**a*b***c'), ctx), [['<strong>a<em>b</em></strong>', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('**a**b****'), ctx), [['<strong>a</strong>', 'b', '****'], '']);
-      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*****'), ctx), [['<strong>a</strong>', '<em>b</em>', '****'], '']);
-      assert.deepStrictEqual(inspect(parser('**a***b*****c'), ctx), [['<strong>a</strong>', '<em>b</em>', '****', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser('**a***b*****c'), ctx), [['<strong>a</strong>', '<em>b</em>', '****c'], '']);
       assert.deepStrictEqual(inspect(parser('**a *b***'), ctx), [['<strong>a <em>b</em></strong>'], '']);
       assert.deepStrictEqual(inspect(parser('**a *b***c'), ctx), [['<strong>a <em>b</em></strong>', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('**a **b****'), ctx), [['<strong>a <strong>b</strong></strong>'], '']);
@@ -68,7 +68,7 @@ describe('Unit: parser/inline', () => {
       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>'], '']);

package/src/parser/segment.ts

@@ -53,7 +53,9 @@ export function* segment(source: string): Generator<string, undefined, undefined
     const result = parser(input)!;
     assert(result);
     assert(context.position > position);
-    const segs = eval(result).length ? eval(result) : [source.slice(position, context.position)];
+    const segs = eval(result).length > 0
+      ? eval(result).foldl<string[]>((acc, { value }) => void acc.push(value) || acc, [])
+      : [source.slice(position, context.position)];
     assert(segs.join('') === source.slice(position, context.position));
     for (let i = 0; i < segs.length; ++i) {
       const seg = segs[i];

package/src/parser/source/escapable.ts

@@ -1,5 +1,6 @@
 import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { consume } from '../../combinator';
 import { next } from './text';
 import { html } from 'typed-dom/dom';
@@ -16,33 +17,33 @@ export const escsource: EscapableSourceParser = ({ context }) => {
     case '\r':
       assert(!source.includes('\r', position + 1));
       consume(-1, context);
-      return [[]];
+      return new List();
     case Command.Escape:
       consume(1, context);
       context.position += 1;
-      return [[source.slice(position + 1, position + 2)]];
+      return new List([new Data(source.slice(position + 1, position + 2))]);
     case '\\':
       switch (source[position + 1]) {
         case undefined:
-          return [[char]];
+          return new List([new Data(char)]);
         case '\n':
-          return [[char]];
+          return new List([new Data(char)]);
         default:
           consume(1, context);
           context.position += 1;
-          return [[source.slice(position, position + 2)]];
+          return new List([new Data(source.slice(position, position + 2))]);
       }
     case '\n':
       context.linebreak ||= source.length - position;
-      return [[html('br')]];
+      return new List([new Data(html('br'))]);
     default:
       assert(char !== '\n');
-      if (context.sequential) return [[char]];
+      if (context.sequential) return new List([new Data(char)]);
       let i = next(source, position, delimiter);
       assert(i > position);
       i -= position;
       consume(i - 1, context);
       context.position += i - 1;
-      return [[source.slice(position, context.position)]];
+      return new List([new Data(source.slice(position, context.position))]);
   }
 };

package/src/parser/source/line.ts

@@ -1,10 +1,11 @@
 import { AnyLineParser, EmptyLineParser, ContentLineParser } from '../source';
+import { List } from '../../combinator/data/parser';
 
 export const anyline: AnyLineParser = input => {
   const { context } = input;
   const { source, position } = context;
   context.position = source.indexOf('\n', position) + 1 || source.length;
-  return [[]];
+  return new List();
 };
 const regEmptyline = /[^\S\n]*(?:$|\n)/y;
 export const emptyline: EmptyLineParser = input => {
@@ -15,7 +16,7 @@ export const emptyline: EmptyLineParser = input => {
   const i = regEmptyline.lastIndex;
   if (i === 0) return;
   context.position = i;
-  return [[]];
+  return new List();
 };
 const regContentline = /[^\S\n]*\S[^\n]*(?:$|\n)/y;
 export const contentline: ContentLineParser = input => {
@@ -26,5 +27,5 @@ export const contentline: ContentLineParser = input => {
   const i = regContentline.lastIndex;
   if (i === 0) return;
   context.position = i;
-  return [[]];
+  return new List();
 }

package/src/parser/source/str.ts

@@ -1,5 +1,5 @@
 import { StrParser } from '../source';
-import { Parser } from '../../combinator/data/parser';
+import { Parser, List, Data } from '../../combinator/data/parser';
 import { matcher } from '../../combinator';
 
 export function str(pattern: string | RegExp): StrParser;
@@ -17,6 +17,6 @@ export function strs(pattern: string): Parser<string> {
       acc += pattern;
       context.position += pattern.length;
     }
-    return [[acc]];
+    return new List([new Data(acc)]);
   };
 }

package/src/parser/source/text.ts

@@ -1,5 +1,6 @@
 import { TextParser, TxtParser, LinebreakParser } from '../source';
 import { Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, consume, focus } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
@@ -17,26 +18,26 @@ export const text: TextParser = input => {
     case '\r':
       assert(!source.includes('\r', position + 1));
       consume(-1, context);
-      return [[]];
+      return new List();
     case Command.Escape:
     case '\\':
       switch (source[position + 1]) {
         case undefined:
-          return [[]];
+          return new List();
         case '\n':
           assert(char !== Command.Escape);
-          return [[]];
+          return new List();
         default:
           consume(1, context);
           context.position += 1;
-          return [[source.slice(position + 1, context.position)]];
+          return new List([new Data(source.slice(position + 1, context.position))]);
       }
     case '\n':
       context.linebreak ||= source.length - position;
-      return [[html('br')]];
+      return new List([new Data(html('br'))]);
     default:
       assert(char !== '\n');
-      if (context.sequential) return [[char]];
+      if (context.sequential) return new List([new Data(char)]);
       nonWhitespace.lastIndex = position + 1;
       const s = canSkip(source, position);
       let i = s
@@ -54,8 +55,8 @@ export const text: TextParser = input => {
       context.position += i - 1;
       const linestart = position === 0 || source[position - 1] === '\n';
       return position === context.position || s && !linestart || lineend
-        ? [[]]
-        : [[source.slice(position, context.position)]];
+        ? new List()
+        : new List([new Data(source.slice(position, context.position))]);
   }
 };
 
@@ -136,36 +137,30 @@ export function backToWhitespace(source: string, position: number, index: number
 export function backToUrlHead(source: string, position: number, index: number): number {
   const delim = index;
   let state = false;
-  let offset = 0;
-  for (let i = index; --i > position;) {
-    index = i;
+  for (let i = index - 1; i >= position; --i) {
     const char = source[i];
     if (state) switch (char) {
       case '.':
       case '+':
       case '-':
         state = false;
-        offset = 1;
         continue;
     }
     if (isAlphanumeric(char)) {
       state = true;
-      offset = 0;
+      index = i;
       continue;
     }
     break;
   }
-  if (index === position + 1 && offset === 0 && isAlphanumeric(source[index - 1])) {
-    return delim;
-  }
-  return index + offset;
+  return index === position
+    ? delim
+    : index;
 }
 export function backToEmailHead(source: string, position: number, index: number): number {
   const delim = index;
   let state = false;
-  let offset = 0;
-  for (let i = index; --i > position;) {
-    index = i;
+  for (let i = index - 1; i >= position; --i) {
     const char = source[i];
     if (state) switch (char) {
       case '_':
@@ -173,20 +168,18 @@ export function backToEmailHead(source: string, position: number, index: number)
       case '+':
       case '-':
         state = false;
-        offset = 1;
         continue;
     }
     if (isAlphanumeric(char)) {
       state = true;
-      offset = 0;
+      index = i;
       continue;
     }
     break;
   }
-  if (index === position + 1 && offset === 0 && isAlphanumeric(source[index - 1])) {
-    return delim;
-  }
-  return index + offset;
+  return index === position
+    ? delim
+    : index;
 }
 function isAlphanumeric(char: string): boolean {
   assert(char.length === 1);

package/src/parser/source/unescapable.ts

@@ -1,5 +1,6 @@
 import { UnescapableSourceParser } from '../source';
 import { Command } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { consume } from '../../combinator';
 import { nonWhitespace, canSkip, next } from './text';
 import { html } from 'typed-dom/dom';
@@ -16,17 +17,17 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
     case '\r':
       assert(!source.includes('\r', position + 1));
       consume(-1, context);
-      return [[]];
+      return new List();
     case Command.Escape:
       consume(1, context);
       context.position += 1;
-      return [[source.slice(position + 1, position + 2)]];
+      return new List([new Data(source.slice(position + 1, position + 2))]);
     case '\n':
       context.linebreak ||= source.length - position;
-      return [[html('br')]];
+      return new List([new Data(html('br'))]);
     default:
       assert(char !== '\n');
-      if (context.sequential) return [[char]];
+      if (context.sequential) return new List([new Data(char)]);
       nonWhitespace.lastIndex = position + 1;
       let i = canSkip(source, position)
         ? nonWhitespace.test(source)
@@ -37,6 +38,6 @@ export const unescsource: UnescapableSourceParser = ({ context }) => {
       i -= position;
       consume(i - 1, context);
       context.position += i - 1;
-      return [[source.slice(position, context.position)]];
+      return new List([new Data(source.slice(position, context.position))]);
   }
 };

package/src/parser/util.ts

@@ -1,47 +1,34 @@
 import { min } from 'spica/alias';
 import { MarkdownParser } from '../../markdown';
 import { Command } from './context';
-import { Parser, Result, Ctx, Node, Context, eval, failsafe } from '../combinator/data/parser';
-import { convert } from '../combinator';
+import { Parser, Result, List, Data, Ctx, Node, Context, eval, failsafe } from '../combinator/data/parser';
 import { define } from 'typed-dom/dom';
 
-export function linearize<P extends Parser<HTMLElement | string>>(parser: P, trim?: 0 | 1 | -1): P;
-export function linearize<N extends HTMLElement | string>(parser: Parser<N>, trim = 0): Parser<N> {
-  return convert(
-    source => `${
-      trim === 0
-        ? source
-        : trim > 0
-          ? source.at(-1) === '\n'
-            ? source
-            : source + '\n'
-          : source.at(-1) === '\n'
-            ? source.slice(0, -1)
-            : source
-    }`,
-    parser,
-    trim === 0);
+export function* unwrap<N>(nodes: List<Data<N>>): Iterable<N> {
+  for (const node of nodes) {
+    yield node.value;
+  }
 }
 
-export function repeat<P extends Parser<HTMLElement |  string, MarkdownParser.Context>>(symbol: string, parser: P, cons: (nodes: Node<P>[], context: Context<P>) => Node<P>[], termination?: (acc: Node<P>[], context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | Node<P>>): P;
-export function repeat<N extends HTMLElement |  string>(symbol: string, parser: Parser<N>, cons: (nodes: N[], context: MarkdownParser.Context) => N[], termination: (acc: N[], context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | N, MarkdownParser.Context> = (nodes, context, prefix, postfix) => {
-  const acc = [];
+export function repeat<P extends Parser<HTMLElement | string, MarkdownParser.Context>>(symbol: string, parser: P, cons: (nodes: List<Data<Node<P>>>, context: Context<P>) => List<Data<Node<P>>>, termination?: (acc: List<Data<Node<P>>>, context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | Node<P>>): P;
+export function repeat<N extends HTMLElement | string>(symbol: string, parser: Parser<N>, cons: (nodes: List<Data<N>>, context: MarkdownParser.Context) => List<Data<N>>, termination: (acc: List<Data<N>>, context: Ctx, prefix: number, postfix: number, state: boolean) => Result<string | N, MarkdownParser.Context> = (nodes, context, prefix, postfix) => {
+  const acc = new List<Data<string | N>>();
   if (prefix > 0) {
-    acc.push(symbol[0].repeat(prefix));
+    acc.push(new Data(symbol[0].repeat(prefix)));
   }
-  acc.push(...nodes);
+  acc.import(nodes);
   if (postfix > 0) {
     const { source, position } = context;
-    acc.push(source.slice(position, position + postfix));
+    acc.push(new Data(source.slice(position, position + postfix)));
     context.position += postfix;
   }
-  return [acc];
+  return acc;
 }): Parser<string | N, MarkdownParser.Context> {
   return failsafe(input => {
     const { context } = input;
     const { source, position } = context;
     assert(source.startsWith(symbol, context.position));
-    let nodes: N[] = [];
+    let nodes = new List<Data<N>>();
     let i = symbol.length;
     while (source[context.position + i] === source[context.position]) ++i;
     context.position += i;
@@ -58,7 +45,7 @@ export function repeat<N extends HTMLElement |  string>(symbol: string, parser:
       context.buffer = buf;
       if (result === undefined) break;
       nodes = eval(result);
-      switch (nodes.at(-1)) {
+      switch (nodes.last?.value) {
         case Command.Cancel:
           assert(!source.startsWith(symbol, context.position));
           nodes.pop();
@@ -124,10 +111,9 @@ export function unmarkInvalid<N extends HTMLElement>(el: N): N {
   });
 }
 
-export function stringify(nodes: readonly (HTMLElement | string)[]): string {
+export function stringify(nodes: Iterable<HTMLElement | string>): string {
   let acc = '';
-  for (let i = 0; i < nodes.length; ++i) {
-    const node = nodes[i];
+  for (const node of nodes) {
     if (typeof node === 'string') {
       assert(!node.includes('\n'));
       acc += node;