securemark 0.293.4 → 0.294.0

package/src/combinator/data/parser/context.test.ts

@@ -1,7 +1,7 @@
-import { Parser, Ctx, CtxOptions, input } from '../parser';
+import { Parser, List, Data, Ctx, CtxOptions, input, eval } from '../parser';
 import { some } from './some';
-import { reset, context } from './context';
-import { creation } from './context';
+import { reset, context, creation } from './context';
+import { unwrap } from '../../../parser/util';
 
 describe('Unit: combinator/data/parser/context', () => {
   interface Context extends CtxOptions {
@@ -12,26 +12,26 @@ describe('Unit: combinator/data/parser/context', () => {
     const parser: Parser<number> = some(creation(1,
       ({ context }) => {
         context.position += 1;
-        return [[context.resources?.clock ?? NaN]];
+        return new List([new Data(context.resources?.clock ?? NaN)]);
       }));
 
     it('root', () => {
       const base: Context = { resources: { clock: 3, recursions: [1] } };
       const ctx: Context = {};
-      assert.deepStrictEqual(reset(base, parser)(input('123', ctx)), [[3, 2, 1]]);
+      assert.deepStrictEqual([...unwrap(eval(reset(base, parser)(input('123', ctx)))!)], [3, 2, 1]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === undefined);
       assert.throws(() => reset(base, parser)(input('1234', ctx)));
-      assert(ctx.resources?.clock === 0);
+      assert(ctx.resources?.clock === undefined);
     });
 
     it('node', () => {
       const base: Context = { resources: { clock: 3, recursions: [1] } };
-      const ctx: Context = { resources: { clock: 1, recursions: [1] } };
-      assert.deepStrictEqual(reset(base, parser)(input('1', ctx)), [[1]]);
+      const ctx: Context = { resources: { clock: 2, recursions: [1] } };
+      assert.deepStrictEqual([...unwrap(eval(reset(base, parser)(input('1', ctx)))!)], [2]);
       assert(base.resources?.clock === 3);
-      assert(ctx.resources?.clock === 0);
-      assert.throws(() => reset(base, parser)(input('1', ctx)));
+      assert(ctx.resources?.clock === 1);
+      assert.throws(() => reset(base, parser)(input('12', ctx)));
       assert(ctx.resources?.clock === 0);
     });
 
@@ -41,16 +41,17 @@ describe('Unit: combinator/data/parser/context', () => {
     const parser: Parser<boolean, Context & Ctx> = some(creation(1,
       ({ context }) => {
         context.position += 1;
-        return [[context.status!]];
+        return new List([new Data(context.status!)]);
       }));
 
     it('', () => {
       const base: Context = { status: true };
-      const ctx: Context = { resources: { clock: 3, recursions: [1] } };
-      assert.deepStrictEqual(context(base, parser)(input('123', ctx)), [[true, true, true]]);
-      assert(ctx.resources?.clock === 0);
+      const ctx: Context = { resources: { clock: 2, recursions: [1] } };
+      assert.deepStrictEqual([...unwrap(eval(context(base, parser)(input('1', ctx)))!)], [true]);
+      assert(base.resources?.clock === undefined);
+      assert(ctx.resources?.clock === 1);
       assert(ctx.status === undefined);
-      assert.throws(() => reset(base, parser)(input('1', ctx)));
+      assert.throws(() => context(base, parser)(input('12', ctx)));
       assert(ctx.resources?.clock === 0);
       assert(ctx.status === true);
     });

package/src/combinator/data/parser/context.ts

@@ -1,5 +1,5 @@
 import { min } from 'spica/alias';
-import { Parser, Result, Ctx, CtxOptions, Node, Context } from '../../data/parser';
+import { Parser, Result, List, Data, Ctx, CtxOptions, Node, Context } from '../../data/parser';
 import { clone } from 'spica/assign';
 
 export function reset<P extends Parser<unknown>>(base: CtxOptions, parser: P): P;
@@ -9,7 +9,8 @@ export function reset<N>(base: Ctx, parser: Parser<N>): Parser<N> {
   const changes = Object.entries(base);
   const values = Array(changes.length);
   return ({ context }) =>
-    apply(parser, context, changes, values, true);
+    // 大域離脱時の汚染回避のため複製
+    apply(parser, { ...context }, changes, values, true);
 }
 
 export function context<P extends Parser<unknown>>(base: CtxOptions, parser: P): P;
@@ -172,7 +173,7 @@ export function matcher(pattern: string | RegExp, advance: boolean): Parser<stri
         if (advance) {
           context.position += pattern.length;
         }
-        return [[pattern]];
+        return new List([new Data(pattern)]);
       };
     case 'object':
       assert(pattern.sticky);
@@ -185,7 +186,7 @@ export function matcher(pattern: string | RegExp, advance: boolean): Parser<stri
         if (advance) {
           context.position += src.length;
         }
-        return [[src]];
+        return new List([new Data(src)]);
       };
   }
 }

package/src/combinator/data/parser/inits.ts

@@ -1,27 +1,26 @@
-import { Parser, CtxOptions, Node, Context, SubParsers, SubNode, eval, Ctx } from '../parser';
-import { push } from 'spica/array';
+import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode, eval, Ctx } from '../parser';
 
-export function inits<P extends Parser<unknown, Ctx>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[]) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function inits<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[]) => boolean): Parser<N, CtxOptions, D> {
+export function inits<P extends Parser<unknown, Ctx>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function inits<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return input => {
     const { context } = input;
     const { source, position } = context;
-    let nodes: N[] | undefined;
+    let nodes: List<Data<N>> | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (context.position === source.length) break;
       if (context.delimiters?.match(input)) break;
       const result = parsers[i](input);
       if (result === undefined) break;
       nodes = nodes
-        ? push(nodes, eval(result))
+        ? nodes.import(eval(result))
         : eval(result);
       if (resume?.(eval(result)) === false) break;
     }
     assert(context.position >= position);
     return nodes && context.position > position
-      ? [nodes]
+      ? nodes
       : undefined;
   };
 }

