securemark 0.258.1 → 0.258.4

package/markdown.d.ts

@@ -964,7 +964,7 @@ export namespace MarkdownParser {
       Inline<'html'>,
       Parser<HTMLElement | string, Context, [
         HTMLParser.OpenTagParser,
-        SourceParser.StrParser,
+        HTMLParser.OpenTagParser,
         HTMLParser.TagParser,
         HTMLParser.TagParser,
       ]> {
@@ -972,8 +972,8 @@ export namespace MarkdownParser {
     export namespace HTMLParser {
       export interface OpenTagParser extends
         Inline<'html/opentag'>,
-        Parser<HTMLElement, Context, [
-          TagParser.AttributeParser,
+        Parser<HTMLElement | string, Context, [
+          AttributeParser,
         ]> {
       }
       export interface TagParser extends
@@ -983,13 +983,11 @@ export namespace MarkdownParser {
           InlineParser,
         ]> {
       }
-      export namespace TagParser {
-        export interface AttributeParser extends
-          Inline<'html/tag/attribute'>,
-          Parser<string, Context, [
-            SourceParser.StrParser,
-          ]> {
-        }
+      export interface AttributeParser extends
+        Inline<'html/attribute'>,
+        Parser<string, Context, [
+          SourceParser.StrParser,
+        ]> {
       }
     }
     export interface InsertionParser extends

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securemark",
-  "version": "0.258.1",
+  "version": "0.258.4",
   "description": "Secure markdown renderer working on browsers for user input data.",
   "private": false,
   "homepage": "https://github.com/falsandtru/securemark",

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

@@ -1,12 +1,14 @@
 import { undefined } from 'spica/global';
 import { Parser, exec } from '../../data/parser';
+import { Memo } from '../../data/parser/context/memo';
 import { firstline, isEmpty } from './line';
 
 export function block<P extends Parser<unknown>>(parser: P, separation?: boolean): P;
 export function block<T>(parser: Parser<T>, separation = true): Parser<T> {
   assert(parser);
-  return (source, context) => {
+  return (source, context = {}) => {
     if (source === '') return;
+    context.memo ??= new Memo();
     const result = parser(source, context);
     if (!result) return;
     const rest = exec(result);

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

@@ -1,14 +1,19 @@
 import { undefined } from 'spica/global';
 import { Parser, eval, exec, check } from '../../data/parser';
+import { Memo } from '../../data/parser/context/memo';
 
 export function line<P extends Parser<unknown>>(parser: P): P;
 export function line<T>(parser: Parser<T>): Parser<T> {
   assert(parser);
-  return (source, context) => {
+  return (source, context = {}) => {
     if (source === '') return;
+    context.memo ??= new Memo();
     const line = firstline(source);
+    const memo = context.memo!;
+    memo.offset += source.length - line.length;
     const result = parser(line, context);
     assert(check(line, result));
+    memo.offset -= source.length - line.length;
     if (!result) return;
     return isEmpty(exec(result))
       ? [eval(result), source.slice(line.length)]

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

@@ -1,17 +1,17 @@
-import { undefined } from 'spica/global';
-import { Parser } from '../../data/parser';
+import { Parser, check } from '../../data/parser';
 
 export function convert<P extends Parser<unknown>>(conv: (source: string) => string, parser: P): P;
 export function convert<T>(conv: (source: string) => string, parser: Parser<T>): Parser<T> {
   assert(parser);
   return (source, context = {}) => {
     if (source === '') return;
-    source = conv(source);
-    if (source === '') return [[], ''];
+    const src = conv(source);
+    if (src === '') return [[], ''];
     const memo = context.memo;
-    context.memo = undefined;
-    const result = parser(source, context);
-    context.memo = memo;
+    memo && (memo.offset += source.length - src.length);
+    const result = parser(src, context);
+    assert(check(src, result));
+    memo && (memo.offset -= source.length - src.length);
     return result;
   };
 }

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

@@ -21,7 +21,10 @@ export function indent<T>(opener: RegExp | Parser<T>, parser?: Parser<T> | boole
     ([indent]) => indent.length * 2 + +(indent[0] === ' '), [])), separation),
     (lines, rest, context) => {
       assert(parser = parser as Parser<T>);
+      const memo = context.memo;
+      memo && (memo.offset += rest.length);
       const result = parser(trimBlockEnd(lines.join('')), context);
+      memo && (memo.offset -= rest.length);
       return result && exec(result) === ''
         ? [eval(result), rest]
         : undefined;

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

@@ -14,10 +14,10 @@ export function focus<T>(scope: string | RegExp, parser: Parser<T>): Parser<T> {
     assert(source.startsWith(src));
     if (src === '') return;
     const memo = context.memo;
-    memo && (memo.offset = source.length - src.length);
+    memo && (memo.offset += source.length - src.length);
     const result = parser(src, context);
     assert(check(src, result));
-    memo && (memo.offset = source.length + src.length);
+    memo && (memo.offset -= source.length - src.length);
     if (!result) return;
     assert(exec(result).length < src.length);
     return exec(result).length < src.length
@@ -42,10 +42,10 @@ export function rewrite<T>(scope: Parser<unknown>, parser: Parser<T>): Parser<T>
     const src = source.slice(0, source.length - exec(res1).length);
     assert(src !== '');
     assert(source.startsWith(src));
-    memo && (memo.offset = source.length - src.length);
+    memo && (memo.offset += source.length - src.length);
     const res2 = parser(src, context);
     assert(check(src, res2));
-    memo && (memo.offset = source.length + src.length);
+    memo && (memo.offset -= source.length - src.length);
     if (!res2) return;
     assert(exec(res2) === '');
     return exec(res2).length < src.length

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

@@ -1,5 +1,5 @@
 export class Memo {
-  private memory: Record<string, readonly [any[], number]>[/* pos */] = [];
+  private readonly memory: Record<string, readonly [any[], number] | readonly []>[/* pos */] = [];
   public get length(): number {
     return this.memory.length;
   }
@@ -8,27 +8,32 @@ export class Memo {
     position: number,
     syntax: number,
     state: number,
-  ): readonly [any[], number] | undefined {
+  ): readonly [any[], number] | readonly [] | undefined {
     //console.log('get', position + this.offset, syntax, state, this.memory[position + this.offset - 1]?.[`${syntax}:${state}`]);;
-    return this.memory[position + this.offset - 1]?.[`${syntax}:${state}`];
+    const cache = this.memory[position + this.offset - 1]?.[`${syntax}:${state}`];
+    return cache?.length === 2
+      ? [cache[0].slice(), cache[1]]
+      : cache;
   }
   public set(
     position: number,
     syntax: number,
     state: number,
-    nodes: any[],
+    nodes: any[] | undefined,
     offset: number,
   ): void {
     const record = this.memory[position + this.offset - 1] ??= {};
     assert(!record[`${syntax}:${state}`]);
-    record[`${syntax}:${state}`] = [nodes.slice(), offset];
-    //console.log('set', position + this.offset, syntax, state);
+    record[`${syntax}:${state}`] = nodes
+      ? [nodes.slice(), offset]
+      : [];
+    //console.log('set', position + this.offset, syntax, state, record[`${syntax}:${state}`]);
   }
   public clear(position: number): void {
     const memory = this.memory;
     for (let i = position + this.offset, len = memory.length; i < len; ++i) {
       memory.pop();
     }
-    //console.log(position);
+    //console.log('clear', position);
   }
 }

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

@@ -1,7 +1,7 @@
 import { Parser, Ctx } from '../parser';
 import { some } from './some';
 import { reset, context } from './context';
-import { creator } from './context';
+import { creation } from './context';
 
 describe('Unit: combinator/data/parser/context', () => {
   interface Context extends Ctx {
@@ -9,44 +9,44 @@ describe('Unit: combinator/data/parser/context', () => {
   }
 
   describe('reset', () => {
-    const parser: Parser<number> = some(creator(
-      (s, context) => [[context.resources?.budget ?? NaN], s.slice(1)]));
+    const parser: Parser<number> = some(creation(
+      (s, context) => [[context.resources?.clock ?? NaN], s.slice(1)]));
 
     it('root', () => {
-      const base: Context = { resources: { budget: 3, recursion: 1 } };
+      const base: Context = { resources: { clock: 3, recursion: 1 } };
       const ctx: Context = {};
       assert.deepStrictEqual(reset(base, parser)('123', ctx), [[3, 2, 1], '']);
-      assert(base.resources?.budget === 3);
-      assert(ctx.resources?.budget === undefined);
+      assert(base.resources?.clock === 3);
+      assert(ctx.resources?.clock === undefined);
       assert.throws(() => reset(base, parser)('1234', ctx));
-      assert(ctx.resources?.budget === undefined);
+      assert(ctx.resources?.clock === undefined);
       assert.deepStrictEqual(reset(base, parser)('123', ctx), [[3, 2, 1], '']);
     });
 
     it('node', () => {
-      const base: Context = { resources: { budget: 3, recursion: 1 } };
-      const ctx: Context = { resources: { budget: 1, recursion: 1 } };
+      const base: Context = { resources: { clock: 3, recursion: 1 } };
+      const ctx: Context = { resources: { clock: 1, recursion: 1 } };
       assert.deepStrictEqual(reset(base, parser)('1', ctx), [[1], '']);
-      assert(base.resources?.budget === 3);
-      assert(ctx.resources?.budget === 0);
+      assert(base.resources?.clock === 3);
+      assert(ctx.resources?.clock === 0);
       assert.throws(() => reset(base, parser)('1', ctx));
-      assert(ctx.resources?.budget === 0);
+      assert(ctx.resources?.clock === 0);
     });
 
   });
 
   describe('context', () => {
-    const parser: Parser<boolean, Context> = some(creator(
+    const parser: Parser<boolean, Context> = some(creation(
       (s, context) => [[context.status!], s.slice(1)]));
 
     it('', () => {
       const base: Context = { status: true };
-      const ctx: Context = { resources: { budget: 3, recursion: 1 } };
+      const ctx: Context = { resources: { clock: 3, recursion: 1 } };
       assert.deepStrictEqual(context(base, parser)('123', ctx), [[true, true, true], '']);
-      assert(ctx.resources?.budget === 0);
+      assert(ctx.resources?.clock === 0);
       assert(ctx.status === undefined);
       assert.throws(() => reset(base, parser)('1', ctx));
-      assert(ctx.resources?.budget === 0);
+      assert(ctx.resources?.clock === 0);
       assert(ctx.status === undefined);
     });
 

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

@@ -56,44 +56,38 @@ function apply<T>(parser: Parser<T>, source: string, context: Ctx, changes: [str
   return result;
 }
 
-export function syntax<P extends Parser<unknown>>(syntax: number, precedence: number, parser: P): P;
 export function syntax<P extends Parser<unknown>>(syntax: number, precedence: number, cost: number, parser: P): P;
-export function syntax<T>(syntax: number, precedence: number, cost: number | Parser<T>, parser?: Parser<T>): Parser<T> {
-  if (typeof cost === 'function') {
-    parser = cost;
-    cost = 1;
-  }
+export function syntax<T>(syntax: number, precedence: number, cost: number, parser?: Parser<T>): Parser<T> {
   return (source, context) => {
     if (source === '') return;
-    context.backtrackable ??= ~0;
-    const state = context.state ??= 0;
+    const memo = context.memo ??= new Memo();
+    context.memorable ??= ~0;
     const p = context.precedence;
     context.precedence = precedence;
-    const { resources = { budget: 1, recursion: 1 } } = context;
-    if (resources.budget <= 0) throw new Error('Too many creations');
+    const { resources = { clock: 1, recursion: 1 } } = context;
+    if (resources.clock <= 0) throw new Error('Too many creations');
     if (resources.recursion <= 0) throw new Error('Too much recursion');
     --resources.recursion;
-    const pos = source.length;
-    const cache = syntax && context.memo?.get(pos, syntax, state);
+    const position = source.length;
+    const state = context.state ?? 0;
+    const cache = syntax && memo.get(position, syntax, state);
     const result: Result<T> = cache
-      ? [cache[0], source.slice(cache[1])]
+      ? cache.length === 0
+        ? undefined
+        : [cache[0], source.slice(cache[1])]
       : parser!(source, context);
     ++resources.recursion;
-    if (result) {
-      if (!cache) {
-        assert(cost = cost as number);
-        resources.budget -= cost;
+    if (result && !cache) {
+      resources.clock -= cost;
+    }
+    if (syntax) {
+      if (state & context.memorable!) {
+        cache ?? memo.set(position, syntax, state, eval(result), source.length - exec(result, '').length);
+        assert.deepStrictEqual(cache && cache, cache && memo.get(position, syntax, state));
       }
-      if (syntax) {
-        if (state & context.backtrackable) {
-          context.memo ??= new Memo();
-          cache ?? context.memo.set(pos, syntax, state, eval(result), source.length - exec(result).length);
-          assert.deepStrictEqual(cache && cache, cache && context.memo.get(pos, syntax, state));
-        }
-        else if (context.memo?.length! >= pos) {
-          assert(!(state & context.backtrackable));
-          context.memo!.clear(pos);
-        }
+      else if (result && memo.length! >= position) {
+        assert(!(state & context.memorable!));
+        memo.clear(position);
       }
     }
     context.precedence = p;
@@ -101,20 +95,20 @@ export function syntax<T>(syntax: number, precedence: number, cost: number | Par
   };
 }
 
-export function creator<P extends Parser<unknown>>(parser: P): P;
-export function creator<P extends Parser<unknown>>(cost: number, parser: P): P;
-export function creator(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
-  if (typeof cost === 'function') return creator(1, cost);
+export function creation<P extends Parser<unknown>>(parser: P): P;
+export function creation<P extends Parser<unknown>>(cost: number, parser: P): P;
+export function creation(cost: number | Parser<unknown>, parser?: Parser<unknown>): Parser<unknown> {
+  if (typeof cost === 'function') return creation(1, cost);
   assert(cost >= 0);
   return (source, context) => {
-    const { resources = { budget: 1, recursion: 1 } } = context;
-    if (resources.budget <= 0) throw new Error('Too many creations');
+    const { resources = { clock: 1, recursion: 1 } } = context;
+    if (resources.clock <= 0) throw new Error('Too many creations');
     if (resources.recursion <= 0) throw new Error('Too much recursion');
     --resources.recursion;
     const result = parser!(source, context);
     ++resources.recursion;
     if (result) {
-      resources.budget -= cost;
+      resources.clock -= cost;
     }
     return result;
   };
@@ -139,6 +133,24 @@ export function guard<T>(f: (context: Ctx) => boolean | number, parser: Parser<T
       : undefined;
 }
 
+export function constraint<P extends Parser<unknown>>(state: number, parser: P): P;
+export function constraint<P extends Parser<unknown>>(state: number, positive: boolean, parser: P): P;
+export function constraint<T>(state: number, positive: boolean | Parser<T>, parser?: Parser<T>): Parser<T> {
+  if (typeof positive === 'function') {
+    parser = positive;
+    positive = true;
+  }
+  assert(state);
+  return (source, context) => {
+    const s = positive
+      ? state & context.state!
+      : state & ~context.state!;
+    return s === state
+      ? parser!(source, context)
+      : undefined;
+  };
+}
+
 export function state<P extends Parser<unknown>>(state: number, parser: P): P;
 export function state<P extends Parser<unknown>>(state: number, positive: boolean, parser: P): P;
 export function state<T>(state: number, positive: boolean | Parser<T>, parser?: Parser<T>): Parser<T> {
@@ -146,6 +158,7 @@ export function state<T>(state: number, positive: boolean | Parser<T>, parser?:
     parser = positive;
     positive = true;
   }
+  assert(state);
   return (source, context) => {
     const s = context.state ?? 0;
     context.state = positive

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

@@ -1,7 +1,7 @@
 import { undefined } from 'spica/global';
 import { Parser, eval, exec, check } from '../parser';
 import { Delimiters } from './context/delimiter';
-import { push } from 'spica/array';
+import { unshift, push } from 'spica/array';
 
 type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
 
@@ -32,7 +32,9 @@ export function some<T>(parser: Parser<T>, end?: string | RegExp | number, delim
       assert.doesNotThrow(() => limit < 0 && check(rest, result));
       if (!result) break;
       nodes = nodes
-        ? push(nodes, eval(result))
+        ? nodes.length < eval(result).length
+          ? unshift(nodes, eval(result))
+          : push(nodes, eval(result))
         : eval(result);
       rest = exec(result);
       if (limit >= 0 && source.length - rest.length > limit) break;

package/src/combinator/data/parser.ts

@@ -9,13 +9,13 @@ export type Result<T, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any>
   | undefined;
 export interface Ctx {
   readonly resources?: {
-    budget: number;
+    clock: number;
     recursion: number;
   };
   precedence?: number;
   delimiters?: Delimiters;
   state?: number;
-  backtrackable?: number;
+  memorable?: number;
   memo?: Memo;
 }
 export type Tree<P extends Parser<unknown>> = P extends Parser<infer T> ? T : never;

package/src/parser/api/bind.ts

@@ -24,7 +24,7 @@ export function bind(target: DocumentFragment | HTMLElement | ShadowRoot, settin
   let context: MarkdownParser.Context = {
     ...settings,
     host: settings.host ?? new ReadonlyURL(location.pathname, location.origin),
-    backtrackable,
+    memorable: backtrackable,
   };
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   assert(!settings.id);

package/src/parser/api/parse.test.ts

@@ -247,19 +247,19 @@ describe('Unit: parser/api/parse', () => {
         [...parse('('.repeat(20)).children].map(el => el.outerHTML),
         [`<p>${'('.repeat(20)}</p>`]);
       assert.deepStrictEqual(
-        [...parse('('.repeat(21)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse('('.repeat(22)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [
           '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
-          `<pre class="error" translate="no">${'('.repeat(21)}</pre>`,
+          `<pre class="error" translate="no">${'('.repeat(22)}</pre>`,
         ]);
       assert.deepStrictEqual(
         [...parse('['.repeat(20)).children].map(el => el.outerHTML),
         [`<p>${'['.repeat(20)}</p>`]);
       assert.deepStrictEqual(
-        [...parse('['.repeat(21)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
+        [...parse('['.repeat(22)).children].map(el => el.outerHTML.replace(/:\w+/, ':rnd')),
         [
           '<h1 id="error:rnd" class="error">Error: Too much recursion</h1>',
-          `<pre class="error" translate="no">${'['.repeat(21)}</pre>`,
+          `<pre class="error" translate="no">${'['.repeat(22)}</pre>`,
         ]);
       assert.deepStrictEqual(
         [...parse('['.repeat(17) + '\na').children].map(el => el.outerHTML),

package/src/parser/api/parse.ts

@@ -30,7 +30,7 @@ export function parse(source: string, opts: Options = {}, context?: MarkdownPars
     ...context?.resources && {
       resources: context.resources,
     },
-    backtrackable,
+    memorable: backtrackable,
   };
   if (context.host?.origin === 'null') throw new Error(`Invalid host: ${context.host.href}`);
   const node = frag();

package/src/parser/autolink.test.ts

@@ -13,13 +13,14 @@ describe('Unit: parser/autolink', () => {
       assert.deepStrictEqual(inspect(parser('@a#b')), [['<a href="/@a?ch=b" class="channel">@a#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('a#b')), [['a#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0a#b')), [['0', 'a#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0a#b')), [['0a#b'], '']);
       assert.deepStrictEqual(inspect(parser('あ#b')), [['あ#b'], '']);
       assert.deepStrictEqual(inspect(parser('あい#b')), [['あ', 'い#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあ#b')), [['0a', 'あ#b'], '']);
+      assert.deepStrictEqual(inspect(parser('0aあ#b')), [['0aあ#b'], '']);
       assert.deepStrictEqual(inspect(parser('0aあい#b')), [['0a', 'あ', 'い#b'], '']);
       assert.deepStrictEqual(inspect(parser('a\n#b')), [['a', '<br>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\n#b')), [['a', '\\', '<br>', '<a href="/hashtags/b" class="hashtag">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('0a>>b')), [['0a>>b'], '']);
     });
 
   });

package/src/parser/autolink.ts

@@ -5,7 +5,23 @@ import { linebreak, unescsource } from './source';
 
 export import AutolinkParser = MarkdownParser.AutolinkParser;
 
-export const autolink: AutolinkParser = lazy(() => union([
+const delimiter = /[@#>0-9A-Za-z\n]|\S[#>]/;
+
+export const autolink: AutolinkParser = (source, context) => {
+  if (source === '') return;
+  assert(source[0] !== '\x1B');
+  const i = source.search(delimiter);
+  switch (i) {
+    case -1:
+      return [[source], ''];
+    case 0:
+      return parser(source, context);
+    default:
+      return [[source.slice(0, i)], source.slice(i)];
+  }
+};
+
+const parser: AutolinkParser = lazy(() => union([
   autolink_,
   linebreak,
   unescsource

package/src/parser/block/blockquote.ts

@@ -1,5 +1,5 @@
 import { BlockquoteParser } from '../block';
-import { union, some, creator, block, validate, rewrite, open, convert, lazy, fmap } from '../../combinator';
+import { union, some, creation, block, validate, rewrite, open, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
 import { parse } from '../api/parse';
@@ -19,7 +19,7 @@ const indent = block(open(opener, some(contentline, /^>(?:$|\s)/)), false);
 const unindent = (source: string) => source.replace(/(^|\n)>(?:[^\S\n]|(?=>*(?:$|\s)))|\n$/g, '$1');
 
 const source: BlockquoteParser.SourceParser = lazy(() => fmap(
-  some(creator(union([
+  some(creation(union([
     rewrite(
       indent,
       convert(unindent, source)),
@@ -30,11 +30,11 @@ const source: BlockquoteParser.SourceParser = lazy(() => fmap(
   ns => [html('blockquote', ns)]));
 
 const markdown: BlockquoteParser.MarkdownParser = lazy(() => fmap(
-  some(creator(union([
+  some(creation(union([
     rewrite(
       indent,
       convert(unindent, markdown)),
-    creator(99,
+    creation(99,
     rewrite(
       some(contentline, opener),
       convert(unindent, (source, context) => {

package/src/parser/block/dlist.ts

@@ -1,5 +1,5 @@
 import { DListParser } from '../block';
-import { union, inits, some, creator, state, block, line, validate, rewrite, open, trimEnd, lazy, fmap } from '../../combinator';
+import { union, inits, some, creation, state, block, line, validate, rewrite, open, trimEnd, lazy, fmap } from '../../combinator';
 import { inline, indexee, indexer } from '../inline';
 import { anyline } from '../source';
 import { State } from '../context';
@@ -17,13 +17,13 @@ export const dlist: DListParser = lazy(() => block(localize(fmap(validate(
   ]))),
   es => [html('dl', fillTrailingDescription(es))]))));
 
-const term: DListParser.TermParser = creator(line(indexee(fmap(open(
+const term: DListParser.TermParser = creation(line(indexee(fmap(open(
   /^~[^\S\n]+(?=\S)/,
   visualize(trimBlank(some(union([indexer, inline])))),
   true),
   ns => [html('dt', defrag(ns))]))));
 
-const desc: DListParser.DescriptionParser = creator(block(fmap(open(
+const desc: DListParser.DescriptionParser = creation(block(fmap(open(
   /^:[^\S\n]+(?=\S)|/,
   rewrite(
     some(anyline, /^[~:][^\S\n]+\S/),

package/src/parser/block/extension/table.ts

@@ -2,7 +2,7 @@ import { undefined, BigInt, Array } from 'spica/global';
 import { max, min, isArray } from 'spica/alias';
 import { ExtensionParser } from '../../block';
 import { Tree, eval } from '../../../combinator/data/parser';
-import { union, subsequence, inits, some, creator, block, line, validate, fence, rewrite, open, clear, convert, trim, dup, lazy, fmap } from '../../../combinator';
+import { union, subsequence, inits, some, creation, block, line, validate, fence, rewrite, open, clear, convert, trim, dup, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { str, anyline, emptyline, contentline } from '../../source';
 import { localize } from '../../locale';
@@ -79,7 +79,7 @@ const align: AlignParser = line(fmap(
 
 const delimiter = /^[-=<>]+(?:\/[-=^v]*)?(?=[^\S\n]*\n)|^[#:](?:(?!:\D|0)\d*:(?!0)\d*)?!*(?=\s)/;
 
-const head: CellParser.HeadParser = creator(block(fmap(open(
+const head: CellParser.HeadParser = creation(block(fmap(open(
   str(/^#(?:(?!:\D|0)\d*:(?!0)\d*)?!*(?=\s)/),
   rewrite(
     inits([
@@ -91,7 +91,7 @@ const head: CellParser.HeadParser = creator(block(fmap(open(
   ns => [html('th', attributes(ns.shift()! as string), defrag(ns))]),
   false));
 
-const data: CellParser.DataParser = creator(block(fmap(open(
+const data: CellParser.DataParser = creation(block(fmap(open(
   str(/^:(?:(?!:\D|0)\d*:(?!0)\d*)?!*(?=\s)/),
   rewrite(
     inits([
@@ -103,7 +103,7 @@ const data: CellParser.DataParser = creator(block(fmap(open(
   ns => [html('td', attributes(ns.shift()! as string), defrag(ns))]),
   false));
 
-const dataline: CellParser.DatalineParser = creator(line(
+const dataline: CellParser.DatalineParser = creation(line(
   rewrite(
     contentline,
     union([

package/src/parser/block/ilist.ts

@@ -1,5 +1,5 @@
 import { IListParser } from '../block';
-import { union, inits, some, creator, state, block, line, validate, indent, open, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, some, creation, state, block, line, validate, indent, open, fallback, lazy, fmap } from '../../combinator';
 import { ulist_, fillFirstLine } from './ulist';
 import { olist_, invalid } from './olist';
 import { inline } from '../inline';
@@ -13,7 +13,7 @@ export const ilist: IListParser = lazy(() => block(validate(
 
 export const ilist_: IListParser = lazy(() => block(fmap(validate(
   /^[-+*](?:$|\s)/,
-  some(creator(union([
+  some(creation(union([
     fmap(fallback(
       inits([
         line(open(/^[-+*](?:$|\s)/, some(inline), true)),

package/src/parser/block/olist.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { OListParser } from '../block';
-import { union, inits, subsequence, some, creator, state, block, line, validate, indent, focus, rewrite, open, match, fallback, lazy, fmap } from '../../combinator';
+import { union, inits, subsequence, some, creation, state, block, line, validate, indent, focus, rewrite, open, match, fallback, lazy, fmap } from '../../combinator';
 import { checkbox, ulist_, fillFirstLine } from './ulist';
 import { ilist_ } from './ilist';
 import { inline, indexee, indexer } from '../inline';
@@ -36,7 +36,7 @@ export const olist_: OListParser = lazy(() => block(union([
 ])));
 
 const list = (type: string, form: string): OListParser.ListParser => fmap(
-  some(creator(union([
+  some(creation(union([
     indexee(fmap(fallback(
       inits([
         line(open(heads[form], subsequence([checkbox, trimBlank(some(union([indexer, inline])))]), true)),