securemark 0.258.2 → 0.258.3

package/src/parser/inline/deletion.ts

@@ -2,17 +2,18 @@ import { DeletionParser } from '../inline';
 import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const deletion: DeletionParser = lazy(() => syntax(Rule.none, 1, surround(
+export const deletion: DeletionParser = lazy(() => surround(
   str('~~'),
+  syntax(Syntax.none, 1, 1,
   some(union([
     some(inline, blankWith('\n', '~~')),
     open('\n', some(inline, '~'), true),
-  ])),
+  ]))),
   str('~~'), false,
   ([, bs], rest) => [[html('del', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/emphasis.ts

@@ -4,13 +4,14 @@ import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { strong } from './strong';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { startTight, blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const emphasis: EmphasisParser = lazy(() => syntax(Rule.none, 1, surround(
+export const emphasis: EmphasisParser = lazy(() => surround(
   str('*'),
+  syntax(Syntax.none, 1, 1,
   startTight(some(union([
     strong,
     some(inline, blankWith('*')),
@@ -19,7 +20,7 @@ export const emphasis: EmphasisParser = lazy(() => syntax(Rule.none, 1, surround
       strong,
       emphasis,
     ])),
-  ])), '*'),
+  ])), '*')),
   str('*'), false,
   ([, bs], rest) => [[html('em', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/emstrong.ts

@@ -5,7 +5,7 @@ import { inline } from '../inline';
 import { strong } from './strong';
 import { emphasis } from './emphasis';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { startTight, blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
@@ -27,12 +27,13 @@ const subemphasis: IntermediateParser<EmphasisParser> = lazy(() => some(union([
   ])),
 ])));
 
-export const emstrong: EmStrongParser = lazy(() => syntax(Rule.none, 1, surround(
+export const emstrong: EmStrongParser = lazy(() => surround(
   str('***'),
+  syntax(Syntax.none, 1, 1,
   startTight(some(union([
     some(inline, blankWith('*')),
     open(some(inline, '*'), inline),
-  ]))),
+  ])))),
   str(/^\*{1,3}/), false,
   ([, bs, cs], rest, context): Result<HTMLElement | string, typeof context> => {
     assert(cs.length === 1);
@@ -58,4 +59,4 @@ export const emstrong: EmStrongParser = lazy(() => syntax(Rule.none, 1, surround
     }
     assert(false);
   },
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/extension/index.ts

@@ -1,24 +1,25 @@
 import { undefined } from 'spica/global';
 import { ExtensionParser } from '../../inline';
-import { union, some, syntax, creator, precedence, guard, state, validate, surround, open, lazy, fmap } from '../../../combinator';
+import { union, some, syntax, creation, precedence, guard, state, validate, surround, open, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
 import { txt, str, stropt } from '../../source';
-import { Rule, State } from '../../context';
+import { Syntax, State } from '../../context';
 import { startTight, trimBlankEnd } from '../../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
 
-export const index: IndexParser = lazy(() => validate('[#', syntax(Rule.index, 2, fmap(indexee(surround(
+export const index: IndexParser = lazy(() => validate('[#', fmap(indexee(surround(
   '[#',
   guard(context => ~context.state! & State.index,
+  syntax(Syntax.index, 2, 1,
   state(State.annotation | State.reference | State.index | State.label | State.link | State.media | State.autolink,
   startTight(
   open(stropt(/^\|?/), trimBlankEnd(some(union([
     signature,
     inline,
-  ]), ']', [[/^\\?\n/, 9], [']', 2]])), true)))),
+  ]), ']', [[/^\\?\n/, 9], [']', 2]])), true))))),
   ']',
   false,
   ([, ns], rest) => [[html('a', defrag(ns))], rest])),
@@ -30,16 +31,16 @@ export const index: IndexParser = lazy(() => validate('[#', syntax(Rule.index, 2
         href: el.id ? `#${el.id}` : undefined,
       },
       el.childNodes),
-  ]))));
+  ])));
 
-const signature: IndexParser.SignatureParser = lazy(() => creator(fmap(open(
+const signature: IndexParser.SignatureParser = lazy(() => creation(fmap(open(
   '|#',
   startTight(some(union([bracket, txt]), ']'))),
   ns => [
     html('span', { class: 'indexer', 'data-index': identity(ns.join('')).slice(6) }),
   ])));
 
-const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creator(union([
+const bracket: IndexParser.SignatureParser.BracketParser = lazy(() => creation(union([
   surround(str('('), some(union([bracket, txt]), ')'), str(')'), true),
   surround(str('['), some(union([bracket, txt]), ']'), str(']'), true),
   surround(str('{'), some(union([bracket, txt]), '}'), str('}'), true),

package/src/parser/inline/extension/indexer.ts

@@ -1,10 +1,10 @@
 import { ExtensionParser } from '../../inline';
-import { union, creator, state, verify, focus, surround, fmap } from '../../../combinator';
+import { union, creation, state, verify, focus, surround, fmap } from '../../../combinator';
 import { index } from './index';
 import { State } from '../../context';
 import { html } from 'typed-dom/dom';
 
-export const indexer: ExtensionParser.IndexerParser = creator(fmap(verify(surround(
+export const indexer: ExtensionParser.IndexerParser = creation(fmap(verify(surround(
   /^\s+(?=\[#\S)/,
   state(State.index, false,
   union([

package/src/parser/inline/extension/label.ts

@@ -1,6 +1,6 @@
 import { Array } from 'spica/global';
 import { ExtensionParser } from '../../inline';
-import { union, guard, creator, validate, surround, clear, fmap } from '../../../combinator';
+import { union, guard, creation, validate, surround, clear, fmap } from '../../../combinator';
 import { str } from '../../source';
 import { State } from '../../context';
 import { html } from 'typed-dom/dom';
@@ -12,7 +12,7 @@ export const segment: ExtensionParser.LabelParser.SegmentParser = clear(validate
   body,
 ])));
 
-export const label: ExtensionParser.LabelParser = validate(['[$', '$'], creator(fmap(
+export const label: ExtensionParser.LabelParser = validate(['[$', '$'], creation(fmap(
   guard(context => ~context.state! & State.label,
   union([
     surround('[', body, ']'),

package/src/parser/inline/extension/placeholder.ts

@@ -2,7 +2,7 @@ import { ExtensionParser } from '../../inline';
 import { union, some, syntax, validate, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
-import { Rule } from '../../context';
+import { Syntax } from '../../context';
 import { startTight } from '../../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
@@ -11,9 +11,10 @@ import { unshift } from 'spica/array';
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], syntax(Rule.none, 2, surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate(['[:', '[^'], surround(
   str(/^\[[:^]/),
-  startTight(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]])),
+  syntax(Syntax.none, 2, 1,
+  startTight(some(union([inline]), ']', [[/^\\?\n/, 9], [']', 2]]))),
   str(']'), false,
   ([as, bs], rest) => [[
     html('span', {
@@ -23,4 +24,4 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validat
       'data-invalid-message': `Reserved start symbol "${as[0][1]}" cannot be used in "[]"`,
     }, defrag(bs)),
   ], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest]))));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/html.ts

@@ -3,7 +3,7 @@ import { HTMLParser } from '../inline';
 import { union, subsequence, some, syntax, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { isStartLooseNodes, blankWith } from '../visibility';
 import { html as h, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
@@ -19,7 +19,7 @@ const attrspecs = {
 Object.setPrototypeOf(attrspecs, null);
 Object.values(attrspecs).forEach(o => Object.setPrototypeOf(o, null));
 
-export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/, syntax(Rule.none, 5, union([
+export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/, syntax(Syntax.none, 5, 1, union([
   focus(
     '<wbr>',
     () => [[h('wbr')], '']),

package/src/parser/inline/htmlentity.ts

@@ -1,10 +1,10 @@
 import { undefined } from 'spica/global';
 import { HTMLEntityParser, UnsafeHTMLEntityParser } from '../inline';
-import { union, creator, validate, focus, fmap } from '../../combinator';
+import { union, creation, validate, focus, fmap } from '../../combinator';
 import { html } from 'typed-dom/dom';
 import { reduce } from 'spica/memoize';
 
-export const unsafehtmlentity: UnsafeHTMLEntityParser = creator(validate('&', focus(
+export const unsafehtmlentity: UnsafeHTMLEntityParser = creation(validate('&', focus(
   /^&[0-9A-Za-z]+;/,
   entity => [[parse(entity) ?? `\x1B${entity}`], ''])));
 

package/src/parser/inline/insertion.ts

@@ -2,17 +2,18 @@ import { InsertionParser } from '../inline';
 import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const insertion: InsertionParser = lazy(() => syntax(Rule.none, 1, surround(
+export const insertion: InsertionParser = lazy(() => surround(
   str('++'),
+  syntax(Syntax.none, 1, 1,
   some(union([
     some(inline, blankWith('\n', '++')),
     open('\n', some(inline, '+'), true),
-  ])),
+  ]))),
   str('++'), false,
   ([, bs], rest) => [[html('ins', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/link.ts

@@ -1,12 +1,12 @@
 import { undefined, location, encodeURI, decodeURI, Location } from 'spica/global';
 import { LinkParser, TextLinkParser } from '../inline';
 import { Result, eval, exec } from '../../combinator/data/parser';
-import { union, inits, tails, subsequence, some, guard, syntax, state, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, subsequence, some, guard, syntax, creation, precedence, state, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
 import { inline, media, shortmedia } from '../inline';
 import { attributes } from './html';
 import { autolink } from '../autolink';
 import { unescsource, str } from '../source';
-import { Rule, State } from '../context';
+import { Syntax, State } from '../context';
 import { trimNode } from '../visibility';
 import { stringify } from '../util';
 import { html, define, defrag } from 'typed-dom/dom';
@@ -17,8 +17,9 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const link: LinkParser = lazy(() => validate(['[', '{'], syntax(Rule.link, 2, 10, bind(
+export const link: LinkParser = lazy(() => validate(['[', '{'], bind(
   guard(context => ~context.state! & State.link,
+  syntax(Syntax.link, 2, 10,
   fmap(subsequence([
     state(State.link,
     dup(union([
@@ -35,7 +36,7 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], syntax(Rule.link
     ]))),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
   ], nodes => nodes[0][0] !== ''),
-  ([as, bs = []]) => bs[0] === '\r' && bs.shift() ? [as, bs] : as[0] === '\r' && as.shift() ? [[], as] : [as, []])),
+  ([as, bs = []]) => bs[0] === '\r' && bs.shift() ? [as, bs] : as[0] === '\r' && as.shift() ? [[], as] : [as, []]))),
   ([content, params]: [(HTMLElement | string)[], string[]], rest, context) => {
     assert(content[0] !== '' || params.length === 0);
     if (content[0] === '') return [content, rest];
@@ -61,13 +62,14 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], syntax(Rule.link
     if (el.classList.contains('invalid')) return [[el], rest];
     assert(el.classList.length === 0);
     return [[define(el, attributes('link', [], optspec, params))], rest];
-  }))));
+  })));
 
-export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], syntax(Rule.link, 2, 10, bind(
+export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], bind(
+  creation(10, precedence(2,
   reverse(tails([
     dup(surround('[', some(union([unescsource]), ']'), ']')),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ])),
+  ])))),
   ([params, content = []], rest, context) => {
     assert(params[0] === '\r');
     params.shift();
@@ -86,7 +88,7 @@ export const textlink: TextLinkParser = lazy(() => validate(['[', '{'], syntax(R
     assert(!el.classList.contains('invalid'));
     assert(el.classList.length === 0);
     return [[define(el, attributes('link', [], optspec, params))], rest];
-  }))));
+  })));
 
 export const uri: LinkParser.ParameterParser.UriParser = fmap(union([
   open(/^[^\S\n]+/, str(/^\S+/)),

package/src/parser/inline/mark.ts

@@ -3,16 +3,17 @@ import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { startTight, blankWith } from '../visibility';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const mark: MarkParser = lazy(() => syntax(Rule.none, 1, surround(
+export const mark: MarkParser = lazy(() => surround(
   str('=='),
+  syntax(Syntax.none, 1, 1,
   startTight(some(union([
     some(inline, blankWith('==')),
     open(some(inline, '='), mark),
-  ]))),
+  ])))),
   str('=='), false,
   ([, bs], rest) => [[html('mark', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/math.ts

@@ -1,11 +1,11 @@
 import { MathParser } from '../inline';
-import { union, some, creator, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
+import { union, some, creation, precedence, validate, focus, rewrite, surround, lazy } from '../../combinator';
 import { escsource, unescsource } from '../source';
 import { html } from 'typed-dom/dom';
 
 const forbiddenCommand = /\\(?:begin|tiny|huge|large)(?![a-z])/i;
 
-export const math: MathParser = lazy(() => validate('$', creator(rewrite(
+export const math: MathParser = lazy(() => validate('$', creation(rewrite(
   union([
     surround('$', precedence(6, bracket), '$'),
     surround(
@@ -31,7 +31,7 @@ export const math: MathParser = lazy(() => validate('$', creator(rewrite(
       source)
   ], '']))));
 
-const bracket: MathParser.BracketParser = lazy(() => creator(surround(
+const bracket: MathParser.BracketParser = lazy(() => creation(surround(
   '{',
   some(union([
     bracket,

package/src/parser/inline/media.ts

@@ -1,11 +1,11 @@
 import { undefined, location } from 'spica/global';
 import { MediaParser } from '../inline';
-import { union, inits, tails, some, creator, precedence, guard, syntax, validate, verify, surround, open, dup, lazy, fmap, bind } from '../../combinator';
+import { union, inits, tails, some, creation, precedence, guard, syntax, validate, verify, surround, open, dup, lazy, fmap, bind } from '../../combinator';
 import { textlink, uri, option as linkoption, resolve } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
 import { txt, str } from '../source';
-import { Rule, State } from '../context';
+import { Syntax, State } from '../context';
 import { html, define } from 'typed-dom/dom';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, shift, push } from 'spica/array';
@@ -18,9 +18,10 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => validate(['![', '!{'], syntax(Rule.media, 2, 10, bind(verify(fmap(open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], bind(verify(fmap(open(
   '!',
   guard(context => ~context.state! & State.media,
+  syntax(Syntax.media, 2, 10,
   tails([
     dup(surround(
       '[',
@@ -28,7 +29,7 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], syntax(Rule.
       ']',
       true)),
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ]))),
+  ])))),
   ([as, bs]) => bs ? [[as.join('').trim() || as.join('')], shift(bs)[1]] : [[''], shift(as)[1]]),
   ([[text]]) => text === '' || text.trim() !== ''),
   ([[text], params], rest, context) => {
@@ -58,9 +59,9 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], syntax(Rule.
       textlink as MediaParser,
       ([link]) => [define(link, { target: '_blank' }, [el])])
       (`{ ${INSECURE_URI}${params.join('')} }${rest}`, context);
-  }))));
+  })));
 
-const bracket: MediaParser.TextParser.BracketParser = lazy(() => creator(union([
+const bracket: MediaParser.TextParser.BracketParser = lazy(() => creation(union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), some(union([unsafehtmlentity, bracket, txt]), ']'), str(']'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('{'), some(union([unsafehtmlentity, bracket, txt]), '}'), str('}'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),

package/src/parser/inline/reference.ts

@@ -1,17 +1,18 @@
 import { undefined } from 'spica/global';
 import { ReferenceParser } from '../inline';
-import { union, subsequence, some, context, creator, guard, syntax, state, validate, surround, open, lazy, bind } from '../../combinator';
+import { union, subsequence, some, context, creation, guard, syntax, state, surround, open, lazy, bind } from '../../combinator';
 import { inline } from '../inline';
 import { optimize } from './link';
 import { str, stropt } from '../source';
-import { Rule, State } from '../context';
+import { Syntax, State } from '../context';
 import { regBlankStart, startLoose, trimNode } from '../visibility';
 import { stringify } from '../util';
 import { html, defrag } from 'typed-dom/dom';
 
-export const reference: ReferenceParser = lazy(() => validate('[[', syntax(Rule.reference, 6, surround(
+export const reference: ReferenceParser = lazy(() => surround(
   '[[',
   guard(context => ~context.state! & State.reference,
+  syntax(Syntax.reference, 6, 1,
   state(State.annotation | State.reference | State.media,
   startLoose(
   context({ delimiters: undefined },
@@ -19,13 +20,13 @@ export const reference: ReferenceParser = lazy(() => validate('[[', syntax(Rule.
     abbr,
     open(stropt(/^(?=\^)/), some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]])),
     some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]]),
-  ])), ']'))),
+  ])), ']')))),
   ']]',
   false,
   ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNode(defrag(ns)))])], rest],
-  ([, ns, rest], next) => next[0] === ']' ? undefined : optimize('[[', ns, rest, next)))));
+  ([, ns, rest], next) => next[0] === ']' ? undefined : optimize('[[', ns, rest, next)));
 
-const abbr: ReferenceParser.AbbrParser = creator(bind(surround(
+const abbr: ReferenceParser.AbbrParser = creation(bind(surround(
   '^',
   union([str(/^(?![0-9]+\s?[|\]])[0-9A-Za-z]+(?:(?:-|(?=\W)(?!'\d)'?(?!\.\d)\.?(?!,\S),? ?)[0-9A-Za-z]+)*(?:-|'?\.?,? ?)?/)]),
   /^\|?(?=]])|^\|[^\S\n]*/),

package/src/parser/inline/ruby.ts

@@ -1,15 +1,15 @@
 import { undefined } from 'spica/global';
 import { RubyParser } from '../inline';
 import { eval, exec } from '../../combinator/data/parser';
-import { sequence, syntax, creator, validate, verify, focus, surround, lazy, fmap } from '../../combinator';
+import { sequence, syntax, creation, validate, verify, focus, surround, lazy, fmap } from '../../combinator';
 import { unsafehtmlentity } from './htmlentity';
 import { text as txt } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { isStartTightNodes } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 
-export const ruby: RubyParser = lazy(() => validate('[', syntax(Rule.none, 2, fmap(verify(
+export const ruby: RubyParser = lazy(() => validate('[', syntax(Syntax.none, 2, 1, fmap(verify(
   sequence([
     surround('[', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=]\()/, text), ']'),
     surround('(', focus(/^(?:\\[^\n]|[^\\[\](){}"\n])+(?=\))/, text), ')'),
@@ -48,7 +48,7 @@ export const ruby: RubyParser = lazy(() => validate('[', syntax(Rule.none, 2, fm
     }
   }))));
 
-const text: RubyParser.TextParser = creator((source, context) => {
+const text: RubyParser.TextParser = creation((source, context) => {
   const acc = [''];
   while (source !== '') {
     assert(source[0] !== '\n');

package/src/parser/inline/strong.ts

@@ -3,20 +3,21 @@ import { union, some, syntax, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { startTight, blankWith } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const strong: StrongParser = lazy(() => syntax(Rule.none, 1, surround(
+export const strong: StrongParser = lazy(() => surround(
   str('**'),
+  syntax(Syntax.none, 1, 1,
   startTight(some(union([
     some(inline, blankWith('**')),
     open(some(inline, '*'), union([
       emstrong,
       strong,
     ])),
-  ])), '*'),
+  ])), '*')),
   str('**'), false,
   ([, bs], rest) => [[html('strong', defrag(bs))], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]));

package/src/parser/inline/template.ts

@@ -1,18 +1,18 @@
 import { undefined } from 'spica/global';
 import { TemplateParser } from '../inline';
-import { union, some, syntax, creator, precedence, surround, lazy } from '../../combinator';
+import { union, some, syntax, creation, precedence, surround, lazy } from '../../combinator';
 import { optimize } from './link';
 import { escsource, str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { html } from 'typed-dom/dom';
 import { unshift } from 'spica/array';
 
-export const template: TemplateParser = lazy(() => syntax(Rule.none, 2, surround(
-  '{{', some(union([bracket, escsource]), '}'), '}}', true,
+export const template: TemplateParser = lazy(() => surround(
+  '{{', syntax(Syntax.none, 2, 1, some(union([bracket, escsource]), '}')), '}}', true,
   ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest],
-  ([, ns = [], rest], next) => next[0] === '}' ? undefined : optimize('{{', ns, rest, next))));
+  ([, ns = [], rest], next) => next[0] === '}' ? undefined : optimize('{{', ns, rest, next)));
 
-const bracket: TemplateParser.BracketParser = lazy(() => creator(union([
+const bracket: TemplateParser.BracketParser = lazy(() => creation(union([
   surround(str('('), some(union([bracket, escsource]), ')'), str(')'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('['), some(union([bracket, escsource]), ']'), str(']'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),
   surround(str('{'), some(union([bracket, escsource]), '}'), str('}'), true, undefined, ([as, bs = []], rest) => [unshift(as, bs), rest]),

package/src/parser/inline.test.ts

@@ -168,6 +168,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a*b\nc*]')), [['[', '<a href="/hashtags/a" class="hashtag">#a</a>', '<em>b<br>c</em>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[*a\nb*]{/}')), [['[', '<em>a<br>b</em>', ']', '<a href="/">/</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[*a\nb]*')), [['[', '*', 'a', '<br>', 'b', ']', '*'], '']);
+      assert.deepStrictEqual(inspect(parser('[*[a\nb*]')), [['', '[', '*', '[', 'a', '<br>', 'b', '*', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[[*a\nb*]]')), [['[', '[', '<em>a<br>b</em>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '[%', ' ', '"', '*', '"', '*', ' ', '%', ']'], '']);

package/src/parser/source/escapable.ts

@@ -1,10 +1,10 @@
 import { EscapableSourceParser } from '../source';
-import { creator } from '../../combinator';
+import { creation } from '../../combinator';
 import { nonWhitespace } from './text';
 
 const delimiter = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
 
-export const escsource: EscapableSourceParser = creator(source => {
+export const escsource: EscapableSourceParser = creation(source => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {

package/src/parser/source/str.ts

@@ -1,19 +1,19 @@
 import { undefined } from 'spica/global';
 import { StrParser } from '../source';
 import { Parser, Context } from '../../combinator/data/parser';
-import { creator } from '../../combinator';
+import { creation } from '../../combinator';
 
 export function str(pattern: string | RegExp): StrParser;
 export function str(pattern: string | RegExp): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
-    ? creator(source => {
+    ? creation(source => {
         if (source === '') return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
       })
-    : creator(source => {
+    : creation(source => {
         if (source === '') return;
         const m = source.match(pattern);
         return m && m[0].length > 0
@@ -26,13 +26,13 @@ export function stropt(pattern: string | RegExp): StrParser;
 export function stropt(pattern: string | RegExp): Parser<string, Context<StrParser>, []> {
   assert(pattern);
   return typeof pattern === 'string'
-    ? creator(source => {
+    ? creation(source => {
         if (source === '') return;
         return source.slice(0, pattern.length) === pattern
           ? [[pattern], source.slice(pattern.length)]
           : undefined;
       })
-    : creator(source => {
+    : creation(source => {
         if (source === '') return;
         const m = source.match(pattern);
         return m

package/src/parser/source/text.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { TextParser, TxtParser, LinebreakParser } from '../source';
-import { union, creator, focus } from '../../combinator';
+import { union, creation, focus } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom/dom';
 
@@ -9,7 +9,7 @@ export const nonWhitespace = /[\S\n]|$/;
 export const nonAlphanumeric = /[^0-9A-Za-z]|\S#|$/;
 const repeat = str(/^(.)\1*/);
 
-export const text: TextParser = creator((source, context) => {
+export const text: TextParser = creation((source, context) => {
   if (source === '') return;
   const i = source.search(delimiter);
   switch (i) {

package/src/parser/source/unescapable.ts

@@ -1,8 +1,8 @@
 import { UnescapableSourceParser } from '../source';
-import { creator } from '../../combinator';
+import { creation } from '../../combinator';
 import { delimiter, nonWhitespace, nonAlphanumeric, isAlphanumeric } from './text';
 
-export const unescsource: UnescapableSourceParser = creator(source => {
+export const unescsource: UnescapableSourceParser = creation(source => {
   assert(source[0] !== '\x1B');
   if (source === '') return;
   const i = source.search(delimiter);