package/src/combinator/data/parser/sequence.test.ts

@@ -1,4 +1,4 @@
-import { Parser, input } from '../parser';
+import { Parser, List, Data, input } from '../parser';
 import { sequence } from './sequence';
 import { inspect } from '../../../debug.test';
 
@@ -6,12 +6,12 @@ describe('Unit: combinator/data/parser/sequence', () => {
   describe('sequence', () => {
     const a: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'a'
-        ? void ++context.position || [['A']]
+        ? void ++context.position || new List([new Data('A')])
         : undefined;
     };
     const b: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'b'
-        ? void ++context.position || [['B']]
+        ? void ++context.position || new List([new Data('B')])
         : undefined;
     };
     const ab = sequence<Parser<string, {}, [typeof a, typeof b]>>([a, b]);

package/src/combinator/data/parser/sequence.ts

@@ -1,27 +1,26 @@
-import { Parser, CtxOptions, Node, Context, SubParsers, SubNode, eval } from '../parser';
-import { push } from 'spica/array';
+import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode, eval } from '../parser';
 
-export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[]) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function sequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[]) => boolean): Parser<N, CtxOptions, D> {
+export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function sequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return input => {
     const { context } = input;
     const { source, position } = context;
-    let nodes: N[] | undefined;
+    let nodes: List<Data<N>> | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (context.position === source.length) return;
       if (context.delimiters?.match(input)) return;
       const result = parsers[i](input);
       if (result === undefined) return;
       nodes = nodes
-        ? push(nodes, eval(result))
+        ? nodes.import(eval(result))
         : eval(result);
       if (resume?.(eval(result)) === false) return;
     }
     assert(context.position >= position);
     return nodes && context.position > position
-      ? [nodes]
+      ? nodes
       : undefined;
   };
 }

package/src/combinator/data/parser/some.test.ts

@@ -1,4 +1,4 @@
-import { Parser, input } from '../parser';
+import { Parser, List, Data, input } from '../parser';
 import { union } from './union';
 import { some } from './some';
 import { inspect } from '../../../debug.test';
