securemark 0.258.0 → 0.258.3

package/package.json

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

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/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;
-    context.memo = undefined;
+    memo && (memo.offset += source.length - src.length);
     const result = parser(src, context);
     assert(check(src, result));
-    context.memo = memo;
+    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));
-    context.memo = undefined;
+    memo && (memo.offset += source.length - src.length);
     const res2 = parser(src, context);
     assert(check(src, res2));
-    context.memo = memo;
+    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,30 +1,39 @@
-import { splice } from 'spica/array';
-
 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;
   }
+  public offset = 0;
   public get(
     position: number,
-    rule: number,
     syntax: number,
     state: number,
-  ): readonly [any[], number] | undefined {
-    return this.memory[position - 1]?.[`${rule}:${syntax}:${state}`];
+  ): readonly [any[], number] | readonly [] | undefined {
+    //console.log('get', position + this.offset, syntax, state, 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,
-    rule: number,
     syntax: number,
     state: number,
-    nodes: any[],
+    nodes: any[] | undefined,
     offset: number,
   ): void {
-    const record = this.memory[position - 1] ??= {};
-    record[`${rule}:${syntax}:${state}`] = [nodes, offset];
+    const record = this.memory[position + this.offset - 1] ??= {};
+    assert(!record[`${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 {
-    splice(this.memory, position, this.memory.length - position);
+    const memory = this.memory;
+    for (let i = position + this.offset, len = memory.length; i < len; ++i) {
+      memory.pop();
+    }
+    //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,7 +9,7 @@ describe('Unit: combinator/data/parser/context', () => {
   }
 
   describe('reset', () => {
-    const parser: Parser<number> = some(creator(
+    const parser: Parser<number> = some(creation(
       (s, context) => [[context.resources?.budget ?? NaN], s.slice(1)]));
 
     it('root', () => {
@@ -36,7 +36,7 @@ describe('Unit: combinator/data/parser/context', () => {
   });
 
   describe('context', () => {
-    const parser: Parser<boolean, Context> = some(creator(
+    const parser: Parser<boolean, Context> = some(creation(
       (s, context) => [[context.status!], s.slice(1)]));
 
     it('', () => {

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

@@ -56,19 +56,12 @@ 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;
-    const r = context.rule ?? 0;
-    context.rule = r | syntax;
-    context.backtrackable ??= ~0;
-    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;
@@ -76,38 +69,36 @@ export function syntax<T>(syntax: number, precedence: number, cost: number | Par
     if (resources.recursion <= 0) throw new Error('Too much recursion');
     --resources.recursion;
     const pos = source.length;
-    const cache = context.memo?.get(pos, context.rule, syntax, context.state);
+    const state = context.state ?? 0;
+    const cache = syntax && memo.get(pos, 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.budget -= cost;
+    }
+    if (syntax) {
+      if (state & context.memorable!) {
+        cache ?? memo.set(pos, syntax, state, eval(result), source.length - exec(result, '').length);
+        assert.deepStrictEqual(cache && cache, cache && memo.get(pos, syntax, state));
       }
-      if (syntax ) {
-        if (r & context.backtrackable) {
-          context.memo ??= new Memo();
-          cache ?? context.memo.set(pos, context.rule, syntax, context.state, eval(result), source.length - exec(result).length);
-          assert.deepStrictEqual(cache && cache, cache && context.memo.get(pos, context.rule, syntax, context.state));
-        }
-        else if (context.memo?.length! >= pos) {
-          assert(!(r & context.backtrackable));
-          context.memo!.clear(pos);
-        }
+      else if (result && memo.length! >= pos) {
+        assert(!(state & context.memorable!));
+        memo.clear(pos);
       }
     }
     context.precedence = p;
-    context.rule = r;
     return result;
   };
 }
 
-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;

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

@@ -2,8 +2,8 @@ import { undefined } from 'spica/global';
 import { Parser, Ctx, Tree, Context, SubParsers, SubTree, eval, exec, check } from '../parser';
 import { push } from 'spica/array';
 
-export function inits<P extends Parser<unknown>>(parsers: SubParsers<P>): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function inits<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
+export function inits<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
+export function inits<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return (source, context) => {
@@ -19,6 +19,7 @@ export function inits<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
         ? push(nodes, eval(result))
         : eval(result);
       rest = exec(result);
+      if (resume?.(eval(result), exec(result)) === false) break;
     }
     assert(rest.length <= source.length);
     return nodes && rest.length < source.length

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

@@ -2,8 +2,8 @@ import { undefined } from 'spica/global';
 import { Parser, Ctx, Tree, Context, SubParsers, SubTree, eval, exec, check } from '../parser';
 import { push } from 'spica/array';
 
-export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function sequence<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
+export function sequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
+export function sequence<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return (source, context) => {
@@ -19,6 +19,7 @@ export function sequence<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D
         ? push(nodes, eval(result))
         : eval(result);
       rest = exec(result);
+      if (resume?.(eval(result), exec(result)) === false) return;
     }
     assert(rest.length <= source.length);
     return nodes && rest.length < source.length

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/subsequence.ts

@@ -2,12 +2,12 @@ import { Parser, Ctx, Tree, Context, SubParsers, SubTree } from '../parser';
 import { union } from './union';
 import { inits } from './inits';
 
-export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function subsequence<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
+export function subsequence<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
+export function subsequence<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
   assert(parsers.every(f => f));
   return union(
     parsers.map((_, i) =>
       i + 1 < parsers.length
-        ? inits([parsers[i], subsequence(parsers.slice(i + 1))])
+        ? inits([parsers[i], subsequence(parsers.slice(i + 1), resume)], resume)
         : parsers[i]) as D);
 }

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

@@ -2,7 +2,7 @@ import { Parser, Ctx, Tree, Context, SubParsers, SubTree } from '../parser';
 import { union } from './union';
 import { sequence } from './sequence';
 
-export function tails<P extends Parser<unknown>>(parsers: SubParsers<P>): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
-export function tails<T, D extends Parser<T>[]>(parsers: D): Parser<T, Ctx, D> {
-  return union(parsers.map((_, i) => sequence(parsers.slice(i))) as D);
+export function tails<P extends Parser<unknown>>(parsers: SubParsers<P>, resume?: (nodes: SubTree<P>[], rest: string) => boolean): SubTree<P> extends Tree<P> ? P : Parser<SubTree<P>, Context<P>, SubParsers<P>>;
+export function tails<T, D extends Parser<T>[]>(parsers: D, resume?: (nodes: T[], rest: string) => boolean): Parser<T, Ctx, D> {
+  return union(parsers.map((_, i) => sequence(parsers.slice(i), resume)) as D);
 }

package/src/combinator/data/parser.ts

@@ -15,8 +15,7 @@ export interface Ctx {
   precedence?: number;
   delimiters?: Delimiters;
   state?: number;
-  rule?: 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

@@ -235,32 +235,35 @@ describe('Unit: parser/api/parse', () => {
 
     it('recursion', () => {
       assert.deepStrictEqual(
-        [...parse('('.repeat(20)).children].map(el => el.outerHTML),
-        [`<p>${'('.repeat(20)}</p>`]);
+        [...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(21)).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(21)}</pre>`,
         ]);
       assert.deepStrictEqual(
-        [...parse('['.repeat(20)).children].map(el => el.outerHTML),
-        [`<p>${'['.repeat(20)}</p>`]);
+        [...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>`]);
+        [...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),
+        [`<p>${'['.repeat(17)}<br>a</p>`]);
     });
 
     if (!navigator.userAgent.includes('Chrome')) return;

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/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)),

package/src/parser/block/reply/cite.ts

@@ -1,10 +1,10 @@
 import { ReplyParser } from '../../block';
-import { union, tails, creator, line, validate, focus, reverse, fmap } from '../../../combinator';
+import { union, tails, creation, line, validate, focus, reverse, fmap } from '../../../combinator';
 import { anchor } from '../../inline/autolink/anchor';
 import { str } from '../../source';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const cite: ReplyParser.CiteParser = creator(line(fmap(validate(
+export const cite: ReplyParser.CiteParser = creation(line(fmap(validate(
   '>>',
   reverse(tails([
     str(/^>*(?=>>[^>\s]+[^\S\n]*(?:$|\n))/),

package/src/parser/block/reply/quote.ts

@@ -1,6 +1,6 @@
 import { ReplyParser } from '../../block';
 import { eval } from '../../../combinator/data/parser';
-import { union, some, creator, block, line, validate, rewrite, lazy, fmap } from '../../../combinator';
+import { union, some, creation, block, line, validate, rewrite, lazy, fmap } from '../../../combinator';
 import { math } from '../../inline/math';
 import { str, anyline } from '../../source';
 import { autolink } from '../../autolink';
@@ -8,7 +8,7 @@ import { html, defrag } from 'typed-dom/dom';
 
 export const syntax = /^>+(?=[^\S\n])|^>(?=[^\s>])|^>+(?=[^\s>])(?![0-9a-z]+(?:-[0-9a-z]+)*(?![0-9A-Za-z@#:]))/;
 
-export const quote: ReplyParser.QuoteParser = lazy(() => creator(block(fmap(validate(
+export const quote: ReplyParser.QuoteParser = lazy(() => creation(block(fmap(validate(
   '>',
   union([
     rewrite(

package/src/parser/block/sidefence.ts

@@ -1,5 +1,5 @@
 import { SidefenceParser } from '../block';
-import { union, some, creator, block, focus, rewrite, convert, lazy, fmap } from '../../combinator';
+import { union, some, creation, block, focus, rewrite, convert, lazy, fmap } from '../../combinator';
 import { autolink } from '../autolink';
 import { contentline } from '../source';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -20,7 +20,7 @@ const opener = /^(?=\|\|+(?:$|\s))/;
 const unindent = (source: string) => source.replace(/(^|\n)\|(?:[^\S\n]|(?=\|*(?:$|\s)))|\n$/g, '$1');
 
 const source: SidefenceParser.SourceParser = lazy(() => fmap(
-  some(creator(union([
+  some(creation(union([
     focus(
       /^(?:\|\|+(?:[^\S\n][^\n]*)?(?:$|\n))+/,
       convert(unindent, source)),

package/src/parser/block/table.ts

@@ -1,5 +1,5 @@
 import { TableParser } from '../block';
-import { union, sequence, some, creator, block, line, validate, focus, rewrite, surround, open, fallback, lazy, fmap } from '../../combinator';
+import { union, sequence, some, creation, block, line, validate, focus, rewrite, surround, open, fallback, lazy, fmap } from '../../combinator';
 import { inline } from '../inline';
 import { contentline } from '../source';
 import { trimNode } from '../visibility';
@@ -25,7 +25,7 @@ export const table: TableParser = lazy(() => block(fmap(validate(
     ]),
   ])));
 
-const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => creator(fallback(fmap(
+const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean): RowParser<P> => creation(fallback(fmap(
   line(surround(/^(?=\|)/, some(union([parser])), /^[|\\]?\s*$/, optional)),
   es => [html('tr', es)]),
   rewrite(contentline, source => [[
@@ -37,7 +37,7 @@ const row = <P extends CellParser | AlignParser>(parser: P, optional: boolean):
     }, [html('td', source.replace('\n', ''))])
   ], ''])));
 
-const align: AlignParser = creator(fmap(open(
+const align: AlignParser = creation(fmap(open(
   '|',
   union([
     focus(/^:-+:/, () => [['center'], '']),
@@ -52,11 +52,11 @@ const cell: CellParser = surround(
   some(union([inline]), /^\|/, [[/^[|\\]?\s*$/, 9]]),
   /^[^|]*/, true);
 
-const head: CellParser.HeadParser = creator(fmap(
+const head: CellParser.HeadParser = creation(fmap(
   cell,
   ns => [html('th', trimNode(defrag(ns)))]));
 
-const data: CellParser.DataParser = creator(fmap(
+const data: CellParser.DataParser = creation(fmap(
   cell,
   ns => [html('td', trimNode(defrag(ns)))]));
 

package/src/parser/block/ulist.ts

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