securemark 0.293.0 → 0.293.2

package/src/parser/inline/remark.ts

@@ -1,26 +1,24 @@
 import { RemarkParser } from '../inline';
 import { Recursion } from '../context';
-import { union, some, recursion, precedence, surround, close, match, lazy } from '../../combinator';
+import { union, some, recursion, precedence, focus, surround, close, fallback, lazy } from '../../combinator';
 import { inline } from '../inline';
 import { text, str } from '../source';
-import { memoize } from 'spica/memoize';
+import { invalid } from '../util';
 import { unshift, push } from 'spica/array';
 import { html, defrag } from 'typed-dom/dom';
 
-export const remark: RemarkParser = lazy(() => match(
-  /\[(%+)\s/y,
-  memoize(
-  ([, fence]) =>
-    surround(
-      str(`[${fence}`),
-      precedence(4, recursion(Recursion.inline,
-      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' }, [
-          html('input', { type: 'checkbox' }),
-          html('span', defrag(push(unshift(as, bs), cs))),
-        ]),
-      ]],
-      ([as, bs]) => bs && [unshift(as, bs)]),
-  ([, fence]) => fence.length, {})));
+export const remark: RemarkParser = lazy(() => fallback(surround(
+  str(/\[%(?=\s)/y),
+  precedence(4, recursion(Recursion.inline,
+  some(union([inline]), /\s%\]/y, [[/\s%\]/y, 4]]))),
+  close(text, str(`%]`)), true,
+  ([as, bs = [], cs]) => [[
+    html('span', { class: 'remark' }, [
+      html('input', { type: 'checkbox' }),
+      html('span', defrag(push(unshift(as, bs), cs))),
+    ]),
+  ]],
+  ([as, bs]) => bs && [unshift(as, bs)]),
+  focus(/\[%+(?=\s)/y, ({ context: { source } }) => [[
+    html('span', { class: 'invalid', ...invalid('remark', 'syntax', 'Invalid start symbol') }, source)
+  ]])));

package/src/parser/inline/ruby.ts

