securemark 0.279.0 → 0.280.0

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

@@ -1,23 +1,23 @@
 import { ExtensionParser } from '../../inline';
-import { union, some, syntax, creation, precedence, constraint, validate, surround, open, lazy, fmap } from '../../../combinator';
+import { union, inits, some, syntax, creation, precedence, constraint, validate, surround, open, lazy, fmap } from '../../../combinator';
 import { inline } from '../../inline';
 import { indexee, identity } from './indexee';
-import { txt, str, stropt } from '../../source';
+import { txt, str } from '../../source';
 import { Syntax, State } from '../../context';
 import { startTight, trimNodeEnd } from '../../visibility';
 import { html, define, defrag } from 'typed-dom/dom';
 
 import IndexParser = ExtensionParser.IndexParser;
 
-export const index: IndexParser = lazy(() => validate('[#', fmap(indexee(surround(
+export const index: IndexParser = lazy(() => validate('[#', creation(fmap(indexee(surround(
   '[#',
   constraint(State.index, false,
-  syntax(Syntax.index, 2, 1, State.linkers | State.media,
+  syntax(Syntax.index, 2, State.linkers | State.media,
   startTight(
-  open(stropt('|'), some(union([
-    signature,
+  some(inits([
     inline,
-  ]), ']', [[/^\\?\n/, 9], [']', 2]]), true)))),
+    signature,
+  ]), ']', [[/^\\?\n/, 9], [']', 2]])))),
   ']',
   false,
   ([, ns], rest) => [[html('a', trimNodeEnd(defrag(ns)))], rest])),
@@ -28,18 +28,18 @@ export const index: IndexParser = lazy(() => validate('[#', fmap(indexee(surroun
         class: 'index',
         href: el.id ? `#${el.id}` : undefined,
       }),
-  ])));
+  ]))));
 
-export const signature: IndexParser.SignatureParser = lazy(() => creation(fmap(open(
+export const signature: IndexParser.SignatureParser = lazy(() => validate('|', creation(fmap(open(
   '|',
   startTight(some(union([bracket, txt]), ']'))),
   ns => [
     html('span', { class: 'indexer', 'data-index': identity(undefined, ns.join(''))!.slice(7) }),
-  ])));
+  ]))));
 
 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),
-  surround(str('"'), precedence(8, some(txt, '"')), str('"'), true),
+  surround(str('"'), precedence(3, some(txt, '"')), str('"'), true),
 ])));

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

@@ -1,5 +1,5 @@
 import { ExtensionParser } from '../../inline';
-import { union, some, syntax, validate, surround, lazy } from '../../../combinator';
+import { union, some, syntax, creation, validate, surround, lazy } from '../../../combinator';
 import { inline } from '../../inline';
 import { str } from '../../source';
 import { Syntax, State } from '../../context';
@@ -11,9 +11,9 @@ import { html, defrag } from 'typed-dom/dom';
 
 // All syntax surrounded by square brackets shouldn't contain line breaks.
 
-export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', surround(
+export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validate('[', creation(surround(
   str(/^\[[:^|]/),
-  syntax(Syntax.placeholder, 2, 1, State.none,
+  syntax(Syntax.placeholder, 2, State.none,
   startTight(some(union([inline]), ']', [[']', 2]]))),
   str(']'), false,
   ([, bs], rest) => [[
@@ -24,4 +24,4 @@ export const placeholder: ExtensionParser.PlaceholderParser = lazy(() => validat
       'data-invalid-message': `Invalid start symbol or linebreak`,
     }, defrag(bs)),
   ], rest],
-  ([as, bs], rest) => [unshift(as, bs), rest])));
+  ([as, bs], rest) => [unshift(as, bs), rest]))));

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

