securemark 0.292.0 → 0.293.0

package/src/parser/inline/media.ts

@@ -5,7 +5,7 @@ import { union, inits, tails, some, creation, recursion, precedence, constraint,
 import { unsafelink, uri, option as linkoption, resolve, decode } from './link';
 import { attributes } from './html';
 import { unsafehtmlentity } from './htmlentity';
-import { txt, linebreak, str } from '../source';
+import { txt, str } from '../source';
 import { invalid } from '../util';
 import { ReadonlyURL } from 'spica/url';
 import { unshift, push } from 'spica/array';
@@ -19,7 +19,7 @@ const optspec = {
 } as const;
 Object.setPrototypeOf(optspec, null);
 
-export const media: MediaParser = lazy(() => constraint(State.media, validate(['![', '!{'], creation(10, open(
+export const media: MediaParser = lazy(() => constraint(State.media, validate(/![[{]/y, creation(10, open(
   '!',
   bind(verify(fmap(tails([
     dup(surround(
@@ -38,9 +38,9 @@ export const media: MediaParser = lazy(() => constraint(State.media, validate(['
       undefined,
       [3 | Backtrack.escbracket])),
     dup(surround(
-      /^{(?![{}])/,
+      /{(?![{}])/y,
       inits([uri, some(option)]),
-      /^[^\S\n]*}/,
+      /[^\S\n]*}/y,
       false,
       undefined,
       ([as, bs], context) => {
@@ -107,9 +107,9 @@ export const media: MediaParser = lazy(() => constraint(State.media, validate(['
   }))))));
 
 export const linemedia: MediaParser.LineMediaParser = surround(
-  linebreak,
+  /(?<=^|[\r\n])/y,
   union([media]),
-  /^(?=[^\S\n]*(?:$|\n))/);
+  /(?=[^\S\n]*(?:$|\n))/y);
 
 const bracket: MediaParser.TextParser.BracketParser = lazy(() => recursion(Recursion.terminal, union([
   surround(str('('), some(union([unsafehtmlentity, bracket, txt]), ')'), str(')'), true,
@@ -124,9 +124,9 @@ const bracket: MediaParser.TextParser.BracketParser = lazy(() => recursion(Recur
 
 const option: MediaParser.ParameterParser.OptionParser = lazy(() => union([
   surround(
-    open(/^[^\S\n]+/, str(/^[1-9][0-9]*/)),
-    str(/^[x:]/),
-    str(/^[1-9][0-9]*(?=[^\S\n]|})/),
+    open(/[^\S\n]+/y, str(/[1-9][0-9]*/y)),
+    str(/[x:]/y),
+    str(/[1-9][0-9]*(?=[^\S\n]|})/y),
     false,
     ([[a], [b], [c]]) => [
       b === 'x'

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

@@ -69,7 +69,7 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[^A ]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A  ]]'), ctx), [['<sup class="invalid"><span>^A</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A B]]'), ctx), [['<sup class="reference" data-abbr="A B"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A  B]]'), ctx), [['<sup class="invalid"><span>^A  B</span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^A  B]]'), ctx), [['<sup class="invalid"><span>^A B</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A|]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A,|]]'), ctx), [['<sup class="reference" data-abbr="A,"><span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A |]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
@@ -77,11 +77,11 @@ describe('Unit: parser/inline/reference', () => {
       assert.deepStrictEqual(inspect(parser('[[^A|b]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A|b ]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A|b  ]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|<wbr>]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|<wbr>b]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A| ]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A| b]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
-      assert.deepStrictEqual(inspect(parser('[[^A|  ]]'), ctx), [['<sup class="reference" data-abbr="A"><span></span></sup>'], '']);
+      assert.deepStrictEqual(inspect(parser('[[^A|  ]]'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[[^A|<wbr>]]'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('[[^A|<wbr>b]]'), ctx), [['<sup class="reference" data-abbr="A"><span>b</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A|^]]'), ctx), [['<sup class="reference" data-abbr="A"><span>^</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^A|^B]]'), ctx), [['<sup class="reference" data-abbr="A"><span>^B</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[^1]]'), ctx), [['<sup class="invalid"><span>^1</span></sup>'], '']);

package/src/parser/inline/reference.ts

@@ -5,7 +5,7 @@ import { union, subsequence, some, precedence, state, constraint, surround, isBa
 import { inline } from '../inline';
 import { textlink } from './link';
 import { str } from '../source';
-import { blank, trimBlankStart, trimBlankNodeEnd } from '../visibility';
+import { trimBlankStart, trimBlankNodeEnd } from '../visibility';
 import { html, defrag } from 'typed-dom/dom';
 import { unshift, push } from 'spica/array';
 import { invalid } from '../util';
@@ -93,13 +93,13 @@ export const reference: ReferenceParser = lazy(() => constraint(State.reference,
 // Chicago-Style
 const abbr: ReferenceParser.AbbrParser = surround(
   str('^'),
-  union([str(/^(?=[A-Z])(?:[0-9A-Za-z]'?|(?:[-.:]|\.?\??,? ?)(?!['\-.:?, ]))+/)]),
-  /^\|?(?=]])|^\|/,
+  union([str(/(?=[A-Z])(?:[0-9A-Za-z]'?|(?:[-.:]|\.?\??,? ?)(?!['\-.:?, ]))+/y)]),
+  /\|?(?=]])|\|/y,
   true,
   ([, ns], context) => {
     const { source, position, range = 0 } = context;
     if (!ns) return [['', source.slice(position - range, source[position - 1] === '|' ? position - 1 : position)]];
-    context.position += source.slice(position).match(blank.start)?.[0].length ?? 0;
+    context.position += source[position] === ' ' ? 1 : 0;
     return [[Command.Separator, ns[0].trimEnd()]];
   },
   (_, context) => {

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

@@ -15,16 +15,16 @@ describe('Unit: parser/inline/remark', () => {
       assert.deepStrictEqual(inspect(parser('[%[%'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[%a%]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[%a b%]'), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser('[% '), ctx), [['[%', ' '], '']);
-      assert.deepStrictEqual(inspect(parser('[% \n a'), ctx), [['[%', ' ', '<br>', ' ', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('[% '), ctx), [['[%'], '']);
+      assert.deepStrictEqual(inspect(parser('[% \n a'), ctx), [['[%', '<br>', ' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[%%]'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('[% [%'), ctx), [['[%', ' ', '[', '%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% [% '), ctx), [['[%', ' ', '[%', ' '], '']);
+      assert.deepStrictEqual(inspect(parser('[% [% '), ctx), [['[%', ' ', '[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% a'), ctx), [['[%', ' ', '[%', ' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('[% [% a %]'), ctx), [['[%', ' ', '<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a[%'), ctx), [['[%', ' ', 'a', '[', '%'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [%'), ctx), [['[%', ' ', 'a', ' ', '[', '%'], '']);
-      assert.deepStrictEqual(inspect(parser('[% a [% '), ctx), [['[%', ' ', 'a', ' ', '[%', ' '], '']);
+      assert.deepStrictEqual(inspect(parser('[% a [% '), ctx), [['[%', ' ', 'a', ' ', '[%'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [% b'), ctx), [['[%', ' ', 'a', ' ', '[%', ' ', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('[% a [%% b'), ctx), [['[%', ' ', 'a', ' ', '[%%', ' ', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('[%% a [% b'), ctx), [['[%%', ' ', 'a', ' ', '[%', ' ', 'b'], '']);
@@ -40,10 +40,10 @@ describe('Unit: parser/inline/remark', () => {
 
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('[% %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%  %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[%  %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%   %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[%   %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[%  %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[%   %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
-      assert.deepStrictEqual(inspect(parser('[%  a  %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[%  a  %]</span></span>'], '']);
+      assert.deepStrictEqual(inspect(parser('[%  a  %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a b %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a b %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a\nb %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a<br>b %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('[% a %] %]'), ctx), [['<span class="remark"><input type="checkbox"><span>[% a %]</span></span>'], ' %]']);

package/src/parser/inline/remark.ts

@@ -8,13 +8,13 @@ import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
 export const remark: RemarkParser = lazy(() => match(
-  /^\[(%+)\s/,
+  /\[(%+)\s/y,
   memoize(
   ([, fence]) =>
     surround(
       str(`[${fence}`),
       precedence(4, recursion(Recursion.inline,
-      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}\]`, 'y'), [[new RegExp(String.raw`\s+${fence}\]`, 'y'), 4]]))),
       close(some(text, '%'), str(`${fence}]`)), true,
       ([as, bs = [], cs]) => [[
         html('span', { class: 'remark' }, [

package/src/parser/inline/ruby.ts

@@ -67,8 +67,9 @@ const text: RubyParser.TextParser = input => {
   const { source } = context;
   const acc = [''];
   let state = false;
+  context.sequential = true;
   for (let { position } = context; position < source.length; position = context.position) {
-    if (!/^(?:\\[^\n]|[^\\[\](){}<>"`$#:^|\n])/.test(source.slice(position, position + 2))) break;
+    if (!/(?:\\[^\n]|[^\\[\](){}<>"`$#:^|\n])/y.test(source.slice(position, position + 2))) break;
     assert(source[position] !== '\n');
     switch (source[position]) {
       case '&': {
@@ -91,6 +92,7 @@ const text: RubyParser.TextParser = input => {
       }
     }
   }
+  context.sequential = false;
   state ||= acc.at(-1)!.trimStart() !== '';
   return state
     ? [acc]

package/src/parser/inline/shortmedia.ts

@@ -3,7 +3,6 @@ import { State } from '../context';
 import { union, constraint, focus, rewrite, open, convert } from '../../combinator';
 import { url } from './autolink/url';
 import { media } from './media';
-import { linebreak } from '../source';
 
 export const shortmedia: ShortMediaParser = constraint(State.media, rewrite(
   open('!', url),
@@ -12,11 +11,9 @@ export const shortmedia: ShortMediaParser = constraint(State.media, rewrite(
     union([media]),
     false)));
 
-export const lineshortmedia: ShortMediaParser.LineShortMediaParser = open(
-  linebreak,
-  focus(
-    /^!https?:\/\/\S+(?=[^\S\n]*(?:$|\n))/,
-    convert(
-      source => `!{ ${source.slice(1)} }`,
-      union([media]),
-      false)));
+export const lineshortmedia: ShortMediaParser.LineShortMediaParser = focus(
+  /(?<=^|[\r\n])!?https?:\/\/\S+(?=[^\S\n]*(?:$|\n))/y,
+  convert(
+    source => `!{ ${source.slice(1)} }`,
+    union([media]),
+    false));

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

@@ -11,11 +11,11 @@ describe('Unit: parser/inline/strong', () => {
     it('invalid', () => {
       assert.deepStrictEqual(inspect(parser('**'), ctx), undefined);
       assert.deepStrictEqual(inspect(parser('**a'), ctx), [['**', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('**a **'), ctx), [['**', 'a'], ' **']);
-      assert.deepStrictEqual(inspect(parser('**a  **'), ctx), [['**', 'a', ' '], ' **']);
-      assert.deepStrictEqual(inspect(parser('**a\n**'), ctx), [['**', 'a'], '\n**']);
-      assert.deepStrictEqual(inspect(parser('**a\\ **'), ctx), [['**', 'a'], '\\ **']);
-      assert.deepStrictEqual(inspect(parser('**a\\\n**'), ctx), [['**', 'a'], '\\\n**']);
+      assert.deepStrictEqual(inspect(parser('**a **'), ctx), [['**', 'a', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser('**a  **'), ctx), [['**', 'a', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser('**a\n**'), ctx), [['**', 'a', '<br>', '**'], '']);
+      assert.deepStrictEqual(inspect(parser('**a\\ **'), ctx), [['**', 'a', ' ', '**'], '']);
+      assert.deepStrictEqual(inspect(parser('**a\\\n**'), ctx), [['**', 'a', '<br>', '**'], '']);
       assert.deepStrictEqual(inspect(parser('**a*'), ctx), [['**', 'a'], '*']);
       assert.deepStrictEqual(inspect(parser('**a*b**'), ctx), [['**', 'a', '<em>b</em>'], '*']);
       assert.deepStrictEqual(inspect(parser('** **'), ctx), undefined);

package/src/parser/inline/strong.ts

@@ -2,7 +2,6 @@ import { StrongParser } from '../inline';
 import { Recursion } from '../context';
 import { union, some, recursion, precedence, surround, open, lazy } from '../../combinator';
 import { inline } from '../inline';
-import { emstrong } from './emstrong';
 import { emphasis } from './emphasis';
 import { str } from '../source';
 import { tightStart, blankWith } from '../visibility';
@@ -10,16 +9,12 @@ import { unshift } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
 export const strong: StrongParser = lazy(() => surround(
-  str('**', '*'),
+  str(/\*\*(?!\*)/y),
   precedence(0, recursion(Recursion.inline,
   tightStart(some(union([
     emphasis,
     some(inline, blankWith('*')),
-    open(some(inline, '*'), union([
-      emstrong,
-      strong,
-      emphasis,
-    ])),
+    open(some(inline, '*'), inline),
   ]))))),
   str('**'), false,
   ([, bs]) => [[html('strong', defrag(bs))]],

package/src/parser/inline.test.ts

@@ -80,7 +80,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*a((b))*'), ctx), [['<em>a<sup class="annotation"><span>b</span></sup></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*++ ++*'), ctx), [['<em><ins> </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*++ a ++*'), ctx), [['<em><ins> a </ins></em>'], '']);
-      assert.deepStrictEqual(inspect(parser('*++  a  ++*'), ctx), [['<em><ins>  a  </ins></em>'], '']);
+      assert.deepStrictEqual(inspect(parser('*++  a  ++*'), ctx), [['<em><ins> a </ins></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*<bdi>`a`</bdi>*'), ctx), [['<em><bdi><code data-src="`a`">a</code></bdi></em>'], '']);
       assert.deepStrictEqual(inspect(parser('*a"\nb*'), ctx), [['*', 'a', '"', '<br>', 'b', '*'], '']);
       assert.deepStrictEqual(inspect(parser('*a"\n"("b*'), ctx), [['<em>a"<br>"("b</em>'], '']);
@@ -166,7 +166,7 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('"[% "*"* %]'), ctx), [['"', '<span class="remark"><input type="checkbox"><span>[% "*"* %]</span></span>'], '']);
       assert.deepStrictEqual(inspect(parser('"{{""}}'), ctx), [['"', '{', '{', '"', '"', '}', '}'], '']);
       assert.deepStrictEqual(inspect(parser('[#http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::http://host/(&lt;bdi&gt;)">http://host/(&lt;bdi&gt;)</a>', '<', '/', 'bdi', '>'], '']);
-      assert.deepStrictEqual(inspect(parser('[#@a/http://host/(<bdi>)]</bdi>'), ctx), [[ '[', '#@a/http', ':', '/', '/', 'host', '/', '(', '<bdi>)]</bdi>' ], '']);
+      assert.deepStrictEqual(inspect(parser('[#@a/http://host/(<bdi>)]</bdi>'), ctx), [['<a class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/(&lt;bdi&gt;)</a>', '<', '/', 'bdi', '>'], '']);
       assert.deepStrictEqual(inspect(parser('[#a|<bdi>]</bdi>'), ctx), [['[', '<a class="hashtag" href="/hashtags/a">#a</a>', '|', '<bdi>]</bdi>'], '']);
       assert.deepStrictEqual(inspect(parser('[[#a|<bdi>]</bdi>'), ctx), [['[', '[', '<a class="hashtag" href="/hashtags/a">#a</a>', '|', '<bdi>]</bdi>'], '']);
     });
@@ -209,6 +209,7 @@ describe('Unit: parser/inline', () => {
 
     it('account', () => {
       assert.deepStrictEqual(inspect(parser('@a'), ctx), [['<a class="account" href="/@a">@a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('@http://host'), ctx), [['@http', ':', '/', '/', 'host'], '']);
       assert.deepStrictEqual(inspect(parser('_@a'), ctx), [['_', '<a class="account" href="/@a">@a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_@a_'), ctx), [['_', '<a class="account" href="/@a">@a</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser('*@a*'), ctx), [['<em><a class="account" href="/@a">@a</a></em>'], '']);
@@ -217,21 +218,22 @@ describe('Unit: parser/inline', () => {
     });
 
     it('hashtag', () => {
-      assert.deepStrictEqual(inspect(parser('#a#'), ctx), [['#a#'], '']);
-      assert.deepStrictEqual(inspect(parser('#a#b'), ctx), [['#a#b'], '']);
+      assert.deepStrictEqual(inspect(parser('#a#'), ctx), [['#a', '#'], '']);
+      assert.deepStrictEqual(inspect(parser('#a#b'), ctx), [['#a', '#', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('#a'), ctx), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('#http://host'), ctx), [['#http', ':', '/', '/', 'host'], '']);
       assert.deepStrictEqual(inspect(parser('#a\nb\n#c\n[#d]'), ctx), [['<a class="hashtag" href="/hashtags/a">#a</a>', '<br>', 'b', '<br>', '<a class="hashtag" href="/hashtags/c">#c</a>', '<br>', '<a class="index" href="#index::d">d</a>'], '']);
       assert.deepStrictEqual(inspect(parser('##a'), ctx), [['##a'], '']);
       assert.deepStrictEqual(inspect(parser('_#a'), ctx), [['_', '<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_#a_'), ctx), [['_', '<a class="hashtag" href="/hashtags/a">#a</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser('_#a_b'), ctx), [['_', '<a class="hashtag" href="/hashtags/a_b">#a_b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_#a_b_'), ctx), [['_', '<a class="hashtag" href="/hashtags/a_b">#a_b</a>', '_'], '']);
-      assert.deepStrictEqual(inspect(parser('a#b'), ctx), [['a#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0a#b'), ctx), [['0a#b'], '']);
-      assert.deepStrictEqual(inspect(parser('あ#b'), ctx), [['あ#b'], '']);
-      assert.deepStrictEqual(inspect(parser('あい#b'), ctx), [['あ', 'い#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあ#b'), ctx), [['0aあ#b'], '']);
-      assert.deepStrictEqual(inspect(parser('0aあい#b'), ctx), [['0a', 'あ', 'い#b'], '']);
+      assert.deepStrictEqual(inspect(parser('a#b'), ctx), [['a', '#', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('0a#b'), ctx), [['0a', '#', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('あ#b'), ctx), [['あ', '#', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('あい#b'), ctx), [['あい', '#', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('0aあ#b'), ctx), [['0a', 'あ', '#', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('0aあい#b'), ctx), [['0a', 'あい', '#', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('「#あ」'), ctx), [['「', '<a class="hashtag" href="/hashtags/あ">#あ</a>', '」'], '']);
       assert.deepStrictEqual(inspect(parser('a\n#b'), ctx), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\n#b'), ctx), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
@@ -245,7 +247,7 @@ describe('Unit: parser/inline', () => {
     it('hashnum', () => {
       assert.deepStrictEqual(inspect(parser('#1'), ctx), [['<a class="hashnum">#1</a>'], '']);
       assert.deepStrictEqual(inspect(parser(`#1'`), ctx), [[`<a class="hashnum">#1</a>`, `'`], '']);
-      assert.deepStrictEqual(inspect(parser('#1234567890@a'), ctx), [['#1234567890@a'], '']);
+      assert.deepStrictEqual(inspect(parser('#1234567890@a'), ctx), [['#1234567890', '@', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('_#1'), ctx), [['_', '<a class="hashnum">#1</a>'], '']);
       assert.deepStrictEqual(inspect(parser('_#1_'), ctx), [['_', '<a class="hashnum">#1</a>', '_'], '']);
       assert.deepStrictEqual(inspect(parser('_#1_0'), ctx), [['_', '<a class="hashtag" href="/hashtags/1_0">#1_0</a>'], '']);

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

@@ -14,17 +14,17 @@ describe('Unit: parser/source/escsource', () => {
 
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('ab'), ctx), [['a', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['0', '9', 'あ', 'い', 'A', 'Z', 'a', 'z'], '']);
+      assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09', 'あい', 'AZaz'], '']);
     });
 
     it('space', () => {
       assert.deepStrictEqual(inspect(parser(' '), ctx), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('  '), ctx), [[' ', ' '], '']);
-      assert.deepStrictEqual(inspect(parser('   '), ctx), [[' ', ' ', ' '], '']);
+      assert.deepStrictEqual(inspect(parser('  '), ctx), [['  '], '']);
+      assert.deepStrictEqual(inspect(parser('   '), ctx), [['   '], '']);
       assert.deepStrictEqual(inspect(parser(' \n'), ctx), [[' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n'), ctx), [[' ', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('   \n'), ctx), [[' ', ' ', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('  \n'), ctx), [['  ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('   \n'), ctx), [['   ', '<br>'], '']);
     });
 
     it('linebreak', () => {

package/src/parser/source/escapable.ts

@@ -1,14 +1,16 @@
 import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
+import { nonWhitespace, nonAlphanumeric, ASCII, isBlank, isAlphanumeric, isASCII } from './text';
 import { html } from 'typed-dom/dom';
 
 export const escsource: EscapableSourceParser = ({ context }) => {
   const { source, position } = context;
   if (position === source.length) return;
+  const char = source[position];
   consume(1, context);
   context.position += 1;
-  switch (source[position]) {
+  switch (char) {
     case '\r':
       assert(!source.includes('\r', position + 1));
       consume(-1, context);
@@ -20,9 +22,9 @@ export const escsource: EscapableSourceParser = ({ context }) => {
     case '\\':
       switch (source[position + 1]) {
         case undefined:
-          return [[source[position]]];
+          return [[char]];
         case '\n':
-          return [[source[position]]];
+          return [[char]];
         default:
           consume(1, context);
           context.position += 1;
@@ -32,7 +34,29 @@ export const escsource: EscapableSourceParser = ({ context }) => {
       context.linebreak ||= source.length - position;
       return [[html('br')]];
     default:
-      assert(source[position] !== '\n');
-      return [[source[position]]];
+      assert(char !== '\n');
+      if (context.sequential) return [[char]];
+      nonAlphanumeric.lastIndex = position + 1;
+      nonWhitespace.lastIndex = position + 1;
+      ASCII.lastIndex = position + 1;
+      const b = isBlank(source, position);
+      let i = b
+        ? nonWhitespace.test(source)
+          ? nonWhitespace.lastIndex - 1
+          : source.length
+        : isAlphanumeric(char)
+          ? nonAlphanumeric.test(source)
+            ? nonAlphanumeric.lastIndex - 1
+            : source.length
+          : !isASCII(char)
+            ? ASCII.test(source)
+              ? ASCII.lastIndex - 1
+              : source.length
+            : position + 1;
+      assert(i > position);
+      i -= position;
+      consume(i - 1, context);
+      context.position += i - 1;
+      return [[source.slice(position, context.position)]];
   }
 };

package/src/parser/source/line.ts

@@ -1,6 +1,30 @@
 import { AnyLineParser, EmptyLineParser, ContentLineParser } from '../source';
-import { line, isBlank } from '../../combinator';
 
-export const anyline: AnyLineParser = line(() => [[]]);
-export const emptyline: EmptyLineParser = line(({ context: { source } }) => isBlank(source) ? [[]] : undefined);
-export const contentline: ContentLineParser = line(({ context: { source } }) => !isBlank(source) ? [[]] : undefined);
+export const anyline: AnyLineParser = input => {
+  const { context } = input;
+  const { source, position } = context;
+  context.position = source.indexOf('\n', position) + 1 || source.length;
+  return [[]];
+};
+const regEmptyline = /[^\S\n]*(?:$|\n)/y;
+export const emptyline: EmptyLineParser = input => {
+  const { context } = input;
+  const { source, position } = context;
+  regEmptyline.lastIndex = position;
+  regEmptyline.test(source);
+  const i = regEmptyline.lastIndex;
+  if (i === 0) return;
+  context.position = i;
+  return [[]];
+};
+const regContentline = /[^\S\n]*\S[^\n]*(?:$|\n)/y;
+export const contentline: ContentLineParser = input => {
+  const { context } = input;
+  const { source, position } = context;
+  regContentline.lastIndex = position;
+  regContentline.test(source);
+  const i = regContentline.lastIndex;
+  if (i === 0) return;
+  context.position = i;
+  return [[]];
+}

package/src/parser/source/str.ts

@@ -1,32 +1,10 @@
 import { StrParser } from '../source';
-import { Parser, Context } from '../../combinator/data/parser';
-import { consume } from '../../combinator';
+import { Parser } from '../../combinator/data/parser';
+import { matcher } from '../../combinator';
 
-export function str(pattern: string | RegExp, not?: string): StrParser;
-export function str(pattern: string | RegExp, not?: string): Parser<string, Context<StrParser>, []> {
-  assert(pattern);
-  const count = typeof pattern === 'object'
-    ? /[^^\\*+][*+]/.test(pattern.source)
-    : false;
-  return typeof pattern === 'string'
-    ? ({ context }) => {
-        const { source, position } = context;
-        if (position === source.length) return;
-        if (!source.startsWith(pattern, position)) return;
-        if (not && source.startsWith(not, position + pattern.length)) return;
-        context.position += pattern.length;
-        return [[pattern]];
-      }
-    : ({ context }) => {
-        const { source, position } = context;
-        if (position === source.length) return;
-        const m = source.slice(position).match(pattern);
-        if (m === null) return;
-        count && consume(m[0].length, context);
-        if (not && source.slice(position + m[0].length, position + m[0].length + not.length) === not) return;
-        context.position += m[0].length;
-        return [[m[0]]];
-      };
+export function str(pattern: string | RegExp): StrParser;
+export function str(pattern: string | RegExp): Parser<string> {
+  return matcher(pattern, true);
 }
 
 export function strs(pattern: string): StrParser;

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

@@ -14,8 +14,8 @@ describe('Unit: parser/source/text', () => {
 
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('ab'), ctx), [['a', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['0', '9', 'あ', 'い', 'A', 'Z', 'a', 'z'], '']);
+      assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
+      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09', 'あい', 'AZaz'], '']);
       assert.deepStrictEqual(inspect(parser('a\nb'), ctx), [['a', '<br>', 'b'], '']);
     });
 
@@ -34,41 +34,41 @@ describe('Unit: parser/source/text', () => {
     });
 
     it('space', () => {
-      assert.deepStrictEqual(inspect(parser(' '), ctx), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('  '), ctx), [[' ', ' '], '']);
-      assert.deepStrictEqual(inspect(parser('   '), ctx), [[' ', ' ', ' '], '']);
-      assert.deepStrictEqual(inspect(parser(' \n'), ctx), [[' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n'), ctx), [[' ', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \\\n'), ctx), [[' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \\\n'), ctx), [[' ', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser(' '), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser('  '), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser('   '), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser(' \n'), ctx), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('  \n'), ctx), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser(' \\\n'), ctx), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('  \\\n'), ctx), [['<br>'], '']);
       assert.deepStrictEqual(inspect(parser(' a'), ctx), [[' ', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('  a'), ctx), [[' ', ' ', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('   a'), ctx), [[' ', ' ', ' ', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('a '), ctx), [['a', ' '], '']);
-      assert.deepStrictEqual(inspect(parser('a  '), ctx), [['a', ' ', ' '], '']);
-      assert.deepStrictEqual(inspect(parser('a \n'), ctx), [['a', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a  \n'), ctx), [['a', ' ', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a \\\n'), ctx), [['a', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a  \\\n'), ctx), [['a', ' ', ' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('   a'), ctx), [['  ', ' ', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('a '), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser('a  '), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser('a \n'), ctx), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('a  \n'), ctx), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('a \\\n'), ctx), [['a', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('a  \\\n'), ctx), [['a', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('a b'), ctx), [['a', ' ', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('a  b'), ctx), [['a', ' ', ' ', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('a   b'), ctx), [['a', ' ', ' ', ' ', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('a  b'), ctx), [['a', ' ', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser('a   b'), ctx), [['a', ' ', 'b'], '']);
     });
 
     it('hardbreak', () => {
       assert.deepStrictEqual(inspect(parser('\n'), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n '), ctx), [['<br>', ' '], '']);
-      assert.deepStrictEqual(inspect(parser(' \n'), ctx), [[' ', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\n '), ctx), [['<br>'], '']);
+      assert.deepStrictEqual(inspect(parser(' \n'), ctx), [['<br>'], '']);
       assert.deepStrictEqual(inspect(parser('\n\n'), ctx), [['<br>', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \n\n'), ctx), [[' ', '<br>', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n \n'), ctx), [['<br>', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n\n '), ctx), [['<br>', '<br>', ' '], '']);
+      assert.deepStrictEqual(inspect(parser(' \n\n'), ctx), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\n \n'), ctx), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\n\n '), ctx), [['<br>', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('。\n'), ctx), [['。', '<br>'], '']);
     });
 
     it('softbreak', () => {
       assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n '), ctx), [['<br>', ' '], '']);
+      assert.deepStrictEqual(inspect(parser('\\\n '), ctx), [['<br>'], '']);
       assert.deepStrictEqual(inspect(parser('\\\na'), ctx), [['<br>', 'a'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\n'), ctx), [['a', '<br>'], '']);
       assert.deepStrictEqual(inspect(parser('a\\\nb\\\n'), ctx), [['a', '<br>', 'b', '<br>'], '']);
@@ -84,7 +84,7 @@ describe('Unit: parser/source/text', () => {
       assert.deepStrictEqual(inspect(parser('0@0'), ctx), [['0', '@', '0'], '']);
       assert.deepStrictEqual(inspect(parser('a@0'), ctx), [['a', '@', '0'], '']);
       assert.deepStrictEqual(inspect(parser('A@0'), ctx), [['A', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('aA@0'), ctx), [['a', 'A', '@', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('aA@0'), ctx), [['aA', '@', '0'], '']);
       assert.deepStrictEqual(inspect(parser(' @0'), ctx), [[' ', '@', '0'], '']);
       assert.deepStrictEqual(inspect(parser('@@0'), ctx), [['@', '@', '0'], '']);
     });
@@ -98,7 +98,7 @@ describe('Unit: parser/source/text', () => {
       assert.deepStrictEqual(inspect(parser('0#0'), ctx), [['0', '#', '0'], '']);
       assert.deepStrictEqual(inspect(parser('a#0'), ctx), [['a', '#', '0'], '']);
       assert.deepStrictEqual(inspect(parser('A#0'), ctx), [['A', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('aA#0'), ctx), [['a', 'A', '#', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('aA#0'), ctx), [['aA', '#', '0'], '']);
       assert.deepStrictEqual(inspect(parser(' #0'), ctx), [[' ', '#', '0'], '']);
       assert.deepStrictEqual(inspect(parser('##0'), ctx), [['#', '#', '0'], '']);
     });
@@ -112,7 +112,7 @@ describe('Unit: parser/source/text', () => {
       assert.deepStrictEqual(inspect(parser('0>>0'), ctx), [['0', '>', '>', '0'], '']);
       assert.deepStrictEqual(inspect(parser('a>>0'), ctx), [['a', '>', '>', '0'], '']);
       assert.deepStrictEqual(inspect(parser('A>>0'), ctx), [['A', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('aA>>0'), ctx), [['a', 'A', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('aA>>0'), ctx), [['aA', '>', '>', '0'], '']);
       assert.deepStrictEqual(inspect(parser(' >>0'), ctx), [[' ', '>', '>', '0'], '']);
       assert.deepStrictEqual(inspect(parser('>>>>0'), ctx), [['>', '>', '>', '>', '0'], '']);
     });