@@ -7,12 +7,12 @@ describe('Unit: combinator/data/parser/some', () => {
   describe('some', () => {
     const a: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'a'
-        ? void ++context.position || [['A']]
+        ? void ++context.position || new List([new Data('A')])
         : undefined;
     };
     const b: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'b'
-        ? void ++context.position || [['B']]
+        ? void ++context.position || new List([new Data('B')])
         : undefined;
     };
     const ab = union<Parser<string, {}, [typeof a, typeof b]>>([a, b]);

package/src/combinator/data/parser/some.ts

@@ -1,4 +1,4 @@
-import { Parser, eval } from '../parser';
+import { Parser, List, Data, eval } from '../parser';
 import { Delimiters } from './context/delimiter';
 
 type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
@@ -18,7 +18,7 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
     const { context } = input;
     const { source, position } = context;
     //assert(context.backtracks ??= {});
-    let nodes: N[] | undefined;
+    let nodes: List<Data<N>> | undefined;
     if (delims.length > 0) {
       context.delimiters ??= new Delimiters();
       context.delimiters.push(delims);
@@ -30,7 +30,7 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
       const result = parser(input);
       if (result === undefined) break;
       nodes = nodes
-        ? (nodes.push(...eval(result)), nodes)
+        ? nodes.import(eval(result))
         : eval(result);
       if (limit >= 0 && context.position - position > limit) break;
     }
@@ -39,7 +39,7 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
     }
     assert(context.position >= position);
     return nodes && context.position > position
-      ? [nodes]
+      ? nodes
       : undefined;
   };
 }

package/src/combinator/data/parser/subsequence.test.ts

@@ -1,4 +1,4 @@
-import { Parser, input } from '../parser';
+import { Parser, List, Data, input } from '../parser';
 import { subsequence } from './subsequence';
 import { inspect } from '../../../debug.test';
 
