securemark 0.293.5 → 0.294.0

package/src/parser/inline/media.ts

@@ -1,14 +1,13 @@
 import { MediaParser } from '../inline';
 import { State, Recursion, Backtrack, Command } from '../context';
-import { subinput } from '../../combinator/data/parser';
-import { union, inits, tails, some, creation, recursion, precedence, constraint, verify, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
+import { List, Data, subinput } from '../../combinator/data/parser';
+import { union, inits, tails, some, creation, recursion, precedence, constraint, surround, open, setBacktrack, dup, lazy, fmap, bind } from '../../combinator';
 import { unsafelink, uri, option as linkoption, resolve, decode } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
-import { invalid } from '../util';
+import { unwrap, invalid } from '../util';
 import { ReadonlyURL } from 'spica/url';
-import { unshift, push } from 'spica/array';
 import { html, define } from 'typed-dom/dom';
 
 const optspec = {
@@ -21,7 +20,7 @@ Object.setPrototypeOf(optspec, null);
 
 export const media: MediaParser = lazy(() => constraint(State.media, creation(10, open(
   '!',
-  bind(verify(fmap(tails([
+  bind(fmap(tails([
     dup(surround(
       '[',
       precedence(1, some(union([
@@ -31,9 +30,9 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
       ]), ']')),
       ']',
       true,
-      ([, ns = []], context) =>
+      ([, ns = new List()], context) =>
         context.linebreak === 0
-          ? [ns]
+          ? ns
           : undefined,
       undefined,
       [3 | Backtrack.escbracket])),
@@ -47,26 +46,29 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
         if (!bs) return;
         const head = context.position - context.range!;
         setBacktrack(context, [2 | Backtrack.link], head);
-        return [push(unshift(as, bs), [Command.Cancel])];
+        return as.import(bs).push(new Data(Command.Cancel)) && as;
       },
       [3 | Backtrack.link])),
   ]),
-  ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], bs] : [[''], as]),
-  ([[text]]) => text === '' || text.trim() !== ''),
-  ([[text], params], context) => {
-    if (params.at(-1) === Command.Cancel) {
+  nodes =>
+    nodes.length === 1
+      ? new List<Data<List<Data<string>>>>([new Data(new List([new Data('')])), nodes.delete(nodes.head!)])
+      : new List<Data<List<Data<string>>>>([new Data(new List([new Data(nodes.head!.value.foldl((acc, { value }) => acc + value, ''))])), nodes.delete(nodes.last!)])),
+  ([{ value: [{ value: text }] }, { value: params }], context) => {
+    if (text && text.trimStart() === '') return;
+    text = text.trim();
+    if (params.last!.value === Command.Cancel) {
       params.pop();
-      return [[
-        html('span',
+      return new List([
+        new Data(html('span',
           {
             class: 'invalid',
             ...invalid('media', 'syntax', 'Missing the closing symbol "}"')
           },
-          '!' + context.source.slice(context.position - context.range!, context.position))
-      ]];
+          '!' + context.source.slice(context.position - context.range!, context.position)))
+      ]);
     }
-    assert(text === text.trim());
-    const INSECURE_URI = params.shift()!;
+    const INSECURE_URI = params.shift()!.value;
     assert(INSECURE_URI === INSECURE_URI.trim());
     assert(!INSECURE_URI.match(/\s/));
     // altが空だとエラーが見えないため埋める。
@@ -85,37 +87,37 @@ export const media: MediaParser = lazy(() => constraint(State.media, creation(10
       || html('img', { class: 'media', 'data-src': uri?.source });
     assert(!el.matches('.invalid'));
     el.setAttribute('alt', text);
-    if (!sanitize(el, uri)) return [[el]];
+    if (!sanitize(el, uri)) return new List([new Data(el)]);
     assert(!el.matches('.invalid'));
-    const [attrs, linkparams] = attributes('media', optspec, params);
+    const [attrs, linkparams] = attributes('media', optspec, unwrap(params));
     define(el, attrs);
     assert(el.matches('img') || !el.matches('.invalid'));
     // Awaiting the generic support for attr().
     if (el.hasAttribute('aspect-ratio')) {
       el.style.aspectRatio = el.getAttribute('aspect-ratio')!;
     }
-    if (context.state! & State.link) return [[el]];
-    if (cache && cache.tagName !== 'IMG') return [[el]];
+    if (context.state! & State.link) return new List([new Data(el)]);
+    if (cache && cache.tagName !== 'IMG') return new List([new Data(el)]);
     const { source, position } = context;
     return fmap(
       unsafelink as MediaParser,
-      ([link]) => {
+      ([{ value }]) => {
         context.source = source;
         context.position = position;
-        return [define(link, { class: null, target: '_blank' }, [el])];
+        return new List([new Data(define(value, { class: null, target: '_blank' }, [el]))]);
       })
       (subinput(`{ ${INSECURE_URI}${linkparams.join('')} }`, context));
   })))));
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => recursion(Recursion.terminal, union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
   surround(str('{'), some(union([unsafehtmlentity, bracket, txt]), '}'), str('}'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
   surround(str('"'), precedence(2, some(union([unsafehtmlentity, txt]), '"')), str('"'), true,
-    undefined, () => [[]], [3 | Backtrack.escbracket]),
+    undefined, () => new List(), [3 | Backtrack.escbracket]),
 ])));
 
 const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([
@@ -124,11 +126,10 @@ const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([
     str(/[x:]/y),
     str(/[1-9][0-9]*(?=[ }])/y),
     false,
-    ([[a], [b], [c]]) => [
+    ([[{ value: a }], [{ value: b }], [{ value: c }]]) =>
       b === 'x'
-        ? [`width="${a}"`, `height="${c}"`]
-        : [`aspect-ratio="${a}/${c}"`],
-    ]),
+        ? new List([new Data(`width="${a}"`), new Data(`height="${c}"`)])
+        : new List([new Data(`aspect-ratio="${a}/${c}"`)])),
   linkoption,
 ]));
 

package/src/parser/inline/reference.ts

@@ -1,14 +1,13 @@
 import { ReferenceParser } from '../inline';
 import { State, Backtrack, Command } from '../context';
-import { eval } from '../../combinator/data/parser';
+import { List, Data, eval } from '../../combinator/data/parser';
 import { union, subsequence, some, precedence, state, constraint, surround, isBacktrack, setBacktrack, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
 import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
+import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
-import { unshift, push } from 'spica/array';
-import { invalid } from '../util';
 
 export const reference: ReferenceParser = lazy(() => constraint(State.reference, surround(
   str('[['),
@@ -22,7 +21,7 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
   ([, ns], context) => {
     const { position, range = 0, linebreak = 0 } = context;
     if (linebreak === 0) {
-      return [[html('sup', attributes(ns), [html('span', defrag(trimBlankNodeEnd(ns)))])]];
+      return new List([new Data(html('sup', attributes(ns), [html('span', defrag(unwrap(trimBlankNodeEnd(ns))))]))]);
     }
     else {
       const head = position - range;
@@ -42,13 +41,13 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
     else {
       assert(source[position] === ']');
       if (state & State.annotation) {
-        push(bs, [source[position]]);
+        bs.push(new Data(source[position]));
       }
       context.position += 1;
       let result: ReturnType<typeof textlink>;
       if (source[context.position] !== '{') {
         setBacktrack(context, [2 | Backtrack.link], head + 1);
-        result = [[]];
+        result = new List();
       }
       else {
         result = !isBacktrack(context, [1 | Backtrack.link])
@@ -57,7 +56,7 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
         context.range = range;
         if (!result) {
           setBacktrack(context, [2 | Backtrack.link], head + 1);
-          result = [[]];
+          result = new List();
         }
       }
       assert(result);
@@ -71,21 +70,21 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
           some(inline, ']', [[']', 1]]),
           str(']'),
           true,
-          ([, cs = [], ds]) =>
-            [push(cs, ds)],
-          ([, cs = []]) => {
+          ([, cs = new List(), ds]) =>
+            cs.import(ds),
+          ([, cs = new List()]) => {
             setBacktrack(context, [2 | Backtrack.link], head);
-            return [cs];
+            return cs;
           })
           ({ context });
         if (state & State.annotation && next) {
-          return [push(push(unshift(as, bs), eval(result)), eval(next))];
+          return (as as List<Data<string | HTMLElement>>).import(bs).import(eval(result!)).import(eval(next));
         }
       }
       context.position = position;
     }
     return state & State.annotation
-      ? [unshift(as, bs)]
+      ? as.import(bs as List<Data<string>>)
       : undefined;
   },
   [1 | Backtrack.bracket, 3 | Backtrack.doublebracket])));
@@ -98,22 +97,22 @@ const abbr: ReferenceParser.AbbrParser = surround(
   true,
   ([, ns], context) => {
     const { source, position, range = 0 } = context;
-    if (!ns) return [['', source.slice(position - range, source[position - 1] === '|' ? position - 1 : position)]];
+    if (!ns) return new List([new Data(''), new Data(source.slice(position - range, source[position - 1] === '|' ? position - 1 : position))]);
     context.position += source[position] === ' ' ? 1 : 0;
-    return [[Command.Separator, ns[0].trimEnd()]];
+    return new List([new Data(Command.Separator), new Data(ns.head!.value.trimEnd())]);
   },
   (_, context) => {
     context.position -= context.range!;
-    return [['']];
+    return new List([new Data('')]);
   });
 
-function attributes(ns: (string | HTMLElement)[]): Record<string, string | undefined> {
-  switch (ns[0]) {
+function attributes(ns: List<Data<string | HTMLElement>>): Record<string, string | undefined> {
+  switch (ns.head!.value) {
     case '':
       return { class: 'invalid', ...invalid('reference', 'syntax', 'Invalid abbreviation') };
     case Command.Separator:
-      const abbr = ns[1] as string;
-      ns[0] = ns[1] = '';
+      const abbr = ns.head!.next!.value as string;
+      ns.head!.value = ns.head!.next!.value = '';
       return { class: 'reference', 'data-abbr': abbr };
     default:
       return { class: 'reference' };

package/src/parser/inline/remark.ts

@@ -1,10 +1,10 @@
 import { RemarkParser } from '../inline';
 import { Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, recursion, precedence, focus, surround, close, fallback, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, 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 remark: RemarkParser = lazy(() => fallback(surround(
@@ -12,13 +12,13 @@ export const remark: RemarkParser = lazy(() => fallback(surround(
   precedence(3, recursion(Recursion.inline,
   some(union([inline]), /\s%\]/y, [[/\s%\]/y, 3]]))),
   close(text, str(`%]`)), true,
-  ([as, bs = [], cs]) => [[
-    html('span', { class: 'remark' }, [
+  ([as, bs = new List(), cs]) => new List([
+    new Data(html('span', { class: 'remark' }, [
       html('input', { type: 'checkbox' }),
-      html('span', defrag(push(unshift(as, bs), cs))),
-    ]),
-  ]],
-  ([as, bs]) => bs && [unshift(as, bs)]),
-  focus(/\[%+(?=\s)/y, ({ context: { source } }) => [[
-    html('span', { class: 'invalid', ...invalid('remark', 'syntax', 'Invalid start symbol') }, source)
-  ]])));
+      html('span', defrag(unwrap(as.import(bs as List<Data<string>>).import(cs)))),
+    ])),
+  ]),
+  ([as, bs]) => bs && as.import(bs as List<Data<string>>)),
+  focus(/\[%+(?=\s)/y, ({ context: { source } }) => new List([
+    new Data(html('span', { class: 'invalid', ...invalid('remark', 'syntax', 'Invalid start symbol') }, source))
+  ]))));

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