@@ -75,7 +75,7 @@ describe('Unit: parser/inline/html', () => {
     });
 
     it('nest', () => {
-      assert.deepStrictEqual(inspect(parser('<bdi>[% </bdi>')), [['<bdi>[% </bdi>'], '']);
+      assert.deepStrictEqual(inspect(parser('<bdi>[% </bdi>')), [['<span class="invalid">&lt;bdi&gt;[% &lt;/bdi&gt;</span>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi><bdi>a</bdi></bdi>')), [['<bdi><bdi>a</bdi></bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>a<bdi>b</bdi>c</bdi>')), [['<bdi>a<bdi>b</bdi>c</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('<bdi>`a`</bdi>')), [['<bdi><code data-src="`a`">a</code></bdi>'], '']);

package/src/parser/inline/html.ts

@@ -1,5 +1,5 @@
 import { HTMLParser } from '../inline';
-import { union, subsequence, some, syntax, validate, focus, surround, open, match, lazy } from '../../combinator';
+import { union, subsequence, some, syntax, creation, validate, focus, surround, open, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { Syntax, State } from '../context';
@@ -18,7 +18,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]|>)/i, syntax(Syntax.none, 5, 1, State.none, union([
+export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^\S\n]|>)/i, creation(syntax(Syntax.none, 4, State.none, union([
   focus(
     /^<wbr[^\S\n]*>/i,
     () => [[h('wbr')], '']),
@@ -35,14 +35,13 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
         str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
         subsequence([
           focus(/^[^\S\n]*\n/, some(inline)),
-          some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 5]]), true)),
+          some(open(/^\n?/, some(inline, blankWith('\n', `</${tag}>`), [[blankWith('\n', `</${tag}>`), 4]]), true)),
         ]),
         str(`</${tag}>`), true,
         ([as, bs = [], cs], rest) =>
           [[elem(tag, as, bs, cs)], rest],
         ([as, bs = []], rest) =>
-          [[elem(tag, as, bs, [])], rest]),
-    ([, tag]) => TAGS.indexOf(tag), [])),
+          [[elem(tag, as, bs, [])], rest]))),
   match(
     /^<([a-z]+)(?=[^\S\n]|>)/i,
     memoize(
@@ -51,7 +50,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
         str(`<${tag}`), some(attribute), str(/^[^\S\n]*>/), true),
         subsequence([
           focus(/^[^\S\n]*\n/, some(inline)),
-          some(inline, `</${tag}>`, [[`</${tag}>`, 5]]),
+          some(inline, `</${tag}>`, [[`</${tag}>`, 4]]),
         ]),
         str(`</${tag}>`), true,
         ([as, bs = [], cs], rest) =>
@@ -60,7 +59,7 @@ export const html: HTMLParser = lazy(() => validate('<', validate(/^<[a-z]+(?=[^
           [[elem(tag, as, bs, [])], rest]),
     ([, tag]) => tag,
     new Clock(10000))),
-])))));
+]))))));
 
 export const attribute: HTMLParser.AttributeParser = union([
   str(/^[^\S\n]+[a-z]+(?:-[a-z]+)*(?:="[^"\n]*")?(?=[^\S\n]|>)/i),

package/src/parser/inline/insertion.ts

@@ -1,5 +1,5 @@
 import { InsertionParser } from '../inline';
-import { union, some, syntax, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, creation, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { str } from '../source';
 import { Syntax, State } from '../context';
@@ -7,13 +7,13 @@ import { blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const insertion: InsertionParser = lazy(() => surround(
+export const insertion: InsertionParser = lazy(() => creation(surround(
   str('++', '+'),
-  syntax(Syntax.none, 1, 1, State.none,
+  syntax(Syntax.none, 1, State.none,
   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

@@ -20,9 +20,9 @@ export const link: LinkParser = lazy(() => validate(['[', '{'], union([
   textlink,
 ])));
 
-export const textlink: LinkParser.TextLinkParser = lazy(() =>
+export const textlink: LinkParser.TextLinkParser = lazy(() => creation(10,
   constraint(State.link, false,
-  syntax(Syntax.link, 2, 10, State.linkers | State.media,
+  syntax(Syntax.link, 2, State.linkers | State.media,
   bind(reverse(tails([
     dup(surround(
       '[',
@@ -36,11 +36,11 @@ export const textlink: LinkParser.TextLinkParser = lazy(() =>
     assert(content[0] !== '');
     if (content.length !== 0 && trimNodeEnd(content = defrag(content)).length === 0) return;
     return [[parse(content, params, context)], rest];
-  }))));
+  })))));
 
-export const medialink: LinkParser.MediaLinkParser = lazy(() =>
+export const medialink: LinkParser.MediaLinkParser = lazy(() => creation(10,
   constraint(State.link | State.media, false,
-  syntax(Syntax.link, 2, 10, State.linkers,
+  syntax(Syntax.link, 2, State.linkers,
   bind(reverse(sequence([
     dup(surround(
       '[',
@@ -49,7 +49,7 @@ export const medialink: LinkParser.MediaLinkParser = lazy(() =>
     dup(surround(/^{(?![{}])/, inits([uri, some(option)]), /^[^\S\n]*}/)),
   ])),
   ([params, content = []]: [string[], (HTMLElement | string)[]], rest, context) =>
-    [[parse(defrag(content), params, context)], rest]))));
+    [[parse(defrag(content), params, context)], rest])))));
 
 export const linemedialink: LinkParser.LineMediaLinkParser = surround(
   linebreak,

package/src/parser/inline/mark.ts

@@ -1,5 +1,5 @@
 import { MarkParser } from '../inline';
-import { union, some, syntax, constraint, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, creation, constraint, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { identity, signature } from './extension/indexee';
 import { str } from '../source';
@@ -8,10 +8,10 @@ import { Syntax, State } from '../context';
 import { unshift } from 'spica/array';
 import { html, define, defrag } from 'typed-dom/dom';
 
-export const mark: MarkParser = lazy(() => surround(
+export const mark: MarkParser = lazy(() => creation(surround(
   str('==', '='),
   constraint(State.mark, false,
-  syntax(Syntax.none, 1, 1, State.none,
+  syntax(Syntax.none, 1, State.none,
   startTight(some(union([
     some(inline, blankWith('=='), [[/^\\?\n/, 9]]),
     open(some(inline, '=', [[/^\\?\n/, 9]]), mark),
@@ -24,4 +24,4 @@ export const mark: MarkParser = lazy(() => surround(
       el.id && html('a', { href: `#${el.id}` }),
     ], rest];
   },
-  ([as, bs], rest) => [unshift(as, bs), rest]));
+  ([as, bs], rest) => [unshift(as, bs), rest])));

package/src/parser/inline/media.ts

@@ -18,10 +18,10 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => validate(['![', '!{'], open(
+export const media: MediaParser = lazy(() => validate(['![', '!{'], creation(10, open(
   '!',
   constraint(State.media, false,
-  syntax(Syntax.media, 2, 10, ~State.link,
+  syntax(Syntax.media, 2, ~State.link,
   bind(verify(fmap(tails([
     dup(surround(
       '[',
@@ -60,7 +60,7 @@ export const media: MediaParser = lazy(() => validate(['![', '!{'], open(
       unsafelink as MediaParser,
       ([link]) => [define(link, { class: null, target: '_blank' }, [el])])
       ({ source: `{ ${INSECURE_URI}${params.join('')} }${rest}`, context });
-  }))))));
+  })))))));
 
 export const linemedia: MediaParser.LineMediaParser = surround(
   linebreak,
@@ -71,7 +71,7 @@ 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]),
-  surround(str('"'), precedence(8, some(union([unsafehtmlentity, txt]), '"')), str('"'), true),
+  surround(str('"'), precedence(3, some(union([unsafehtmlentity, txt]), '"')), str('"'), true),
 ])));
 
 const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([

package/src/parser/inline/reference.ts

@@ -6,17 +6,17 @@ import { Syntax, State } from '../context';
 import { blank, trimBlankStart, trimNodeEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 
-export const reference: ReferenceParser = lazy(() => surround(
+export const reference: ReferenceParser = lazy(() => creation(surround(
   '[[',
   constraint(State.reference, false,
-  syntax(Syntax.reference, 6, 1, State.annotation | State.reference | State.media,
+  syntax(Syntax.reference, 6, State.annotation | State.reference | State.media,
   subsequence([
     abbr,
     trimBlankStart(some(inline, ']', [[/^\\?\n/, 9], [']', 2], [']]', 6]])),
   ]))),
   ']]',
   false,
-  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNodeEnd(defrag(ns)))])], rest]));
+  ([, ns], rest) => [[html('sup', attributes(ns), [html('span', trimNodeEnd(defrag(ns)))])], rest])));
 
 // Chicago-Style
 const abbr: ReferenceParser.AbbrParser = creation(surround(

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

@@ -16,12 +16,12 @@ describe('Unit: parser/inline/remark', () => {
       assert.deepStrictEqual(inspect(parser('[% ')), [['[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% \n a')), [['[%', '<br>', ' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[%%]')), undefined);
-      assert.deepStrictEqual(inspect(parser('[% [%')), [['[%', ' ', '', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% [%')), [['[%', ' ', '[', '%'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% ')), [['[%', ' ', '[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% a')), [['[%', ' ', '[%', ' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% a %]')), [['[%', ' ', '<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a[%')), [['[%', ' ', 'a', '', '[', '%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a [%')), [['[%', ' ', 'a', ' ', '', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a[%')), [['[%', ' ', 'a', '[', '%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% a [%')), [['[%', ' ', 'a', ' ', '[', '%'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [% ')), [['[%', ' ', 'a', ' ', '[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [% b')), [['[%', ' ', 'a', ' ', '[%', ' ', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [%% b')), [['[%', ' ', 'a', ' ', '[%%', ' ', 'b'], '']);
@@ -58,6 +58,7 @@ describe('Unit: parser/inline/remark', () => {
       assert.deepStrictEqual(inspect(parser('[% [ %]')), [['<span class="remark"><input type="checkbox"><span>[% [ %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% \\ a %]')), [['<span class="remark"><input type="checkbox"><span>[%  a %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% $-a %]$')), [['<span class="remark"><input type="checkbox"><span>[% <a class="label" data-label="$-a">$-a</a> %]</span></span>'], '$']);
+      assert.deepStrictEqual(inspect(parser('[% <bdi> %]')), [['<span class="remark"><input type="checkbox"><span>[% <span class="invalid">&lt;bdi&gt;</span> %]</span></span>'], '']);
     });
 
   });

package/src/parser/inline/remark.ts

@@ -1,5 +1,5 @@
 import { RemarkParser } from '../inline';
-import { union, some, syntax, validate, surround, open, close, match, lazy } from '../../combinator';
+import { union, some, syntax, creation, validate, surround, open, close, match, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
 import { Syntax, State } from '../context';
@@ -7,13 +7,13 @@ import { memoize } from 'spica/memoize';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const remark: RemarkParser = lazy(() => validate('[%', syntax(Syntax.none, 4, 1, State.none, match(
+export const remark: RemarkParser = lazy(() => validate('[%', creation(syntax(Syntax.none, 5, State.none, match(
   /^\[(%+)\s/,
   memoize(
   ([, fence]) =>
     surround(
       open(str(`[${fence}`), some(text, new RegExp(String.raw`^\s+${fence}\]|^\S`)), true),
-      some(union([inline]), new RegExp(String.raw`^\s+${fence}\]`), [[new RegExp(String.raw`^\s+${fence}\]`), 4]]),
+      some(union([inline]), new RegExp(String.raw`^\s+${fence}\]`), [[new RegExp(String.raw`^\s+${fence}\]`), 5]]),
       close(some(text, /^\S/), str(`${fence}]`)), true,
       ([as, bs = [], cs], rest) => [[
         html('span', { class: 'remark' }, [
@@ -22,4 +22,4 @@ export const remark: RemarkParser = lazy(() => validate('[%', syntax(Syntax.none
         ]),
       ], rest],
       ([as, bs = []], rest) => [unshift(as, bs), rest]),
-  ([, fence]) => fence.length, [])))));
+  ([, fence]) => fence.length, {}))))));

package/src/parser/inline/ruby.ts

@@ -8,7 +8,7 @@ import { isStartTightNodes } from '../visibility';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const ruby: RubyParser = lazy(() => validate('[', syntax(Syntax.ruby, 2, 1, State.all, fmap(verify(fmap(
+export const ruby: RubyParser = lazy(() => validate('[', creation(syntax(Syntax.ruby, 2, State.all, fmap(verify(fmap(
   sequence([
     surround('[', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ']'),
     surround('(', str(/^(?:\\[^\n]|[^\\[\](){}"\n])+/), ')'),
@@ -49,7 +49,7 @@ export const ruby: RubyParser = lazy(() => validate('[', syntax(Syntax.ruby, 2,
             [html('rp', '('), html('rt', rubies.join(' ').trim()), html('rp', ')')]))),
         ];
     }
-  }))));
+  })))));
 
 const text: RubyParser.TextParser = creation(1, false, ({ source, context }) => {
   const acc = [''];

package/src/parser/inline/strong.ts

@@ -1,5 +1,5 @@
 import { StrongParser } from '../inline';
-import { union, some, syntax, surround, open, lazy } from '../../combinator';
+import { union, some, syntax, creation, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { emstrong } from './emstrong';
 import { str } from '../source';
@@ -8,9 +8,9 @@ import { startTight, blankWith } from '../visibility';
 import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const strong: StrongParser = lazy(() => surround(
+export const strong: StrongParser = lazy(() => creation(surround(
   str('**', '*'),
-  syntax(Syntax.none, 1, 1, State.none,
+  syntax(Syntax.none, 1, State.none,
   startTight(some(union([
     some(inline, blankWith('**'), [[/^\\?\n/, 9]]),
     open(some(inline, '*', [[/^\\?\n/, 9]]), union([
@@ -20,4 +20,4 @@ export const strong: StrongParser = lazy(() => surround(
   ])))),
   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

@@ -5,13 +5,16 @@ import { Syntax, State } from '../context';
 import { unshift } from 'spica/array';
 import { html } from 'typed-dom/dom';
 
-export const template: TemplateParser = lazy(() => surround(
-  '{{', syntax(Syntax.none, 2, 1, State.all, some(union([bracket, escsource]), '}')), '}}', true,
-  ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest]));
+export const template: TemplateParser = lazy(() => creation(surround(
+  '{{',
+  syntax(Syntax.none, 6, State.all, some(union([bracket, escsource]), '}', [['}}', 6]])),
+  '}}',
+  true,
+  ([, ns = []], rest) => [[html('span', { class: 'template' }, `{{${ns.join('').replace(/\x1B/g, '')}}}`)], rest])));
 
 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]),
-  surround(str('"'), precedence(8, some(escsource, /^"|^\\?\n/)), str('"'), true),
+  surround(str('"'), precedence(3, some(escsource, /^"|^\\?\n/)), str('"'), true),
 ])));

package/src/parser/inline.test.ts

@@ -18,6 +18,8 @@ describe('Unit: parser/inline', () => {
     });
 
     it('nest', () => {
+      assert.deepStrictEqual(inspect(parser('あ（Ａ）')), [['あ', '（', 'Ａ', '）'], '']);
+      assert.deepStrictEqual(inspect(parser('あ（い）')), [['あ', '<span class="paren">（い）</span>'], '']);
       assert.deepStrictEqual(inspect(parser('+++a+++')), [['+++', 'a', '+++'], '']);
       assert.deepStrictEqual(inspect(parser('~~~a~~~')), [['~~~', 'a', '~~~'], '']);
       assert.deepStrictEqual(inspect(parser('===a===')), [['===', 'a', '==='], '']);
@@ -143,36 +145,31 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('${{{a}}}')), [['$', '<span class="template">{{{a}}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('Di$ney Micro$oft')), [['Di', '$', 'ney', ' ', 'Micro', '$', 'oft'], '']);
       assert.deepStrictEqual(inspect(parser('Di$ney, Micro$oft')), [['Di', '$', 'ney', ',', ' ', 'Micro', '$', 'oft'], '']);
-      assert.deepStrictEqual(inspect(parser('(((a))')), [['', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((((a))')), [['', '(', '', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('(((a))')), [['(', '<sup class="annotation"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('((((a))')), [['(', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))))')), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((<bdi>))')), [['<sup class="annotation"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('((${))}$')), [['', '(', '', '(', '<span class="math" translate="no" data-src="${))}$">${))}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('((${))}$')), [['(', '(', '<span class="math" translate="no" data-src="${))}$">${))}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"((""))')), [['"', '<sup class="annotation"><span>""</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[a]]')), [['', '[', '<sup class="reference"><span>a</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['', '[', '', '[', '<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[a]]')), [['[', '<sup class="reference"><span>a</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[[a]]')), [['[', '[', '<sup class="reference"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[[a]]]]')), [['<sup class="reference"><span>[[a]]</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[$-1]]]')), [['<sup class="reference"><span><a class="label" data-label="$-1">$-1</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[]{a}]]')), [['<sup class="reference"><span><a class="url" href="a">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[[a]{b}]]')), [['<sup class="reference"><span><a class="link" href="b">a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[(([a]{#}))]{#}')), [['<a class="link" href="#"><span class="paren">(<span class="paren">([a]{#})</span>)</span></a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[<bdi>]]')), [['<sup class="reference"><span><span class="invalid">&lt;bdi&gt;</span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[${]]}$')), [['', '[', '', '[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[${]]}$')), [['[', '[', '<span class="math" translate="no" data-src="${]]}$">${]]}$</span>'], '']);
       assert.deepStrictEqual(inspect(parser('"[[""]]')), [['"', '<sup class="reference"><span>""</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[==a==]{b}')), [['<a class="link" href="b">==a==</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a](b)]{c}')), [['<a class="link" href="c"><ruby>a<rp>(</rp><rt>b</rt><rp>)</rp></ruby></a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[[[[[[{a}')), [['', '[', '', '[', '', '[', '', '[', '', '[', '', '[', '', '[', '<a class="url" href="a">a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[[[[[[{a}')), [['[', '[', '[', '[', '[', '[', '[', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('<http://host>')), [['<', '<a class="url" href="http://host" target="_blank">http://host</a>', '>'], '']);
-      assert.deepStrictEqual(inspect(parser('[~http://host')), [['', '[', '~', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[~a@b')), [['', '[', '~', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[~http://host')), [['[', '~', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[~a@b')), [['[', '~', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[~~a~~]')), [['[', '<del>a</del>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[^http://host')), [['[^', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[^a@b')), [['[^', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a++b\nc++]')), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '<ins>b<br>c</ins>', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[++a\nb++]{/}')), [['[', '<ins>a<br>b</ins>', ']', '<a class="url" 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++]]')), [['[', '[', '<ins>a<br>b</ins>', ']', ']'], '']);
       assert.deepStrictEqual(inspect(parser('"[% *"*"*')), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]')), [['"', '<span class="remark"><input type="checkbox"><span>[% "*"* %]</span></span>'], '']);
     });
@@ -242,7 +239,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*a*#b')), [['<em>a</em>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('((a))#b')), [['<sup class="annotation"><span>a</span></sup>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[a]]#b')), [['<sup class="reference"><span>a</span></sup>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#a')), [['', '[', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('[#a')), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('|#a')), [['|', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser(' #a')), [[' ', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
     });

package/src/parser/processor/figure.ts

@@ -127,7 +127,6 @@ export function* figure(
     }
     yield ref;
   }
-  return;
 }
 
 const messages = {

package/src/parser/processor/note.ts

@@ -14,7 +14,6 @@ export function* note(
 ): Generator<HTMLAnchorElement | HTMLLIElement | undefined, undefined, undefined> {
   yield* annotation(target, notes?.annotations, opts, bottom);
   yield* reference(target, notes?.references, opts, bottom);
-  return;
 }
 
 export const annotation = build('annotation', n => `*${n}`, 'h1, h2, h3, h4, h5, h6, aside.aside, hr');
@@ -180,7 +179,6 @@ function build(
         el.remove();
       }
     }
-    return;
   }
 
   function* proc(defs: Map<string, HTMLLIElement>, note: HTMLOListElement): Generator<HTMLLIElement | undefined, undefined, undefined> {
@@ -213,7 +211,6 @@ function build(
       --length;
       assert(children.length === length);
     }
-    return;
   }
 }
 

package/src/parser/source/str.ts

@@ -22,22 +22,3 @@ export function str(pattern: string | RegExp, not?: string): Parser<string, Cont
           : undefined;
       });
 }
-
-export function stropt(pattern: string | RegExp): StrParser;
-export function stropt(pattern: string | RegExp): Parser<string, Context<StrParser>, []> {
-  assert(pattern);
-  return typeof pattern === 'string'
-    ? creation(1, false, ({ source }) => {
-        if (source === '') return;
-        return source.slice(0, pattern.length) === pattern
-          ? [[pattern], source.slice(pattern.length)]
-          : [[''], source];
-      })
-    : creation(1, false, ({ source }) => {
-        if (source === '') return;
-        const m = source.match(pattern);
-        return m
-          ? [[m[0]], source.slice(m[0].length)]
-          : undefined;
-      });
-}

package/src/parser/source/text.test.ts

@@ -2,7 +2,7 @@ import { text } from './text';
 import { some } from '../../combinator';
 import { inspect } from '../../debug.test';
 
-describe('Unit: parser/text/text', () => {
+describe('Unit: parser/source/text', () => {
   describe('text', () => {
     const parser = (source: string) => some(text)({ source, context: {} });
 

package/src/parser/source/text.ts

@@ -3,9 +3,9 @@ import { union, creation, focus } from '../../combinator';
 import { str } from './str';
 import { html } from 'typed-dom/dom';
 
-export const delimiter = /[\s\x00-\x7F]|\S[#>]/u;
-export const nonWhitespace = /[\S\n]|$/;
-export const nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/;
+export const delimiter = /[\s\x00-\x7F（）]|\S[#>]/u;
+export const nonWhitespace = /[\S\n]|$/u;
+export const nonAlphanumeric = /[^0-9A-Za-z]|\S[#>]|$/u;
 const repeat = str(/^(.)\1*/);
 
 export const text: TextParser = creation(1, false, ({ source, context }) => {

package/src/parser/source.ts

@@ -14,5 +14,5 @@ export import AnyLineParser = SourceParser.AnyLineParser;
 export { text, txt, linebreak } from './source/text';
 export { escsource } from './source/escapable';
 export { unescsource } from './source/unescapable';
-export { str, stropt } from './source/str';
+export { str } from './source/str';
 export { contentline, emptyline, anyline } from './source/line';

package/src/parser/visibility.ts

@@ -170,7 +170,6 @@ function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser
 //}
 //function trimNodeStart<T extends HTMLElement | string>(nodes: T[]): T[] {
 //  for (let node = nodes[0]; nodes.length > 0 && !isVisible(node = nodes[0], 0);) {
-//    if (nodes.length === 1 && typeof node === 'object' && node.className === 'indexer') break;
 //    if (typeof node === 'string') {
 //      const pos = node.trimStart().length;
 //      if (pos > 0) {
@@ -178,6 +177,9 @@ function trimBlankEnd<T extends HTMLElement | string>(parser: Parser<T>): Parser
 //        break;
 //      }
 //    }
+//    else if (nodes.length === 1 && node.className === 'indexer') {
+//      break;
+//    }
 //    nodes.shift();
 //  }
 //  return nodes;