@@ -6,17 +6,17 @@ describe('Unit: combinator/data/parser/subsequence', () => {
   describe('subsequence', () => {
     const a: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'a'
-        ? void ++context.position || [['A']]
+        ? void ++context.position || new List([new Data('A')])
         : undefined;
     };
     const b: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'b'
-        ? void ++context.position || [['B']]
+        ? void ++context.position || new List([new Data('B')])
         : undefined;
     };
     const c: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'c'
-        ? void ++context.position || [['C']]
+        ? void ++context.position || new List([new Data('C')])
         : undefined;
     };
     const abc = subsequence<Parser<string, {}, [typeof a, typeof b, typeof c]>>([a, b, c]);

package/src/combinator/data/parser/subsequence.ts

@@ -1,9 +1,9 @@
-import { Parser, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
 import { union } from './union';
 import { inits } from './inits';
 
-export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[]) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function subsequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[]) => boolean): Parser<N, CtxOptions, D> {
+export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function subsequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
   assert(parsers.every(f => f));
   return union(
     parsers.map((_, i) =>

package/src/combinator/data/parser/tails.ts

@@ -1,8 +1,8 @@
-import { Parser, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Data, CtxOptions, Node, Context, SubParsers, SubNode } from '../parser';
 import { union } from './union';
 import { sequence } from './sequence';
 
-export function tails<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubNode<P>[]) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function tails<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: N[]) => boolean): Parser<N, CtxOptions, D> {
+export function tails<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
+export function tails<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, CtxOptions, D> {
   return union(parsers.map((_, i) => sequence(parsers.slice(i), resume)) as D);
 }

package/src/combinator/data/parser/union.test.ts

@@ -1,4 +1,4 @@
-import { Parser, input } from '../parser';
+import { Parser, List, Data, input } from '../parser';
 import { union } from './union';
 import { inspect } from '../../../debug.test';
 
@@ -6,12 +6,12 @@ describe('Unit: combinator/data/parser/union', () => {
   describe('union', () => {
     const a: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'a'
-        ? void ++context.position || [['A']]
+        ? void ++context.position || new List([new Data('A')])
         : undefined;
     };
     const b: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'b'
-        ? void ++context.position || [['B']]
+        ? void ++context.position || new List([new Data('B')])
         : undefined;
     };
     const ab = union<Parser<string, {}, [typeof a, typeof b]>>([a, b]);

package/src/combinator/data/parser.ts

@@ -1,3 +1,4 @@
+import { List } from './data';
 import { Delimiters } from './parser/context/delimiter';
 
 export type Parser<N, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any>
@@ -6,9 +7,16 @@ export interface Input<C extends CtxOptions = CtxOptions> {
   readonly context: C & Ctx;
 }
 export type Result<N, C extends CtxOptions = CtxOptions, D extends Parser<unknown, C>[] = any>
-  = readonly [N[], C, D]
-  | readonly [N[]]
+  = readonly [never, C, D]
+  | List<Data<N>>
   | undefined;
+export { List };
+export class Data<N> implements List.Node {
+  constructor(public value: N) {
+  }
+  public next?: this = undefined;
+  public prev?: this = undefined;
+}
 export interface Ctx extends CtxOptions {
   source: string;
   position: number;
@@ -71,12 +79,13 @@ export function clean<C extends Ctx>(context: C): C {
 }
 
 export { eval_ as eval };
-function eval_<N>(result: NonNullable<Result<N>>, default_?: N[]): N[];
-function eval_<N>(result: Result<N>, default_: N[]): N[];
-function eval_<N>(result: Result<N>, default_?: undefined): N[] | undefined;
-function eval_<N>(result: Result<N>, default_?: N[]): N[] | undefined {
+function eval_<N>(result: NonNullable<Result<N>>, default_?: List<Data<N>>): List<Data<N>>;
+function eval_<N>(result: Result<N>, default_: List<Data<N>>): List<Data<N>>;
+function eval_<N>(result: Result<N>, default_?: undefined): List<Data<N>> | undefined;
+function eval_<N>(result: Result<N>, default_?: List<Data<N>>): List<Data<N>> | undefined {
+  assert(!Array.isArray(result));
   return result
-    ? result[0]
+    ? result as List<Data<N>>
     : default_;
 }
 

package/src/debug.test.ts

@@ -2,11 +2,12 @@ import { Result, Ctx, eval } from './combinator/data/parser';
 import { html, define } from 'typed-dom/dom';
 import { querySelectorWith, querySelectorAllWith } from 'typed-dom/query';
 
-export function inspect(result: Result<HTMLElement | string>, ctx: Ctx, until: number | string = Infinity): [string[], string] | undefined {
+export function inspect(result: Result<DocumentFragment | HTMLElement | string>, ctx: Ctx, until: number | string = Infinity): [string[], string] | undefined {
   return result && [
-    eval(result).map(node => {
+    eval(result).foldl<string[]>((acc, { value: node }) => {
       assert(node);
-      if (typeof node === 'string') return node;
+      if (typeof node === 'string') return acc.push(node), acc;
+      if (node instanceof DocumentFragment) return acc.push(html('div', [node]).innerHTML), acc;
       node = node.cloneNode(true);
       assert(!querySelectorWith(node, '.invalid[data-invalid-message$="."]'));
       querySelectorAllWith(node, '.invalid').forEach(el => {
@@ -31,8 +32,8 @@ export function inspect(result: Result<HTMLElement | string>, ctx: Ctx, until: n
       else {
         assert(el.innerHTML.startsWith(node.outerHTML.slice(0, until)));
       }
-      return normalize(node.outerHTML.slice(0, until));
-    }),
+      return acc.push(normalize(node.outerHTML.slice(0, until))), acc;
+    }, []),
     ctx.source.slice(ctx.position),
   ];
 }

package/src/parser/api/bind.ts

@@ -1,7 +1,7 @@
 import { ParserSettings, Progress } from '../../..';
 import { MarkdownParser } from '../../../markdown';
 import { input, eval } from '../../combinator/data/parser';
-import { segment, validate, MAX_INPUT_SIZE } from '../segment';
+import { segment } from '../segment';
 import { header } from '../header';
 import { block } from '../block';
 import { normalize } from './normalize';
@@ -44,12 +44,9 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   function* parse(source: string): Generator<Progress, undefined, undefined> {
     if (settings.chunk && revision) throw new Error('Chunks cannot be updated');
     const url = headers(source).find(field => field.toLowerCase().startsWith('url:'))?.slice(4).trim() ?? '';
-    source = normalize(validate(source, MAX_INPUT_SIZE) ? source : source.slice(0, MAX_INPUT_SIZE + 1));
-    // Change the object identity.
-    context = {
-      ...context,
-      url: url ? new ReadonlyURL(url as ':') : undefined,
-    };
+    source = normalize(source);
+    // @ts-expect-error
+    context.url = url ? new ReadonlyURL(url as ':') : undefined;
     const rev = revision = Symbol();
     const sourceSegments: string[] = [];
     for (const seg of segment(source)) {
@@ -78,7 +75,8 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
     for (; index < sourceSegments.length - last; ++index) {
       assert(rev === revision);
       const seg = sourceSegments[index];
-      const es = eval(header(input(seg, { header: index === 0 } as MarkdownParser.Context)) || block(input(seg, context)), []);
+      const es = eval(header(input(seg, { header: index === 0 } as MarkdownParser.Options)) || block(input(seg, context)))
+        ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? [];
       blocks.splice(index, 0, [seg, es, url]);
       if (es.length === 0) continue;
       // All deletion processes always run after all addition processes have done.

package/src/parser/api/header.ts

@@ -14,7 +14,7 @@ export function headers(source: string): string[] {
 function parse(source: string): [HTMLElement, number] | [] {
   const i = input(source, {});
   const result = h(i);
-  const [el] = eval(result, []);
+  const el = eval(result)?.head?.value;
   return el?.tagName === 'ASIDE'
     ? [el, i.context.position]
     : [];

package/src/parser/api/normalize.ts

@@ -60,12 +60,10 @@ export const invisibleHTMLEntityNames = [
 ] as const;
 const unreadableHTMLEntityNames: readonly string[] = invisibleHTMLEntityNames.slice(2);
 const unreadableEscapableCharacters = unreadableHTMLEntityNames
-  .map(name => eval(unsafehtmlentity(input(`&${name};`, {})))![0]);
+  .map(name => eval(unsafehtmlentity(input(`&${name};`, {})))!.head!.value);
 assert(unreadableEscapableCharacters.length === unreadableHTMLEntityNames.length);
 assert(unreadableEscapableCharacters.every(c => c.length === 1));
-const unreadableEscapableCharacter = new RegExp(`[${
-  [...new Set<string>(unreadableEscapableCharacters)].join('')
-}]`, 'g');
+const unreadableEscapableCharacter = new RegExp(`[${unreadableEscapableCharacters.join('')}]`, 'g');
 assert(!unreadableEscapableCharacter.source.includes('&'));
 
 // https://www.pandanoir.info/entry/2018/03/11/193000

package/src/parser/api/parse.ts

@@ -34,7 +34,9 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
   const node = frag();
   let index = 0;
   for (const seg of segment(source)) {
-    node.append(...eval(header(input(seg, { header: index++ === 0 } as MarkdownParser.Context)) || block(input(seg, context)), []));
+    node.append(
+      ...eval(header(input(seg, { header: index++ === 0 } as MarkdownParser.Context)) || block(input(seg, context)))
+        ?.foldl<HTMLElement[]>((acc, { value }) => void acc.push(value) || acc, []) ?? []);
   }
   assert(opts.id !== '' || !node.querySelector('[id], .index[href], .label[href], .annotation > a[href], .reference > a[href]'));
   if (opts.test) return node;

package/src/parser/block/blockquote.ts

@@ -1,8 +1,10 @@
 import { BlockquoteParser } from '../block';
 import { Recursion } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, some, creation, recursion, block, validate, rewrite, open, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
+import { unwrap } from '../util';
 import { parse } from '../api/parse';
 import { html, defrag } from 'typed-dom/dom';
 
@@ -26,9 +28,9 @@ const source: BlockquoteParser.SourceParser = lazy(() => fmap(
       convert(unindent, source, false, true)),
     rewrite(
       some(contentline, opener),
-      convert(unindent, fmap(autolink, ns => [html('pre', defrag(ns))]), false, true)),
+      convert(unindent, fmap(autolink, ns => new List([new Data(html('pre', defrag(unwrap(ns))))])), false, true)),
   ]))),
-  ns => [html('blockquote', ns)]));
+  ns => new List([new Data(html('blockquote', unwrap(ns)))])));
 
 const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
   some(recursion(Recursion.blockquote, union([
@@ -48,7 +50,7 @@ const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
           },
         }, context);
         context.position = source.length;
-        return [[html('section', [document, html('h2', 'References'), references])]];
+        return new List([new Data(html('section', [document, html('h2', 'References'), references]))]);
       }, false, true))),
   ]))),
