securemark 0.293.4 → 0.294.0

package/markdown.d.ts

@@ -1,4 +1,4 @@
-import { Parser, Ctx, CtxOptions } from './src/combinator/data/parser';
+import { Parser, List, Data, Ctx, CtxOptions } from './src/combinator/data/parser';
 import { Dict } from 'spica/dict';
 
 declare abstract class Markdown<T> {
@@ -13,7 +13,7 @@ export interface MarkdownParser extends
 }
 export namespace MarkdownParser {
   export interface Context extends Ctx, Options {
-    buffer?: (string | HTMLElement)[];
+    buffer?: List<Data<(string | HTMLElement)>>;
     sequential?: boolean;
   }
   export interface Options extends CtxOptions {
@@ -434,7 +434,7 @@ export namespace MarkdownParser {
         }
         export interface RowParser extends
           Block<'extension/table/row'>,
-          Parser<[[string[], string[]?], ...HTMLTableCellElement[]], Context, [
+          Parser<List<Data<[string[], string[]?] | HTMLTableCellElement>>, Context, [
             Parser<[string[], string[]?], Context, [
               AlignParser,
             ]>,
@@ -448,7 +448,7 @@ export namespace MarkdownParser {
         }
         export interface AlignParser extends
           Block<'extension/table/align'>,
-          Parser<string[], Context, [
+          Parser<[string[], string[]?], Context, [
             SourceParser.StrParser,
           ]> {
         }
@@ -792,7 +792,7 @@ export namespace MarkdownParser {
       export interface TextLinkParser extends
         Inline<'link/textlink'>,
         Parser<HTMLAnchorElement | HTMLSpanElement, Context, [
-          Parser<(HTMLElement | string)[], Context, [
+          Parser<List<Data<string | HTMLElement>>, Context, [
             InlineParser,
           ]>,
           LinkParser.ParameterParser,
@@ -801,7 +801,7 @@ export namespace MarkdownParser {
       export interface MediaLinkParser extends
         Inline<'link/medialink'>,
         Parser<HTMLAnchorElement | HTMLSpanElement, Context, [
-          Parser<HTMLElement[], Context, [
+          Parser<List<Data<HTMLElement>>, Context, [
             MediaParser,
             ShortMediaParser,
           ]>,
@@ -817,7 +817,7 @@ export namespace MarkdownParser {
       }
       export interface ContentParser extends
         Inline<'link/content'>,
-        Parser<(HTMLElement | string)[], Context, [
+        Parser<List<Data<string | HTMLElement>>, Context, [
           MediaParser,
           ShortMediaParser,
           InlineParser,
@@ -825,13 +825,13 @@ export namespace MarkdownParser {
       }
       export interface TextParser extends
         Inline<'link/text'>,
-        Parser<string[], Context, [
+        Parser<List<Data<string>>, Context, [
           SourceParser.UnescapableSourceParser,
         ]> {
       }
       export interface ParameterParser extends
         Inline<'link/parameter'>,
-        Parser<string[], Context, [
+        Parser<List<Data<string>>, Context, [
           LinkParser.ParameterParser.UriParser,
           LinkParser.ParameterParser.OptionParser,
         ]> {
@@ -866,7 +866,7 @@ export namespace MarkdownParser {
     export namespace MediaParser {
       export interface TextParser extends
         Inline<'media/text'>,
-        Parser<string[], Context, [
+        Parser<List<Data<string>>, Context, [
           UnsafeHTMLEntityParser,
           TextParser.BracketParser,
           SourceParser.TxtParser,
@@ -900,7 +900,7 @@ export namespace MarkdownParser {
       }
       export interface ParameterParser extends
         Inline<'media/parameter'>,
-        Parser<string[], Context, [
+        Parser<List<Data<string>>, Context, [
           LinkParser.ParameterParser.UriParser,
           ParameterParser.OptionParser,
         ]> {
@@ -919,8 +919,8 @@ export namespace MarkdownParser {
       // [AB](a b)
       Inline<'ruby'>,
       Parser<HTMLElement, Context, [
-        Parser<string[], Context, []>,
-        Parser<string[], Context, []>,
+        Parser<List<Data<string>>, Context, []>,
+        Parser<List<Data<string>>, Context, []>,
       ]> {
     }
     export namespace RubyParser {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.293.4",
+  "version": "0.294.0",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",
@@ -28,7 +28,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "spica": "0.0.805"
+    "spica": "0.0.807"
   },
   "devDependencies": {
     "@types/dompurify": "3.0.5",
@@ -55,7 +55,7 @@
     "npm-check-updates": "^17.0.2",
     "semver": "^7.6.3",
     "ts-loader": "^9.5.1",
-    "typed-dom": "0.0.349",
+    "typed-dom": "0.0.351",
     "typescript": "5.4.5",
     "webpack": "^5.93.0",
     "webpack-cli": "^5.1.4",

package/src/combinator/control/constraint/block.test.ts

@@ -1,5 +1,5 @@
 import { block } from './block';
-import { input } from '../../data/parser';
+import { List, Data, input } from '../../data/parser';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/block', () => {
@@ -7,14 +7,14 @@ describe('Unit: combinator/block', () => {
     const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.throws(() => block(_ => [[]])(input(' \n', ctx)));
+      assert.throws(() => block(_ => new List<Data<string>>())(input(' \n', ctx)));
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return [[]]; })(input('\n', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return [[]]; })(input(' \n', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return [[]]; })(input('\n\n', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length - 1; return [[]]; })(input('\n\n', ctx)), ctx), [[], '\n']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input('\n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input(' \n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input('\n\n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(block(({ context }) => { context.position = context.source.length - 1; return new List<Data<string>>(); })(input('\n\n', ctx)), ctx), [[], '\n']);
     });
 
   });

package/src/combinator/control/constraint/contract.ts

@@ -1,4 +1,4 @@
-import { Parser, Input, Ctx, Node, Context, eval, failsafe } from '../../data/parser';
+import { Parser, Input, List, Data, Ctx, Node, Context, eval, failsafe } from '../../data/parser';
 import { matcher } from '../../../combinator';
 
 //export function contract<P extends Parser<unknown>>(patterns: string | RegExp | (string | RegExp)[], parser: P, cond: (nodes: readonly Data<P>[], rest: string) => boolean): P;
@@ -28,8 +28,8 @@ function guard<N>(f: (input: Input<Ctx>) => boolean, parser: Parser<N>): Parser<
       : undefined;
 }
 
-export function verify<P extends Parser<unknown>>(parser: P, cond: (nodes: readonly Node<P>[], context: Context<P>) => boolean): P;
-export function verify<N>(parser: Parser<N>, cond: (nodes: readonly N[], context: Ctx) => boolean): Parser<N> {
+export function verify<P extends Parser<unknown>>(parser: P, cond: (nodes: List<Data<Node<P>>>, context: Context<P>) => boolean): P;
+export function verify<N>(parser: Parser<N>, cond: (nodes: List<Data<N>>, context: Ctx) => boolean): Parser<N> {
   assert(parser);
   return failsafe(input => {
     const { context } = input;

package/src/combinator/control/constraint/line.test.ts

@@ -1,4 +1,4 @@
-import { input } from '../../data/parser';
+import { List, Data, input } from '../../data/parser';
 import { line } from './line';
 import { inspect } from '../../../debug.test';
 
@@ -7,15 +7,15 @@ describe('Unit: combinator/line', () => {
     const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(line(_ => [[]])(input('', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(line(_ => new List<Data<string>>())(input('', ctx)), ctx), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return [[]]; })(input(' ', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return [[]]; })(input('\n', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return [[]]; })(input('\n\n', ctx)), ctx), [[], '\n']);
-      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return [[]]; })(input(' \n', ctx)), ctx), [[], '']);
-      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length - 1; return [[]]; })(input(' \n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input(' ', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input('\n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input('\n\n', ctx)), ctx), [[], '\n']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length; return new List<Data<string>>(); })(input(' \n', ctx)), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(line(({ context }) => { context.position = context.source.length - 1; return new List<Data<string>>(); })(input(' \n', ctx)), ctx), [[], '']);
     });
 
   });

package/src/combinator/control/constraint/line.ts

@@ -18,7 +18,7 @@ export function line<N>(parser: Parser<N>): Parser<N> {
     if (result === undefined) return;
     if (!isBlank(source.slice(context.position, position + line.length))) return;
     context.position = position + line.length;
-    return [eval(result)];
+    return eval(result);
   });
 }
 

package/src/combinator/control/manipulation/clear.ts

@@ -1,6 +1,5 @@
-import { Parser, CtxOptions } from '../../data/parser';
-
+import { Parser, List, CtxOptions } from '../../data/parser';
 
 export function clear<D extends Parser<unknown, C>[], C extends CtxOptions>(parser: Parser<unknown, C, D>): Parser<never, C, D> {
-  return input => parser(input) && [[]];
+  return input => parser(input) && new List();
 }

package/src/combinator/control/manipulation/convert.ts

@@ -1,4 +1,4 @@
-import { Parser, Ctx, Context, subinput, failsafe } from '../../data/parser';
+import { Parser, List, Ctx, Context, subinput, failsafe } from '../../data/parser';
 
 export function convert<P extends Parser<unknown>>(conv: (source: string, context: Context<P>) => string, parser: P, continuous: boolean, empty?: boolean): P;
 export function convert<N>(conv: (source: string, context: Ctx) => string, parser: Parser<N>, continuous: boolean, empty = false): Parser<N> {
@@ -11,7 +11,7 @@ export function convert<N>(conv: (source: string, context: Ctx) => string, parse
     if (src === '') {
       if (!empty) return;
       context.position = source.length;
-      return [[]];
+      return new List();
     }
     assert(source.endsWith(src) || src.endsWith(source, position) || !continuous);
     if (continuous) {

package/src/combinator/control/manipulation/duplicate.ts

@@ -1,8 +1,7 @@
-import { Parser, Ctx, Node, Context, SubParsers } from '../../data/parser';
+import { Parser, List, Data, Ctx } from '../../data/parser';
 import { fmap } from '../monad/fmap';
 
-export function dup<P extends Parser<unknown[]>>(parser: Parser<Node<P>[number], Context<P>, SubParsers<P>>): P;
-export function dup<N, C extends Ctx, D extends Parser<unknown, C>[]>(parser: Parser<N, C, D>): Parser<N[], C, D>;
-export function dup<N>(parser: Parser<N>): Parser<N[]> {
-  return fmap(parser, nodes => [nodes]);
+export function dup<N, C extends Ctx, D extends Parser<unknown, C>[]>(parser: Parser<N, C, D>): Parser<List<Data<N>>, C, D>;
+export function dup<N>(parser: Parser<N>): Parser<List<Data<N>>> {
+  return fmap(parser, nodes => new List([new Data(nodes)]));
 }

package/src/combinator/control/manipulation/fence.ts

@@ -1,4 +1,4 @@
-import { Parser, Ctx, failsafe } from '../../data/parser';
+import { Parser, List, Data, Ctx, failsafe } from '../../data/parser';
 import { firstline, isBlank } from '../constraint/line';
 import { push } from 'spica/array';
 
@@ -47,6 +47,6 @@ export function fence<C extends Ctx, D extends Parser<unknown, C>[]>(opener: Reg
       }
       context.position += line.length;
     }
-    return [push([block, overflow, closer], matches)];
+    return new List(push([block, overflow, closer], matches).map(str => new Data(str)));
   });
 }

package/src/combinator/control/manipulation/indent.test.ts

@@ -1,5 +1,5 @@
 import { indent } from './indent';
-import { input } from '../../data/parser';
+import { List, Data, input } from '../../data/parser';
 import { inspect } from '../../../debug.test';
 
 describe('Unit: combinator/indent', () => {
@@ -7,7 +7,7 @@ describe('Unit: combinator/indent', () => {
     const { context: ctx } = input('', {});
 
     it('valid', () => {
-      const parser = indent(({ context }) => { context.position = context.source.length; return [[context.source]]; });
+      const parser = indent(({ context }) => { context.position = context.source.length; return new List([new Data(context.source)]); });
       assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(input(' ', ctx)), ctx), undefined);
       assert.deepStrictEqual(inspect(parser(input('  ', ctx)), ctx), undefined);

package/src/combinator/control/manipulation/indent.ts

@@ -1,4 +1,4 @@
-import { Parser, subinput, eval, failsafe } from '../../data/parser';
+import { Parser, List, Data, subinput, eval, failsafe } from '../../data/parser';
 import { some } from '../../data/parser/some';
 import { block } from '../constraint/block';
 import { line } from '../constraint/line';
@@ -24,15 +24,15 @@ export function indent<N>(opener: RegExp | Parser<N>, parser: Parser<N> | boolea
       some(line(open(indent, ({ context }) => {
         const { source, position } = context;
         context.position = source.length;
-        return [[source.slice(position)]];
+        return new List([new Data(source.slice(position))]);
       }))),
     ([indent]) => indent.length * 2 + +(indent[0] === ' '), {})), separation),
     (lines, context) => {
       assert(parser = parser as Parser<N>);
-      const result = parser(subinput(trimBlockEnd(lines.join('')), context));
+      const result = parser(subinput(trimBlockEnd(lines.foldl((acc, node) => acc + node.value, '')), context));
       assert(result);
       return result
-        ? [eval(result)]
+        ? eval(result)
         : undefined;
     }));
 }

package/src/combinator/control/manipulation/reverse.ts

@@ -1,8 +1,8 @@
-import { Parser } from '../../data/parser';
+import { Parser, List, Data } from '../../data/parser';
 import { fmap } from '../monad/fmap';
 
 export function reverse<P extends Parser<unknown>>(parser: P): P;
 export function reverse<N>(parser: Parser<N>): Parser<N> {
-  return fmap(parser, nodes => nodes.reverse());
+  return fmap(parser, nodes => nodes.foldr((node, acc) => acc.push(nodes.delete(node)) && acc, new List<Data<N>>()));
 }
 

package/src/combinator/control/manipulation/scope.ts

@@ -8,7 +8,7 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>): Parser<N> {
   return failsafe(({ context }) => {
     const { source, position } = context;
     if (position === source.length) return;
-    const src = eval(match({ context }))?.[0] ?? '';
+    const src = eval(match({ context }))?.head?.value ?? '';
     assert(source.startsWith(src, position));
     if (src === '') return;
     context.range = src.length;
@@ -21,7 +21,7 @@ export function focus<N>(scope: string | RegExp, parser: Parser<N>): Parser<N> {
     context.source = source;
     context.offset -= position;
     if (result === undefined) return;
-    return [eval(result)];
+    return eval(result);
   });
 }
 
@@ -48,7 +48,6 @@ export function rewrite<N>(scope: Parser<unknown>, parser: Parser<N>): Parser<N>
     context.source = source;
     context.offset -= position;
     if (res2 === undefined) return;
-    assert(context.position === position + src.length);
-    return [eval(res2)];
+    return eval(res2);
   });
 }

package/src/combinator/control/manipulation/surround.ts

@@ -1,40 +1,39 @@
-import { Parser, Result, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, failsafe } from '../../data/parser';
+import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, failsafe } from '../../data/parser';
 import { matcher, clear } from '../../../combinator';
-import { unshift, push } from 'spica/array';
 
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: false,
-  f?: (rss: [S[], SubNode<P>[], S[]], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], SubNode<P>[] | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  f?: (rss: [List<Data<S>>, List<Data<SubNode<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: IntermediateParser<P>, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: boolean,
-  f?: (rss: [S[], SubNode<P>[] | undefined, S[]], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], SubNode<P>[] | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  f?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [List<Data<S>>, List<Data<SubNode<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: false,
-  f?: (rss: [S[], Node<P>[], S[]], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], Node<P>[] | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  f?: (rss: [List<Data<S>>, List<Data<Node<P>>>, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
 ): P;
 export function surround<P extends Parser<unknown>, S = string>(
   opener: string | RegExp | Parser<S, Context<P>>, parser: P, closer: string | RegExp | Parser<S, Context<P>>,
   optional?: boolean,
-  f?: (rss: [S[], Node<P>[] | undefined, S[]], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
-  g?: (rss: [S[], Node<P>[] | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  f?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined, List<Data<S>>], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
+  g?: (rss: [List<Data<S>>, List<Data<Node<P>>> | undefined], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>,
   backtracks?: readonly number[],
 ): P;
 export function surround<N>(
   opener: string | RegExp | Parser<N>, parser: Parser<N>, closer: string | RegExp | Parser<N>,
   optional: boolean = false,
-  f?: (rss: [N[], N[], N[]], context: Ctx) => Result<N>,
-  g?: (rss: [N[], N[] | undefined], context: Ctx) => Result<N>,
+  f?: (rss: [List<Data<N>>, List<Data<N>>, List<Data<N>>], context: Ctx) => Result<N>,
+  g?: (rss: [List<Data<N>>, List<Data<N>> | undefined], context: Ctx) => Result<N>,
   backtracks: readonly number[] = [],
 ): Parser<N> {
   switch (typeof opener) {
@@ -88,7 +87,7 @@ export function surround<N>(
     context.range = context.position - position;
     const result = f
       ? f([nodesO, nodesM!, nodesC], context)
-      : [push(nodesM ? unshift(nodesO, nodesM) : nodesO, nodesC)] satisfies [N[]];
+      : nodesO.import(nodesM ?? new List()).import(nodesC);
     if (result) {
       context.linebreak ||= linebreak;
     }
@@ -157,8 +156,8 @@ export function setBacktrack(
   position: number,
   length: number = 1,
 ): void {
-  const { source, state = 0 } = context;
-  if (state === 0) return;
+  // 以降バックトラックの可能性がなく記録不要の場合もあるが判別が面倒なので省略
+  const { source } = context;
   if (position === source.length) return;
   if (length === 0) return;
   for (const backtrack of backtracks) {

package/src/combinator/control/monad/bind.ts

@@ -1,10 +1,10 @@
-import { Parser, Result, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, failsafe } from '../../data/parser';
+import { Parser, Result, List, Data, Ctx, Node, Context, SubParsers, SubNode, IntermediateParser, eval, failsafe } from '../../data/parser';
 
-export function bind<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: SubNode<P>[], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
-export function bind<P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
-export function bind<N, P extends Parser<unknown>>(parser: Parser<N, Context<P>, SubParsers<P>>, f: (nodes: N[], context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
-export function bind<U, P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], context: Context<P>) => Result<U, Context<P>, SubParsers<P>>): Parser<U, Context<P>, SubParsers<P>>;
-export function bind<N, U>(parser: Parser<N>, f: (nodes: N[], context: Ctx) => Result<U>): Parser<U> {
+export function bind<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: List<Data<SubNode<P>>>, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
+export function bind<P extends Parser<unknown>>(parser: P, f: (nodes: List<Data<Node<P>>>, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
+export function bind<N, P extends Parser<unknown>>(parser: Parser<N, Context<P>, SubParsers<P>>, f: (nodes: List<Data<N>>, context: Context<P>) => Result<Node<P>, Context<P>, SubParsers<P>>): P;
+export function bind<U, P extends Parser<unknown>>(parser: P, f: (nodes: List<Data<Node<P>>>, context: Context<P>) => Result<U, Context<P>, SubParsers<P>>): Parser<U, Context<P>, SubParsers<P>>;
+export function bind<N, U>(parser: Parser<N>, f: (nodes: List<Data<N>>, context: Ctx) => Result<U>): Parser<U> {
   assert(parser);
   return failsafe(input => {
     const { context } = input;

package/src/combinator/control/monad/fmap.ts

@@ -1,10 +1,10 @@
-import { Parser, Ctx, SubParsers, Node, Context, IntermediateParser, SubNode } from '../../data/parser';
+import { Parser, List, Data, Ctx, SubParsers, Node, Context, IntermediateParser, SubNode } from '../../data/parser';
 import { bind } from './bind';
 
-export function fmap<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: SubNode<P>[], context: Context<P>) => Node<P>[]): P;
-export function fmap<P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], context: Context<P>) => Node<P>[]): P;
-export function fmap<N, P extends Parser<unknown>>(parser: Parser<N, Context<P>, SubParsers<P>>, f: (nodes: N[], context: Context<P>) => Node<P>[]): P;
-export function fmap<U, P extends Parser<unknown>>(parser: P, f: (nodes: Node<P>[], context: Context<P>) => U[]): Parser<U, Context<P>, SubParsers<P>>;
-export function fmap<N, U>(parser: Parser<N>, f: (nodes: N[], context: Ctx) => U[]): Parser<U> {
-  return bind(parser, (nodes, context) => [f(nodes, context)]);
+export function fmap<P extends Parser<unknown>>(parser: IntermediateParser<P>, f: (nodes: List<Data<SubNode<P>>>, context: Context<P>) => List<Data<Node<P>>>): P;
+export function fmap<P extends Parser<unknown>>(parser: P, f: (nodes: List<Data<Node<P>>>, context: Context<P>) => List<Data<Node<P>>>): P;
+export function fmap<N, P extends Parser<unknown>>(parser: Parser<N, Context<P>, SubParsers<P>>, f: (nodes: List<Data<N>>, context: Context<P>) => List<Data<Node<P>>>): P;
+export function fmap<U, P extends Parser<unknown>>(parser: P, f: (nodes: List<Data<Node<P>>>, context: Context<P>) => List<Data<U>>): Parser<U, Context<P>, SubParsers<P>>;
+export function fmap<N, U>(parser: Parser<N>, f: (nodes: List<Data<N>>, context: Ctx) => List<Data<U>>): Parser<U> {
+  return bind(parser, (nodes, context) => f(nodes, context));
 }

package/src/combinator/data/data.ts

@@ -0,0 +1,135 @@
+// Memory-efficient flexible list.
+
+export class List<N extends List.Node = List.Node> {
+  constructor(nodes?: ArrayLike<N>) {
+    if (nodes === undefined) return;
+    for (let i = 0; i < nodes.length; ++i) {
+      this.push(nodes[i]);
+    }
+  }
+  public length = 0;
+  public head?: N = undefined;
+  public get tail(): N | undefined {
+    return this.head?.next;
+  }
+  public get last(): N | undefined {
+    return this.head?.prev;
+  }
+  public insert(node: N, before?: N): N {
+    assert(!node.next);
+    if (++this.length === 1) {
+      return this.head = node.next = node.prev = node;
+    }
+    assert(node !== before);
+    const next = node.next = before ?? this.head!;
+    const prev = node.prev = next.prev!;
+    return next.prev = prev.next = node;
+  }
+  public delete(node: N): N {
+    assert(node.next);
+    assert(this.length > 0);
+    if (--this.length === 0) {
+      this.head = undefined;
+    }
+    else {
+      const { next, prev } = node;
+      if (node === this.head) {
+        this.head = next;
+      }
+      // Error if not used.
+      prev!.next = next;
+      next!.prev = prev;
+    }
+    node.next = node.prev = undefined;
+    return node;
+  }
+  public unshift(node: N): N {
+    assert(!node.next);
+    return this.head = this.insert(node, this.head);
+  }
+  public push(node: N): N {
+    assert(!node.next);
+    return this.insert(node, this.head);
+  }
+  public shift(): N | undefined {
+    if (this.length === 0) return;
+    return this.delete(this.head!);
+  }
+  public pop(): N | undefined {
+    if (this.length === 0) return;
+    return this.delete(this.head!.prev!);
+  }
+  public import(list: List<N>, before?: N): this {
+    assert(list !== this);
+    if (list.length === 0) return this;
+    if (this.length === 0) {
+      this.head = list.head;
+      this.length += list.length;
+      list.clear();
+      return this;
+    }
+    const head = list.head!;
+    const last = list.last!;
+    const next = last.next = before ?? this.head!;
+    const prev = head.prev = next.prev!;
+    next.prev = last;
+    prev.next = head;
+    this.length += list.length;
+    list.clear();
+    return this;
+  }
+  public clear(): void {
+    this.length = 0;
+    this.head = undefined;
+  }
+  public *[Symbol.iterator](): Iterator<N, undefined, undefined> {
+    for (let node = this.head; node && this.head;) {
+      const next = node.next;
+      yield node;
+      node = next;
+      if (node === this.head) break;
+    }
+  }
+  public flatMap<T extends List.Node>(f: (node: N) => List<T>): List<T> {
+    const acc = new List<T>();
+    for (let node = this.head; node && this.head;) {
+      const next = node.next;
+      acc.import(f(node));
+      node = next;
+      if (node === this.head) break;
+    }
+    return acc;
+  }
+  public foldl<T>(f: (acc: T, node: N) => T, acc: T): T {
+    for (let node = this.head; node && this.head;) {
+      const next = node.next;
+      acc = f(acc, node);
+      node = next;
+      if (node === this.head) break;
+    }
+    return acc;
+  }
+  public foldr<T>(f: (node: N, acc: T) => T, acc: T): T {
+    for (let node = this.head?.prev; node && this.head;) {
+      const prev = node.prev;
+      acc = f(node, acc);
+      if (node === this.head) break;
+      node = prev;
+    }
+    return acc;
+  }
+  public find(f: (node: N) => unknown): N | undefined {
+    for (let node = this.head; node && this.head;) {
+      const next = node.next;
+      if (f(node)) return node;
+      node = next;
+      if (node === this.head) break;
+    }
+  }
+}
+export namespace List {
+  export class Node {
+    public next?: this = undefined;
+    public prev?: this = undefined;
+  }
+}