securemark 0.292.0 → 0.293.1

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(' 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(' '), 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 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>'], '']);
@@ -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), [['a', 'A', '@', '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), [['a', 'A', '#', '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), [['a', 'A', '>', '>', '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,13 +3,17 @@ import { Command } from '../context';
 import { union, consume, focus } from '../../combinator';
 import { html } from 'typed-dom/dom';
 
+export const delimiter = /(?=[\\!@#$&"`\[\](){}<>（）［］｛｝*%|+~=/]|\s(?:\\?(?:$|\s)|[$*%|]|([+~=])\1)|\/{3}|:\/\/|\n)/g;
+export const nonWhitespace = /[\S\r\n]/g;
+
 export const text: TextParser = input => {
   const { context } = input;
   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,19 +24,41 @@ export const text: TextParser = input => {
         case undefined:
           return [[]];
         case '\n':
-          assert(source[0] !== Command.Escape);
+          assert(char !== Command.Escape);
           return [[]];
         default:
           consume(1, context);
           context.position += 1;
-          return [[source.slice(position + 1, position + 2)]];
+          return [[source.slice(position + 1, context.position)]];
       }
     case '\n':
       context.linebreak ||= source.length - position;
       return [[html('br')]];
     default:
-      assert(source[position] !== '\n');
-      return [[source[position]]];
+      assert(char !== '\n');
+      if (context.sequential) return [[char]];
+      nonWhitespace.lastIndex = position + 1;
+      const b = isBlank(source, position);
+      let i = b
+        ? nonWhitespace.test(source)
+          ? nonWhitespace.lastIndex - 1
+          : source.length
+        : next(source, position, delimiter);
+      assert(i > position);
+      const lineend = 0
+        || b && i === source.length
+        || b && source[i] === '\n'
+        || b && source[i] === '\\' && source[i + 1] === '\n';
+      i -= position;
+      i = lineend ? i : i - +b || 1;
+      consume(i - 1, context);
+      context.position += i - 1;
+      const linestart = position === 0 || source[position - 1] === '\n';
+      i = linestart && b && i >= 3 ? i - 3 : 0;
+      i += position;
+      return i === context.position || b && !linestart || lineend
+        ? [[]]
+        : [[source.slice(i, context.position)]];
   }
 };
 
@@ -40,10 +66,99 @@ export const txt: TxtParser = union([
   text,
 ]) as TxtParser;
 
-export const linebreak: LinebreakParser = focus(/^[\r\n]/, union([
+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;
+  }
+  if (index > position + 1) switch (char) {
+    case '*':
+    case '+':
+    case '~':
+    case '=':
+    case '/':
+    case '%':
+    case '|':
+      index -= /\s/.test(source[index - 1]) ? 1 : 0;
+  }
+  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 {
   assert(char.length === 1);
   if (char < '0' || '\x7F' < char) return false;

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

@@ -14,17 +14,17 @@ describe('Unit: parser/source/unescapable', () => {
 
     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', () => {
@@ -37,8 +37,8 @@ describe('Unit: parser/source/unescapable', () => {
       assert.deepStrictEqual(inspect(parser('\\\\\\'), ctx), [['\\', '\\', '\\'], '']);
       assert.deepStrictEqual(inspect(parser('\\ '), ctx), [['\\', ' '], '']);
       assert.deepStrictEqual(inspect(parser('\\_'), ctx), [['\\', '_'], '']);
-      assert.deepStrictEqual(inspect(parser('\\0'), ctx), [['\\', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('\\a'), ctx), [['\\', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('\\0'), ctx), [['\\0'], '']);
+      assert.deepStrictEqual(inspect(parser('\\a'), ctx), [['\\a'], '']);
       assert.deepStrictEqual(inspect(parser('\\`'), ctx), [['\\', '`'], '']);
       assert.deepStrictEqual(inspect(parser('\\　'), ctx), [['\\', '　'], '']);
       assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [['\\', '<br>'], '']);

package/src/parser/source/unescapable.ts

@@ -1,14 +1,18 @@
 import { UnescapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
+import { nonWhitespace, isBlank, next } from './text';
 import { html } from 'typed-dom/dom';
 
+export const delimiter = /(?=(?=[\x00-\x7F])[^0-9A-Za-z]|(?<=[\x00-\x7F])[^\x00-\x7F])/g;
+
 export const unescsource: UnescapableSourceParser = ({ 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);
@@ -21,7 +25,19 @@ export const unescsource: UnescapableSourceParser = ({ 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]];
+      nonWhitespace.lastIndex = position + 1;
+      const b = isBlank(source, position);
+      let i = b
+        ? nonWhitespace.test(source)
+          ? nonWhitespace.lastIndex - 1
+          : source.length
+        : next(source, position, delimiter);
+      assert(i > position);
+      i -= position;
+      consume(i - 1, context);
+      context.position += i - 1;
+      return [[source.slice(position, context.position)]];
   }
 };

package/src/parser/util.ts

@@ -5,10 +5,10 @@ import { Parser, Result, Ctx, Node, Context, eval, failsafe } from '../combinato
 import { convert } from '../combinator';
 import { define } from 'typed-dom/dom';
 
-export function lineable<P extends Parser<HTMLElement | string>>(parser: P, trim?: 0 | 1 | -1): P;
-export function lineable<N extends HTMLElement | string>(parser: Parser<N>, trim = -1): Parser<N> {
+export function linearize<P extends Parser<HTMLElement | string>>(parser: P, trim?: 0 | 1 | -1): P;
+export function linearize<N extends HTMLElement | string>(parser: Parser<N>, trim = 0): Parser<N> {
   return convert(
-    source => `\r${
+    source => `${
       trim === 0
         ? source
         : trim > 0

package/src/parser/visibility.ts

@@ -1,56 +1,53 @@
 import { MarkdownParser } from '../../markdown';
 import { Command } from './context';
-import { Parser, Input, eval } from '../combinator/data/parser';
-import { union, some, verify, convert, fmap } from '../combinator';
+import { Parser, Input, eval, failsafe } from '../combinator/data/parser';
+import { convert, fmap } from '../combinator';
 import { unsafehtmlentity } from './inline/htmlentity';
-import { linebreak, unescsource } from './source';
 import { invisibleHTMLEntityNames } from './api/normalize';
 import { push } from 'spica/array';
 
 export namespace blank {
   export const line = new RegExp(
-    /^(?:\\?[^\S\r\n]|&IHN;|<wbr[^\S\n]*>|\\$)+$/.source
+    // TODO: 行全体をエスケープ
+    /^(?:[^\S\r\n])*(?!\s)(\\?[^\S\r\n]|&IHN;|<wbr[^\S\n]*>|\\$)+$/mg.source
       .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`),
     'gm');
   export const start = new RegExp(
-    /^(?:\\?[^\S\r\n]|&IHN;|<wbr[^\S\n]*>)+/.source
-      .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`));
+    /(?:\\?[^\S\r\n]|&IHN;|<wbr[^\S\n]*>)+/y.source
+      .replace('IHN', `(?:${invisibleHTMLEntityNames.join('|')})`), 'y');
 }
 
 export function visualize<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function visualize<N extends HTMLElement | string>(parser: Parser<N>): Parser<N> {
-  return union([
-    convert(
-      source => source.replace(blank.line, line => line.replace(/[\\&<]/g, `${Command.Escape}$&`)),
-      verify(parser, (ns, { source, position }) => position === source.length && hasVisible(ns)),
-      false),
-    some(union([linebreak, unescsource])),
-  ]);
-}
-function hasVisible(
-  nodes: readonly (HTMLElement | string)[],
-): boolean {
-  for (let i = 0; i < nodes.length; ++i) {
-    const node = nodes[i];
-    if (typeof node === 'string') {
-      if (node && node.trimStart()) return true;
-    }
-    else {
-      if (node.innerText.trimStart()) return true;
-      if (node.classList.contains('reference')) return true;
-      //if (state & State.media ^ State.media &&
-      //    (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
-    }
-  }
-  return false;
+  return convert(
+    source => source.replace(blank.line, `${Command.Escape}$1`),
+    parser,
+    false);
 }
+//function hasVisible(
+//  nodes: readonly (HTMLElement | string)[],
+//): boolean {
+//  for (let i = 0; i < nodes.length; ++i) {
+//    const node = nodes[i];
+//    if (typeof node === 'string') {
+//      if (node && node.trimStart()) return true;
+//    }
+//    else {
+//      if (node.innerText.trimStart()) return true;
+//      if (node.classList.contains('reference')) return true;
+//      //if (state & State.media ^ State.media &&
+//      //    (node.classList.contains('media') || node.getElementsByClassName('media')[0])) return true;
+//    }
+//  }
+//  return false;
+//}
 
 export function blankWith(delimiter: string | RegExp): RegExp;
 export function blankWith(starts: '' | '\n', delimiter: string | RegExp): RegExp;
 export function blankWith(starts: '' | '\n', delimiter?: string | RegExp): RegExp {
   if (delimiter === undefined) return blankWith('', starts);
   return new RegExp(String.raw
-    `^(?:(?=${starts})(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr[^\S\n]*>)${
+    `(?:(?=${starts})(?:\\?\s|&(?:${invisibleHTMLEntityNames.join('|')});|<wbr[^\S\n]*>)${
       // 空行除去
       // 完全な空行はエスケープ済みなので再帰的バックトラックにはならない。
       starts && '+'
@@ -58,7 +55,7 @@ export function blankWith(starts: '' | '\n', delimiter?: string | RegExp): RegEx
       typeof delimiter === 'string'
         ? delimiter.replace(/[*+()\[\]]/g, '\\$&')
         : delimiter.source
-    }`);
+    }`, 'y');
 }
 
 //export function looseStart<P extends Parser<HTMLElement | string>>(parser: P, except?: string): P;
@@ -79,6 +76,7 @@ export function tightStart<N>(parser: Parser<N>, except?: string): Parser<N> {
       ? parser(input)
       : undefined;
 }
+const wbr = /<wbr[^\S\n]*>/y;
 function isTightStart(input: Input<MarkdownParser.Context>, except?: string): boolean {
   const { context } = input;
   const { source, position } = context;
@@ -103,10 +101,11 @@ function isTightStart(input: Input<MarkdownParser.Context>, except?: string): bo
       context.position = position;
       return true;
     case '<':
+      wbr.lastIndex = position;
       switch (true) {
         case source.length - position >= 5
           && source.startsWith('<wbr', position)
-          && (source[position + 5] === '>' || /^<wbr[^\S\n]*>/.test(source.slice(position))):
+          && (source[position + 5] === '>' || wbr.test(source)):
           return false;
       }
       return true;
@@ -165,16 +164,22 @@ export function trimBlank<N extends HTMLElement | string>(parser: Parser<N>): Pa
 }
 export function trimBlankStart<P extends Parser<unknown>>(parser: P): P;
 export function trimBlankStart<N>(parser: Parser<N>): Parser<N> {
-  return convert(
-    source => source.replace(blank.start, ''),
-    parser,
-    true);
+  return failsafe(input => {
+    const { context } = input;
+    const { source, position } = context;
+    if (position === source.length) return;
+    const reg = blank.start;
+    reg.lastIndex = position;
+    reg.test(source);
+    context.position = reg.lastIndex || position;
+    return context.position === source.length
+      ? [[]]
+      : parser(input);
+  });
 }
 export function trimBlankEnd<P extends Parser<HTMLElement | string>>(parser: P): P;
 export function trimBlankEnd<N extends HTMLElement | string>(parser: Parser<N>): Parser<N> {
-  return fmap(
-    parser,
-    trimBlankNodeEnd);
+  return fmap(parser, trimBlankNodeEnd);
 }
 //export function trimBlankNode<N extends HTMLElement | string>(nodes: N[]): N[] {
 //  return trimBlankNodeStart(trimBlankNodeEnd(nodes));