@@ -18,11 +18,11 @@ export const ruby: RubyParser = lazy(() => bind(
         return isTightNodeStart(ns) ? [ns] : undefined;
       },
       undefined,
-      [3 | Backtrack.ruby, 1 | Backtrack.bracket])),
+      [1 | Backtrack.bracket, 3 | Backtrack.ruby])),
     dup(surround(
       '(', text, ')',
       false, undefined, undefined,
-      [3 | Backtrack.ruby, 1 | Backtrack.bracket])),
+      [1 | Backtrack.bracket, 3 | Backtrack.ruby])),
   ]),
   ([texts, rubies], context) => {
     if (rubies === undefined) {
@@ -69,7 +69,7 @@ const text: RubyParser.TextParser = input => {
   let state = false;
   context.sequential = true;
   for (let { position } = context; position < source.length; position = context.position) {
-    if (!/(?:\\[^\n]|[^\\[\](){}<>"`$#:^|\n])/y.test(source.slice(position, position + 2))) break;
+    if (/[$"`\[\](){}<>（）［］｛｝]|\\?\n/yi.test(source.slice(position, position + 2))) break;
     assert(source[position] !== '\n');
     switch (source[position]) {
       case '&': {

package/src/parser/inline/shortmedia.ts

@@ -12,7 +12,7 @@ export const shortmedia: ShortMediaParser = constraint(State.media, rewrite(
     false)));
 
 export const lineshortmedia: ShortMediaParser.LineShortMediaParser = focus(
-  /(?<=^|[\r\n])!?https?:\/\/\S+(?=[^\S\n]*(?:$|\n))/y,
+  /(?<=^|[\r\n])!https?:\/\/\S+(?=[^\S\n]*(?:$|\n))/y,
   convert(
     source => `!{ ${source.slice(1)} }`,
     union([media]),

package/src/parser/inline.test.ts

@@ -22,10 +22,10 @@ describe('Unit: parser/inline', () => {
     it('nest', () => {
       assert.deepStrictEqual(inspect(parser('あ（Ａ）'), ctx), [['あ', '（', 'Ａ', '）'], '']);
       assert.deepStrictEqual(inspect(parser('あ（い）'), ctx), [['あ', '<span class="paren">（い）</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*'), 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), [['<em>a</em>', '*'], '']);
       assert.deepStrictEqual(inspect(parser('*a**b'), ctx), [['*', 'a', '**', 'b'], '']);
       assert.deepStrictEqual(inspect(parser('*a**b*'), ctx), [['<em>a**b</em>'], '']);
@@ -98,11 +98,11 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('++\na\n++\n~~\nb\n~~\nc'), ctx), [['<ins><br>a</ins>', '<br>', '<del><br>b</del>', '<br>', 'c'], '']);
       assert.deepStrictEqual(inspect(parser('[@a]'), ctx), [['[', '<a class="account" href="/@a">@a</a>', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[#1][#2]'), ctx), [['<a class="index" href="#index::1">1</a>', '<a class="index" href="#index::2">2</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('[$1]'), ctx), [['[', '$', '1', ']'], '']);
-      assert.deepStrictEqual(inspect(parser('[$1-2]'), ctx), [['[', '$', '1-2', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[$1]'), ctx), [['[', '$1', ']'], '']);
+      assert.deepStrictEqual(inspect(parser('[$1-2]'), ctx), [['[', '$1-2', ']'], '']);
       assert.deepStrictEqual(inspect(parser('[$-1][$-2]'), ctx), [['<a class="label" data-label="$-1">$-1</a>', '<a class="label" data-label="$-2">$-2</a>'], '']);
       assert.deepStrictEqual(inspect(parser('$-1, $-2'), ctx), [['<a class="label" data-label="$-1">$-1</a>', ',', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('$-1 and $-2'), ctx), [['<a class="label" data-label="$-1">$-1</a>', ' ', 'and', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
+      assert.deepStrictEqual(inspect(parser('$-1 and $-2'), ctx), [['<a class="label" data-label="$-1">$-1</a>', ' and', ' ', '<a class="label" data-label="$-2">$-2</a>'], '']);
       assert.deepStrictEqual(inspect(parser('$$-1'), ctx), [['$', '<a class="label" data-label="$-1">$-1</a>'], '']);
       assert.deepStrictEqual(inspect(parser('[[#a]]'), ctx), [['<sup class="reference"><span><a class="hashtag" href="/hashtags/a">#a</a></span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('[[$-1]]'), ctx), [['<sup class="reference"><span><a class="label" data-label="$-1">$-1</a></span></sup>'], '']);
@@ -129,8 +129,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('${a}'), ctx), [['$', '<a class="url" href="a">a</a>'], '']);
       assert.deepStrictEqual(inspect(parser('${{a}}'), ctx), [['$', '<span class="template">{{a}}</span>'], '']);
       assert.deepStrictEqual(inspect(parser('${{{a}}}'), ctx), [['$', '<span class="template">{{{a}}}</span>'], '']);
-      assert.deepStrictEqual(inspect(parser('Di$ney Micro$oft'), ctx), [['Di', '$', 'ney', ' ', 'Micro', '$', 'oft'], '']);
-      assert.deepStrictEqual(inspect(parser('Di$ney, Micro$oft'), ctx), [['Di', '$', 'ney', ',', ' ', 'Micro', '$', 'oft'], '']);
+      assert.deepStrictEqual(inspect(parser('Di$ney Micro$oft'), ctx), [['Di', '$ney Micro', '$oft'], '']);
+      assert.deepStrictEqual(inspect(parser('Di$ney, Micro$oft'), ctx), [['Di', '$ney, Micro', '$oft'], '']);
       assert.deepStrictEqual(inspect(parser('(((a))'), ctx), [['(', '<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))'), ctx), [['(', '(', '<sup class="annotation"><span>a</span></sup>'], '']);
       assert.deepStrictEqual(inspect(parser('((((a))))'), ctx), [['<sup class="annotation"><span><span class="paren">((a))</span></span></sup>'], '']);
@@ -165,16 +165,16 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('"[% *"*"*'), ctx), [['"', '[%', ' ', '*', '"', '*', '"', '*'], '']);
       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 class="index" href="#index::@a/http://host/(&lt;bdi&gt;)">@a/http://host/(&lt;bdi&gt;)</a>', '<', '/', 'bdi', '>'], '']);
+      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 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>'], '']);
     });
 
     it('uri', () => {
       assert.deepStrictEqual(inspect(parser('\nhttp://host'), ctx), [['<br>', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('0http://host'), ctx), [['0http', ':', '/', '/', 'host'], '']);
-      assert.deepStrictEqual(inspect(parser('0aAhttp://host'), ctx), [['0aAhttp', ':', '/', '/', 'host'], '']);
+      assert.deepStrictEqual(inspect(parser('0http://host'), ctx), [['0http:', '//host'], '']);
+      assert.deepStrictEqual(inspect(parser('0aAhttp://host'), ctx), [['0aAhttp:', '//host'], '']);
       assert.deepStrictEqual(inspect(parser('?http://host'), ctx), [['?', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('0!http://host'), ctx), [['0', '!', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
       assert.deepStrictEqual(inspect(parser('0?http://host'), ctx), [['0', '?', '<a class="url" href="http://host" target="_blank">http://host</a>'], '']);
@@ -196,7 +196,8 @@ describe('Unit: parser/inline', () => {
       assert.deepStrictEqual(inspect(parser('*a@b*'), ctx), [['<em><a class="email" href="mailto:a@b">a@b</a></em>'], '']);
       assert.deepStrictEqual(inspect(parser('(a@b)'), ctx), [['<span class="paren">(<a class="email" href="mailto:a@b">a@b</a>)</span>'], '']);
       assert.deepStrictEqual(inspect(parser(' a@b'), ctx), [[' ', '<a class="email" href="mailto:a@b">a@b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser('++a++b@c++'), ctx), [['<ins>a</ins>', '<a class="email" href="mailto:b@c">b@c</a>', '+', '+'], '']);
+      assert.deepStrictEqual(inspect(parser('++a@b++'), ctx), [['<ins><a class="email" href="mailto:a@b">a@b</a></ins>'], '']);
+      assert.deepStrictEqual(inspect(parser('++a++b@c++'), ctx), [['<ins>a</ins>', '<a class="email" href="mailto:b@c">b@c</a>', '++'], '']);
     });
 
     it('channel', () => {
@@ -209,7 +210,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('@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>'], '']);
@@ -219,21 +220,21 @@ 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#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('#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>'], '']);
@@ -247,7 +248,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/inline.ts

@@ -55,22 +55,27 @@ export const inline: InlineParser = lazy(() => union([
     if (position === source.length) return;
     switch (source.slice(position, position + 2)) {
       case '((':
-        return annotation(input);
+        return annotation(input)
+            || bracket(input);
       case '[[':
         return reference(input)
-            || textlink(input);
+            || textlink(input)
+            || bracket(input);
       case '{{':
-        return template(input);
+        return template(input)
+            || bracket(input);
       case '[%':
         return remark(input)
-            || textlink(input);
+            || textlink(input)
+            || bracket(input);
       case '[#':
       case '[$':
       case '[:':
       case '[^':
       case '[|':
         return extension(input)
-            || textlink(input);
+            || textlink(input)
+            || bracket(input);
       case '${':
         return math(input);
       case '++':
@@ -89,9 +94,11 @@ export const inline: InlineParser = lazy(() => union([
     switch (source[position]) {
       case '[':
         return textlink(input)
-            || ruby(input);
+            || ruby(input)
+            || bracket(input);
       case '{':
-        return textlink(input);
+        return textlink(input)
+            || bracket(input);
       case '<':
         return html(input);
       case '$':
@@ -104,9 +111,14 @@ export const inline: InlineParser = lazy(() => union([
             || stars(input);
       case '&':
         return htmlentity(input);
+      case '(':
+      case '（':
+      case '［':
+      case '｛':
+      case '"':
+        return bracket(input);
     }
   },
-  bracket,
   autolink,
   text
 ])) as any;
@@ -116,4 +128,4 @@ export { indexer } from './inline/extension/indexer';
 export { dataindex } from './inline/extension/index';
 export { medialink } from './inline/link';
 export { media } from './inline/media';
-export { shortmedia } from './inline/shortmedia';
+export { shortmedia, lineshortmedia } from './inline/shortmedia';

package/src/parser/segment.ts

@@ -14,13 +14,31 @@ export const MAX_SEGMENT_SIZE = 100_000; // 100,000 bytes (Max value size of FDB
 export const MAX_INPUT_SIZE = MAX_SEGMENT_SIZE * 10;
 
 const parser: SegmentParser = union([
-  heading,
-  codeblock,
-  mathblock,
-  extension,
+  input => {
+    const { context: { source, position } } = input;
+    if (position === source.length) return;
+    switch (source.slice(position, position + 3)) {
+      case '~~~':
+        return extension(input);
+      case '```':
+        return codeblock(input);
+    }
+    switch (source.slice(position, position + 2)) {
+      case '$$':
+        return mathblock(input);
+      case '[$':
+        return extension(input);
+    }
+    switch (source[position]) {
+      case '#':
+        return heading(input);
+      case '$':
+        return extension(input);
+    }
+  },
   some(contentline, MAX_SEGMENT_SIZE + 1),
   some(emptyline, MAX_SEGMENT_SIZE + 1),
-]);
+]) as any;
 
 export function* segment(source: string): Generator<string, undefined, undefined> {
   if (!validate(source, MAX_INPUT_SIZE)) return yield `${Command.Error}Too large input over ${MAX_INPUT_SIZE.toLocaleString('en')} bytes.\n${source.slice(0, 1001)}`;

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

@@ -15,7 +15,7 @@ describe('Unit: parser/source/escsource', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09', 'あい', 'AZaz'], '']);
+      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09あいAZaz'], '']);
     });
 
     it('space', () => {

package/src/parser/source/escapable.ts

@@ -1,9 +1,11 @@
 import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
-import { nonWhitespace, nonAlphanumeric, ASCII, isBlank, isAlphanumeric, isASCII } from './text';
+import { nonWhitespace, isBlank, next } from './text';
 import { html } from 'typed-dom/dom';
 
+const delimiter = /(?=[\\$"`\[\](){}\r\n]|\s(?:\$)|:\/\/)/g;
+
 export const escsource: EscapableSourceParser = ({ context }) => {
   const { source, position } = context;
   if (position === source.length) return;
@@ -36,23 +38,13 @@ export const escsource: EscapableSourceParser = ({ context }) => {
     default:
       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;
+        : next(source, position, delimiter);
       assert(i > position);
       i -= position;
       consume(i - 1, context);

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

@@ -15,7 +15,7 @@ describe('Unit: parser/source/text', () => {
     it('basic', () => {
       assert.deepStrictEqual(inspect(parser('a'), ctx), [['a'], '']);
       assert.deepStrictEqual(inspect(parser('ab'), ctx), [['ab'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09', 'あい', 'AZaz'], '']);
+      assert.deepStrictEqual(inspect(parser('09あいAZaz'), ctx), [['09あいAZaz'], '']);
       assert.deepStrictEqual(inspect(parser('a\nb'), ctx), [['a', '<br>', 'b'], '']);
     });
 
@@ -41,18 +41,18 @@ describe('Unit: parser/source/text', () => {
       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'), 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'], '']);
+      assert.deepStrictEqual(inspect(parser('a   b'), ctx), [['a', ' b'], '']);
     });
 
     it('hardbreak', () => {
@@ -76,45 +76,45 @@ describe('Unit: parser/source/text', () => {
     });
 
     it('account', () => {
-      assert.deepStrictEqual(inspect(parser('@0'), ctx), [['@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('_@0'), ctx), [['_', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('$@0'), ctx), [['$', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('+@0'), ctx), [['+', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('-@0'), ctx), [['-', '@', '0'], '']);
-      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), [['aA', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser(' @0'), ctx), [[' ', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('@@0'), ctx), [['@', '@', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('@0'), ctx), [['@0'], '']);
+      assert.deepStrictEqual(inspect(parser('_@0'), ctx), [['_', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser('$@0'), ctx), [['$', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser('+@0'), ctx), [['+', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser('-@0'), ctx), [['-', '@0'], '']);
+      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), [['aA', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser(' @0'), ctx), [[' ', '@0'], '']);
+      assert.deepStrictEqual(inspect(parser('@@0'), ctx), [['@', '@0'], '']);
     });
 
     it('hashtag', () => {
-      assert.deepStrictEqual(inspect(parser('#0'), ctx), [['#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('_#0'), ctx), [['_', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('$#0'), ctx), [['$', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('+#0'), ctx), [['+', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('-#0'), ctx), [['-', '#', '0'], '']);
-      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), [['aA', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser(' #0'), ctx), [[' ', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('##0'), ctx), [['#', '#', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('#0'), ctx), [['#0'], '']);
+      assert.deepStrictEqual(inspect(parser('_#0'), ctx), [['_', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser('$#0'), ctx), [['$', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser('+#0'), ctx), [['+', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser('-#0'), ctx), [['-', '#0'], '']);
+      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), [['aA', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser(' #0'), ctx), [[' ', '#0'], '']);
+      assert.deepStrictEqual(inspect(parser('##0'), ctx), [['#', '#0'], '']);
     });
 
     it('anchor', () => {
-      assert.deepStrictEqual(inspect(parser('>>0'), ctx), [['>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('_>>0'), ctx), [['_', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('$>>0'), ctx), [['$', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('+>>0'), ctx), [['+', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('->>0'), ctx), [['-', '>', '>', '0'], '']);
-      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), [['aA', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser(' >>0'), ctx), [[' ', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('>>>>0'), ctx), [['>', '>', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('>>0'), ctx), [['>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser('_>>0'), ctx), [['_', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser('$>>0'), ctx), [['$', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser('+>>0'), ctx), [['+', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser('->>0'), ctx), [['-', '>', '>0'], '']);
+      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), [['aA', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser(' >>0'), ctx), [[' ', '>', '>0'], '']);
+      assert.deepStrictEqual(inspect(parser('>>>>0'), ctx), [['>', '>', '>', '>0'], '']);
     });
 
   });

package/src/parser/source/text.ts

@@ -3,10 +3,8 @@ import { Command } from '../context';
 import { union, consume, focus } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
-export const category = /(\s)|(\p{ASCII})|(.)/yu;
+export const delimiter = /(?=[\\!@#$&"`\[\](){}<>（）［］｛｝*%|\r\n]|([+~=])\1|\/{3}|\s(?:\\?(?:$|\s)|[$%])|:\/\/)/g;
 export const nonWhitespace = /[\S\r\n]/g;
-export const nonAlphanumeric = /[^0-9A-Za-z]/g;
-export const ASCII = /[\x00-\x7F（）［］｛｝]/g;
 
 export const text: TextParser = input => {
   const { context } = input;
@@ -39,23 +37,13 @@ export const text: TextParser = input => {
     default:
       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;
+        : next(source, position, delimiter);
       assert(i > position);
       const lineend = 0
         || b && i === source.length
@@ -82,24 +70,89 @@ export const linebreak: LinebreakParser = focus(/[\r\n]/y, union([
   text,
 ])) as LinebreakParser;
 
+export function next(source: string, position: number, delimiter: RegExp): number {
+  delimiter.lastIndex = position + 1;
+  delimiter.test(source);
+  let index = delimiter.lastIndex;
+  if (index === 0) return source.length;
+  assert(index > position);
+  const char = source[index];
+  switch (char) {
+    case ':':
+      index = backToUrlHead(source, position, index);
+      break;
+    case '@':
+      index = backToEmailHead(source, position, index);
+      break;
+  }
+  assert(index > position);
+  return index;
+}
+export function backToUrlHead(source: string, position: number, index: number): number {
+  const delim = index;
+  let state = false;
+  let offset = 0;
+  for (let i = index; --i > position;) {
+    index = i;
+    const char = source[i];
+    if (state) switch (char) {
+      case '.':
+      case '+':
+      case '-':
+        state = false;
+        offset = 1;
+        continue;
+    }
+    if (isAlphanumeric(char)) {
+      state = true;
+      offset = 0;
+      continue;
+    }
+    break;
+  }
+  if (index === position + 1 && offset === 0 && isAlphanumeric(source[index - 1])) {
+    return delim;
+  }
+  return index + offset;
+}
+export function backToEmailHead(source: string, position: number, index: number): number {
+  const delim = index;
+  let state = false;
+  let offset = 0;
+  for (let i = index; --i > position;) {
+    index = i;
+    const char = source[i];
+    if (state) switch (char) {
+      case '_':
+      case '.':
+      case '+':
+      case '-':
+        state = false;
+        offset = 1;
+        continue;
+    }
+    if (isAlphanumeric(char)) {
+      state = true;
+      offset = 0;
+      continue;
+    }
+    break;
+  }
+  if (index === position + 1 && offset === 0 && isAlphanumeric(source[index - 1])) {
+    return delim;
+  }
+  return index + offset;
+}
+
 const blank = /\s(?:$|\s|\\\n)/y;
 export function isBlank(source: string, position: number): boolean {
   blank.lastIndex = position;
   return blank.test(source);
 }
-
-export function isAlphanumeric(char: string): boolean {
+function isAlphanumeric(char: string): boolean {
   assert(char.length === 1);
   if (char < '0' || '\x7F' < char) return false;
   return '0' <= char && char <= '9'
       || 'a' <= char && char <= 'z'
       || 'A' <= char && char <= 'Z';
 }
-
-export function isASCII(char: string): boolean {
-  assert(char.length === 1);
-  return char <= '\x7F'
-      || char === '（' || char === '）'
-      || char === '［' || char === '］'
-      || char === '｛' || char === '｝';
-}