securemark 0.258.0 → 0.258.3

package/src/parser/block.ts

@@ -1,6 +1,6 @@
 import { undefined } from 'spica/global';
 import { MarkdownParser } from '../../markdown';
-import { union, reset, creator, open, fallback, recover } from '../combinator';
+import { union, reset, creation, open, fallback, recover } from '../combinator';
 import { emptyline } from './source';
 import { horizontalrule } from './block/horizontalrule';
 import { heading } from './block/heading';
@@ -35,7 +35,7 @@ export import BlockquoteParser = BlockParser.BlockquoteParser;
 export import ReplyParser = BlockParser.ReplyParser;
 export import ParagraphParser = BlockParser.ParagraphParser;
 
-export const block: BlockParser = creator(error(
+export const block: BlockParser = creation(error(
   reset({ resources: { budget: 50 * 1000, recursion: 20 } },
   union([
     emptyline,

package/src/parser/context.ts

@@ -1,4 +1,4 @@
-export const enum Rule {
+export const enum Syntax {
   reference = 1 << 12,
   comment = 1 << 11,
   index = 1 << 10,
@@ -14,12 +14,6 @@ export const enum Rule {
   quote = 1 << 0,
   none = 0,
 }
-export const backtrackable = 0
-  | Rule.annotation
-  | Rule.reference
-  | Rule.index
-  | Rule.link
-  | Rule.media;
 
 export const enum State {
   annotation = 1 << 6,
@@ -30,3 +24,9 @@ export const enum State {
   media = 1 << 1,
   autolink = 1 << 0,
 }
+export const backtrackable = 0
+  | State.annotation
+  | State.reference
+  | State.index
+  | State.link
+  | State.media;

package/src/parser/inline/annotation.test.ts

@@ -18,11 +18,11 @@ describe('Unit: parser/inline/annotation', () => {
       assert.deepStrictEqual(inspect(parser('((\n))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\na))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\\\na))')), undefined);
-      assert.deepStrictEqual(inspect(parser('((a\n))')), [['', '(('], 'a\n))']);
-      assert.deepStrictEqual(inspect(parser('((a\\\n))')), [['', '(('], 'a\\\n))']);
-      assert.deepStrictEqual(inspect(parser('((a\nb))')), [['', '(('], 'a\nb))']);
-      assert.deepStrictEqual(inspect(parser('((a\\\nb))')), [['', '(('], 'a\\\nb))']);
-      assert.deepStrictEqual(inspect(parser('((*a\nb*))')), [['', '(('], '*a\nb*))']);
+      assert.deepStrictEqual(inspect(parser('((a\n))')), undefined);
+      assert.deepStrictEqual(inspect(parser('((a\\\n))')), undefined);
+      assert.deepStrictEqual(inspect(parser('((a\nb))')), undefined);
+      assert.deepStrictEqual(inspect(parser('((a\\\nb))')), undefined);
+      assert.deepStrictEqual(inspect(parser('((*a\nb*))')), undefined);
       assert.deepStrictEqual(inspect(parser('((\\))')), undefined);
       assert.deepStrictEqual(inspect(parser('((a)b))')), undefined);
       assert.deepStrictEqual(inspect(parser('(((a))')), undefined);

package/src/parser/inline/annotation.ts

@@ -1,20 +1,21 @@
 import { undefined } from 'spica/global';
 import { AnnotationParser } from '../inline';
-import { union, some, guard, context, syntax, state, validate, surround, lazy } from '../../combinator';
+import { union, some, guard, context, syntax, state, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { optimize } from './link';
-import { Rule, State } from '../context';
+import { Syntax, State } from '../context';
 import { startLoose, trimNode } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
-export const annotation: AnnotationParser = lazy(() => validate('((', syntax(Rule.annotation, 6, surround(
+export const annotation: AnnotationParser = lazy(() => surround(
   '((',
   guard(context => ~context.state! & State.annotation,
+  syntax(Syntax.annotation, 6, 1,
   state(State.annotation | State.media,
   startLoose(
   context({ delimiters: undefined },
-  some(union([inline]), ')', [[/^\\?\n/, 9], [')', 2], ['))', 6]])), ')'))),
+  some(union([inline]), ')', [[/^\\?\n/, 9], [')', 2], ['))', 6]])), ')')))),
   '))',
   false,
   ([, ns], rest) => [[html('sup', { class: 'annotation' }, [html('span', trimNode(defrag(ns)))])], rest],
-  ([, ns, rest], next) => next[0] === ')' ? undefined : optimize('((', ns, rest)))));
+  ([, ns, rest], next) => next[0] === ')' ? undefined : optimize('((', ns, rest, next)));

package/src/parser/inline/autolink/email.ts

@@ -1,11 +1,11 @@
 import { AutolinkParser } from '../../inline';
-import { creator, verify, rewrite } from '../../../combinator';
+import { creation, verify, rewrite } from '../../../combinator';
 import { str } from '../../source';
 import { html } from 'typed-dom/dom';
 
 // https://html.spec.whatwg.org/multipage/input.html
 
-export const email: AutolinkParser.EmailParser = creator(rewrite(verify(
+export const email: AutolinkParser.EmailParser = creation(rewrite(verify(
   str(/^[0-9A-Za-z]+(?:[.+_-][0-9A-Za-z]+)*@[0-9A-Za-z](?:(?:[0-9A-Za-z]|-(?=\w)){0,61}[0-9A-Za-z])?(?:\.[0-9A-Za-z](?:(?:[0-9A-Za-z]|-(?=\w)){0,61}[0-9A-Za-z])?)*(?![0-9A-Za-z])/),
   ([source]) => source.indexOf('@') <= 64 && source.length <= 255),
   source => [[html('a', { class: 'email', href: `mailto:${source}` }, source)], '']));

package/src/parser/inline/autolink/url.ts

@@ -1,5 +1,5 @@
 import { AutolinkParser } from '../../inline';
-import { union, some, creator, precedence, validate, focus, rewrite, convert, surround, open, lazy } from '../../../combinator';
+import { union, some, creation, precedence, validate, focus, rewrite, convert, surround, open, lazy } from '../../../combinator';
 import { textlink } from '../link';
 import { unescsource } from '../../source';
 
@@ -13,7 +13,7 @@ export const url: AutolinkParser.UrlParser = lazy(() => validate(['http://', 'ht
     url => `{ ${url} }`,
     union([textlink])))));
 
-const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creator(precedence(2, union([
+const bracket: AutolinkParser.UrlParser.BracketParser = lazy(() => creation(precedence(2, union([
   surround('(', some(union([bracket, unescsource]), ')'), ')', true),
   surround('[', some(union([bracket, unescsource]), ']'), ']', true),
   surround('{', some(union([bracket, unescsource]), '}'), '}', true),

package/src/parser/inline/autolink.ts

@@ -8,13 +8,13 @@ import { hashtag, emoji } from './autolink/hashtag';
 import { hashnum } from './autolink/hashnum';
 import { anchor } from './autolink/anchor';
 import { str } from '../source';
-import { Rule, State } from '../context';
+import { Syntax, State } from '../context';
 import { stringify } from '../util';
 
 export const autolink: AutolinkParser = fmap(
   validate(/^(?:[@#>0-9A-Za-z]|\S#)/,
   guard(context => ~context.state! & State.autolink,
-  syntax(Rule.autolink, 1,
+  syntax(Syntax.autolink, 1, 1,
   some(union([
     url,
     email,

package/src/parser/inline/bracket.ts

@@ -3,29 +3,29 @@ import { BracketParser } from '../inline';
 import { union, some, syntax, surround, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 
 const index = /^[0-9A-Za-z]+(?:(?:[.-]|, )[0-9A-Za-z]+)*/;
 
 export const bracket: BracketParser = lazy(() => union([
-  syntax(Rule.none, 2, surround(str('('), str(index), str(')'))),
-  syntax(Rule.bracket, 2, surround(str('('), some(inline, ')', [[')', 2]]), str(')'), true,
+  surround(str('('), syntax(Syntax.none, 2, 1, str(index)), str(')')),
+  surround(str('('), syntax(Syntax.bracket, 2, 1, some(inline, ')', [[')', 2]])), str(')'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
-    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest])),
-  syntax(Rule.none, 2, surround(str('（'), str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0)))), str('）'))),
-  syntax(Rule.bracket, 2, surround(str('（'), some(inline, '）', [['）', 2]]), str('）'), true,
+    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
+  surround(str('（'), syntax(Syntax.none, 2, 1, str(new RegExp(index.source.replace(', ', '[，、]').replace(/[09AZaz.]|\-(?!\w)/g, c => c.trimStart() && String.fromCharCode(c.charCodeAt(0) + 0xFEE0))))), str('）')),
+  surround(str('（'), syntax(Syntax.bracket, 2, 1, some(inline, '）', [['）', 2]])), str('）'), true,
     ([as, bs = [], cs], rest) => [[html('span', { class: 'paren' }, defrag(push(unshift(as, bs), cs)))], rest],
-    ([as, bs = []], rest) => [unshift(as, bs), rest])),
-  syntax(Rule.bracket, 2, surround(str('['), some(inline, ']', [[']', 2]]), str(']'), true,
+    ([as, bs = []], rest) => [unshift(as, bs), rest]),
+  surround(str('['), syntax(Syntax.bracket, 2, 1, some(inline, ']', [[']', 2]])), str(']'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest])),
-  syntax(Rule.bracket, 2, surround(str('{'), some(inline, '}', [['}', 2]]), str('}'), true,
+    ([as, bs = []], rest) => [unshift([''], unshift(as, bs)), rest]),
+  surround(str('{'), syntax(Syntax.bracket, 2, 1, some(inline, '}', [['}', 2]])), str('}'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest])),
+    ([as, bs = []], rest) => [unshift(as, bs), rest]),
   // Control media blinking in editing rather than control confusion of pairs of quote marks.
-  syntax(Rule.quote, 8, surround(str('"'), some(inline, '"', [['"', 8]]), str('"'), true,
+  surround(str('"'), syntax(Syntax.quote, 8, 1, some(inline, '"', [['"', 8]])), str('"'), true,
     undefined,
-    ([as, bs = []], rest) => [unshift(as, bs), rest])),
+    ([as, bs = []], rest) => [unshift(as, bs), rest]),
 ]));

package/src/parser/inline/code.ts

@@ -1,8 +1,8 @@
 import { CodeParser } from '../inline';
-import { creator, validate, match } from '../../combinator';
+import { creation, validate, match } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
-export const code: CodeParser = creator(validate('`', match(
+export const code: CodeParser = creation(validate('`', match(
   /^(`+)(?!`)([^\n]*?[^`\n])\1(?!`)/,
   ([whole, , body]) => rest =>
     [[html('code', { 'data-src': whole }, format(body))], rest.slice(whole.length)])));

package/src/parser/inline/comment.ts

@@ -2,12 +2,12 @@ import { CommentParser } from '../inline';
 import { union, some, syntax, validate, surround, open, close, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
-import { Rule } from '../context';
+import { Syntax } from '../context';
 import { html, defrag } from 'typed-dom/dom';
 import { memoize } from 'spica/memoize';
 import { unshift, push } from 'spica/array';
 
-export const comment: CommentParser = lazy(() => validate('[%', syntax(Rule.none, 4, match(
+export const comment: CommentParser = lazy(() => validate('[%', syntax(Syntax.none, 4, 1, match(
   /^\[(%+)\s/,
   memoize(
   ([, fence]) =>

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.test.ts

@@ -45,6 +45,7 @@ describe('Unit: parser/inline/link', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('')), undefined);
       assert.deepStrictEqual(inspect(parser('{}')), undefined);
+      assert.deepStrictEqual(inspect(parser('[{b}')), [['', '[', '<a href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{}')), undefined);
       assert.deepStrictEqual(inspect(parser('[]{ }')), undefined);
@@ -64,7 +65,7 @@ describe('Unit: parser/inline/link', () => {
       assert.deepStrictEqual(inspect(parser('[\\ ]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[\\\n]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[&Tab;]{b}')), undefined);
-      assert.deepStrictEqual(inspect(parser('[[]{b}')), undefined);
+      assert.deepStrictEqual(inspect(parser('[[]{b}')), [['', '[', '<a href="b">b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[]]{b}')), undefined);
       assert.deepStrictEqual(inspect(parser('[a]{}')), undefined);
       assert.deepStrictEqual(inspect(parser('[a\nb]{b}')), undefined);

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 } from '../../combinator/data/parser';
-import { union, inits, tails, subsequence, some, guard, syntax, state, validate, surround, open, dup, reverse, lazy, fmap, bind } from '../../combinator';
+import { Result, eval, exec } from '../../combinator/data/parser';
+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([
@@ -31,19 +32,22 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], syntax(Rule.link
         ']',
         true,
         undefined,
-        ([, ns = [], rest], next) => next[0] === ']' ? undefined : optimize('[', ns, rest)),
+        ([, ns = [], rest], next) => next[0] === ']' ? undefined : optimize('[', ns, rest, next)),
     ]))),
-    // 全体の失敗が確定した時も解析し予算を浪費している
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
-  ]),
-  ([as, bs = []]) => bs[0] === '\r' && bs.shift() ? [as, bs] : as[0] === '\r' && as.shift() ? [[], as] : [as, []])),
+  ], nodes => nodes[0][0] !== ''),
+  ([as, bs = []]) => bs[0] === '\r' && bs.shift() ? [as, bs] : as[0] === '\r' && as.shift() ? [[], as] : [as, []]))),
   ([content, params]: [(HTMLElement | string)[], string[]], rest, context) => {
-    if (params.length === 0) return;
     assert(content[0] !== '' || params.length === 0);
     if (content[0] === '') return [content, rest];
+    if (params.length === 0) return;
     assert(params.every(p => typeof p === 'string'));
     if (content.length !== 0 && trimNode(content).length === 0) return;
-    if (eval(some(autolink)(stringify(content), context))?.some(node => typeof node === 'object')) return;
+    for (let source = stringify(content); source;) {
+      const result = autolink(source, context);
+      if (typeof eval(result!)[0] === 'object') return;
+      source = exec(result!);
+    }
     assert(!html('div', content).querySelector('a, .media, .annotation, .reference') || (content[0] as HTMLElement).matches('.media'));
     const INSECURE_URI = params.shift()!;
     assert(INSECURE_URI === INSECURE_URI.trim());
@@ -58,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();
@@ -83,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+/)),
@@ -187,11 +192,15 @@ function decode(uri: string): string {
   }
 }
 
-export function optimize(opener: string, ns: readonly (string | HTMLElement)[], rest: string): Result<string> {
+export function optimize(opener: string, ns: readonly (string | HTMLElement)[], rest: string, next: string): Result<string> {
+  if (next[+(next[0] === '\\')] === '\n') return;
   let count = 0;
   for (let i = 0; i < ns.length - 1; i += 2) {
-    if (ns[i] !== '' || ns[i + 1] !== opener[0]) break;
-    ++count;
+    const fst = ns[i];
+    const snd = ns[i + 1] as string;
+    assert(typeof snd === 'string');
+    if (fst !== '' || snd[0] !== opener[0]) break;
+    count += snd.length;
   }
   return [['', opener[0].repeat(opener.length + count)], rest.slice(count)];
 }

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,