-  ns => [html('blockquote', ns)]));
+  ns => new List([new Data(html('blockquote', unwrap(ns)))])));

package/src/parser/block/codeblock.ts

@@ -1,8 +1,8 @@
 import { CodeBlockParser } from '../block';
-import { input, eval } from '../../combinator/data/parser';
+import { List, Data, subinput, eval } from '../../combinator/data/parser';
 import { block, fence, clear, fmap } from '../../combinator';
 import { autolink } from '../autolink';
-import { invalid } from '../util';
+import { unwrap, invalid } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 const opener = /(`{3,})(?!`)([^\n]*)(?:$|\n)/y;
@@ -17,7 +17,8 @@ export const segment_: CodeBlockParser.SegmentParser = block(
 export const codeblock: CodeBlockParser = block(fmap(
   fence(opener, 300),
   // Bug: Type mismatch between outer and inner.
-  ([body, overflow, closer, opener, delim, param]: string[], context) => {
+  (nodes, context) => {
+    const [body, overflow, closer, opener, delim, param] = unwrap<string>(nodes);
     const params = param.match(/(?:\\.?|\S)+/g)?.reduce<{
       lang?: string;
       path?: string;
@@ -49,7 +50,7 @@ export const codeblock: CodeBlockParser = block(fmap(
         : params[name] = value;
       return params;
     }, {}) ?? {};
-    if (!closer || overflow || params.invalid) return [html('pre', {
+    if (!closer || overflow || params.invalid) return new List([new Data(html('pre', {
       class: 'invalid',
       translate: 'no',
       ...invalid(
@@ -60,7 +61,7 @@ export const codeblock: CodeBlockParser = block(fmap(
           : overflow
             ? `Invalid trailing line after the closing delimiter "${delim}"`
             : params.invalid!),
-    }, `${opener}${body}${overflow || closer}`)];
+    }, `${opener}${body}${overflow || closer}`))]);
     const el = html('pre',
       {
         class: params.lang ? `code language-${params.lang}` : 'text',
@@ -72,6 +73,6 @@ export const codeblock: CodeBlockParser = block(fmap(
       params.lang
         ? context.caches?.code?.get(`${params.lang ?? ''}\n${body.slice(0, -1)}`)?.cloneNode(true).childNodes ||
           body.slice(0, -1) || undefined
-        : defrag(eval(autolink(input(body.slice(0, -1), { ...context })), [])));
-    return [el];
+        : defrag(unwrap(eval(autolink(subinput(body.slice(0, -1), context)), new List()))));
+    return new List([new Data(el)]);
   }));

package/src/parser/block/dlist.ts

@@ -1,10 +1,11 @@
 import { DListParser } from '../block';
 import { State } from '../context';
+import { List, Data } from '../../combinator/data/parser';
 import { union, inits, some, state, block, line, validate, rewrite, open, lazy, fmap } from '../../combinator';
 import { inline, indexee, indexer, dataindex } from '../inline';
 import { anyline } from '../source';
 import { visualize, trimBlank, trimBlankEnd } from '../visibility';
-import { push } from 'spica/array';
+import { unwrap } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
 export const dlist: DListParser = lazy(() => block(fmap(validate(
@@ -14,13 +15,13 @@ export const dlist: DListParser = lazy(() => block(fmap(validate(
     some(term)),
     some(desc),
   ]))),
-  es => [html('dl', fillTrailingDescription(es))])));
+  ns => new List([new Data(html('dl', unwrap(fillTrailingDescription(ns))))]))));
 
 const term: DListParser.TermParser = line(indexee(fmap(open(
   /~[^\S\n]+(?=\S)/y,
   visualize(trimBlank(some(union([indexer, inline])))),
   true),
-  ns => [html('dt', { 'data-index': dataindex(ns) }, defrag(ns))])));
+  ns => new List([new Data(html('dt', { 'data-index': dataindex(ns) }, defrag(unwrap(ns))))]))));
 
 const desc: DListParser.DescriptionParser = block(fmap(open(
   /:[^\S\n]+(?=\S)|/y,
@@ -28,11 +29,11 @@ const desc: DListParser.DescriptionParser = block(fmap(open(
     some(anyline, /[~:][^\S\n]+\S/y),
     visualize(trimBlankEnd(some(union([inline]))))),
   true),
-  ns => [html('dd', defrag(ns))]),
+  ns => new List([new Data(html('dd', defrag(unwrap(ns))))])),
   false);
 
-function fillTrailingDescription(es: HTMLElement[]): HTMLElement[] {
-  return es.length > 0 && es.at(-1)!.tagName === 'DT'
-    ? push(es, [html('dd')])
-    : es;
+function fillTrailingDescription(nodes: List<Data<HTMLElement>>): List<Data<HTMLElement>> {
+  return nodes.last?.value.tagName === 'DT'
+    ? nodes.push(new Data(html('dd'))) && nodes
+    : nodes;
 }