securemark 0.291.1 → 0.292.0

package/src/parser/inline.ts

@@ -20,7 +20,7 @@ import { code } from './inline/code';
 import { htmlentity } from './inline/htmlentity';
 import { bracket } from './inline/bracket';
 import { autolink } from './inline/autolink';
-import { text } from './source';
+import { text, strs } from './source';
 
 export import InlineParser = MarkdownParser.InlineParser;
 export import AnnotationParser = InlineParser.AnnotationParser;
@@ -47,11 +47,13 @@ export import ShortMediaParser = InlineParser.ShortMediaParser;
 export import BracketParser = InlineParser.BracketParser;
 export import AutolinkParser = InlineParser.AutolinkParser;
 
+const stars = strs('*');
+
 export const inline: InlineParser = lazy(() => union([
   input => {
-    const { source } = input;
-    if (source === '') return;
-    switch (source.slice(0, 2)) {
+    const { context: { source, position } } = input;
+    if (position === source.length) return;
+    switch (source.slice(position, position + 2)) {
       case '((':
         return annotation(input);
       case '[[':
@@ -79,8 +81,12 @@ export const inline: InlineParser = lazy(() => union([
         return mark(input);
       case '//':
         return italic(input);
+      case '**':
+        return emstrong(input)
+            || strong(input)
+            || stars(input);
     }
-    switch (source[0]) {
+    switch (source[position]) {
       case '[':
         return textlink(input)
             || ruby(input);
@@ -94,9 +100,8 @@ export const inline: InlineParser = lazy(() => union([
       case '`':
         return code(input);
       case '*':
-        return emstrong(input)
-            || strong(input)
-            || emphasis(input);
+        return emphasis(input)
+            || stars(input);
       case '&':
         return htmlentity(input);
     }

package/src/parser/segment.ts

@@ -1,6 +1,6 @@
 import { MarkdownParser } from '../../markdown';
 import { Command } from './context';
-import { eval, exec } from '../combinator/data/parser';
+import { clean, eval } from '../combinator/data/parser';
 import { union, some } from '../combinator';
 import { segment as heading } from './block/heading';
 import { segment as codeblock } from './block/codeblock';
@@ -25,20 +25,25 @@ const parser: SegmentParser = union([
 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)}`;
   assert(source.length < Number.MAX_SAFE_INTEGER);
-  while (source !== '') {
-    const result = parser({ source, context: {} })!;
+  const context = {
+    source,
+    position: 0,
+  };
+  const input = { context };
+  while (context.position < source.length) {
+    const { position } = context;
+    const result = parser(input)!;
     assert(result);
-    const rest = exec(result);
-    const segs = eval(result).length ? eval(result) : [source.slice(0, source.length - rest.length)];
-    assert(source.slice(1).endsWith(rest));
-    assert(segs.join('') === source.slice(0, source.length - rest.length));
+    assert(context.position > position);
+    const segs = eval(result).length ? eval(result) : [source.slice(position, context.position)];
+    assert(segs.join('') === source.slice(position, context.position));
     for (let i = 0; i < segs.length; ++i) {
       const seg = segs[i];
       validate(seg, MAX_SEGMENT_SIZE)
         ? yield seg
         : yield `${Command.Error}Too large segment over ${MAX_SEGMENT_SIZE.toLocaleString('en')} bytes.\n${seg}`
     }
-    source = rest;
+    clean(context);
   }
 }
 

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

@@ -1,45 +1,47 @@
 import { escsource } from './escapable';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/escsource', () => {
   describe('escsource', () => {
-    const parser = (source: string) => some(escsource)({ source, context: {} });
+    const parser = (source: string) => some(escsource)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('a')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('ab')), [['ab'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz')), [['09あいAZaz'], '']);
+      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'], '']);
     });
 
     it('space', () => {
-      assert.deepStrictEqual(inspect(parser(' ')), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('  ')), [[' ', ' '], '']);
-      assert.deepStrictEqual(inspect(parser('   ')), [['  ', ' '], '']);
-      assert.deepStrictEqual(inspect(parser(' \n')), [[' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n')), [[' ', ' ', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('   \n')), [['  ', ' ', '<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>'], '']);
     });
 
     it('linebreak', () => {
-      assert.deepStrictEqual(inspect(parser('\n\n')), [['<br>', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser('\n\n'), ctx), [['<br>', '<br>'], '']);
     });
 
     it('\\', () => {
-      assert.deepStrictEqual(inspect(parser('\\')), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\')), [['\\\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\')), [['\\\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\ ')), [['\\ '], '']);
-      assert.deepStrictEqual(inspect(parser('\\_')), [['\\_'], '']);
-      assert.deepStrictEqual(inspect(parser('\\0')), [['\\0'], '']);
-      assert.deepStrictEqual(inspect(parser('\\a')), [['\\a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\$')), [['\\$'], '']);
-      assert.deepStrictEqual(inspect(parser('\\　')), [['\\　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n')), [['\\', '<br>'], '']);
+      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('\\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/escapable.ts

@@ -1,53 +1,38 @@
 import { EscapableSourceParser } from '../source';
 import { Command } from '../context';
 import { consume } from '../../combinator';
-import { nonWhitespace } from './text';
 import { html } from 'typed-dom/dom';
 
-const delimiter = /[\s\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/;
-
-export const escsource: EscapableSourceParser = ({ source, context }) => {
-  if (source === '') return;
-  const i = source.search(delimiter);
-  switch (i) {
-    case -1:
-      consume(source.length, context);
-      return [[source], ''];
-    case 0:
+export const escsource: EscapableSourceParser = ({ context }) => {
+  const { source, position } = context;
+  if (position === source.length) return;
+  consume(1, context);
+  context.position += 1;
+  switch (source[position]) {
+    case '\r':
+      assert(!source.includes('\r', position + 1));
+      consume(-1, context);
+      return [[]];
+    case Command.Escape:
       consume(1, context);
-      switch (source[0]) {
-        case '\r':
-          assert(!source.includes('\r', 1));
-          consume(-1, context);
-          return [[], source.slice(1)];
-        case Command.Escape:
-          consume(1, context);
-          return [[source.slice(1, 2)], source.slice(2)];
-        case '\\':
-          switch (source[1]) {
-            case undefined:
-              return [[source[0]], ''];
-            case '\n':
-              return [[source[0]], source.slice(1)];
-            default:
-              consume(1, context);
-              return [[source.slice(0, 2)], source.slice(2)];
-          }
+      context.position += 1;
+      return [[source.slice(position + 1, position + 2)]];
+    case '\\':
+      switch (source[position + 1]) {
+        case undefined:
+          return [[source[position]]];
         case '\n':
-          context.linebreak ||= source.length;
-          return [[html('br')], source.slice(1)];
+          return [[source[position]]];
         default:
-          assert(source[0] !== '\n');
-          const b = source[0].trimStart() === '';
-          const i = b
-            ? source.search(nonWhitespace)
-            : 1;
-          assert(i > 0);
-          consume(i - 1, context);
-          return [[source.slice(0, i - +b || 1)], source.slice(i - +b || 1)];
+          consume(1, context);
+          context.position += 1;
+          return [[source.slice(position, position + 2)]];
       }
+    case '\n':
+      context.linebreak ||= source.length - position;
+      return [[html('br')]];
     default:
-      consume(i, context);
-      return [[source.slice(0, i)], source.slice(i)];
+      assert(source[position] !== '\n');
+      return [[source[position]]];
   }
 };

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

@@ -1,30 +1,32 @@
 import { contentline } from './line';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/line', () => {
   describe('contentline', () => {
-    const parser = (source: string) => contentline({ source, context: {} });
+    const parser = (source: string) => contentline(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
-      assert.deepStrictEqual(inspect(parser(' ')), undefined);
-      assert.deepStrictEqual(inspect(parser('\n')), undefined);
-      assert.deepStrictEqual(inspect(parser(' \n')), undefined);
-      assert.deepStrictEqual(inspect(parser('\n\n')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(' '), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('\n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser(' \n'), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser('\n\n'), ctx), undefined);
     });
 
     it('valid', () => {
-      assert.deepStrictEqual(inspect(parser('a')), [[], '']);
-      assert.deepStrictEqual(inspect(parser('a ')), [[], '']);
-      assert.deepStrictEqual(inspect(parser(' a')), [[], '']);
-      assert.deepStrictEqual(inspect(parser(' a ')), [[], '']);
-      assert.deepStrictEqual(inspect(parser(' a\n')), [[], '']);
-      assert.deepStrictEqual(inspect(parser(' a \n')), [[], '']);
-      assert.deepStrictEqual(inspect(parser('ab')), [[], '']);
-      assert.deepStrictEqual(inspect(parser('a\nb')), [[], 'b']);
-      assert.deepStrictEqual(inspect(parser('\\\n')), [[], '']);
-      assert.deepStrictEqual(inspect(parser('\\ \\\n')), [[], '']);
-      assert.deepStrictEqual(inspect(parser('\\ \\ \\\n')), [[], '']);
+      assert.deepStrictEqual(inspect(parser('a'), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser('a '), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser(' a'), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser(' a '), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser(' a\n'), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser(' a \n'), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser('ab'), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser('a\nb'), ctx), [[], 'b']);
+      assert.deepStrictEqual(inspect(parser('\\\n'), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser('\\ \\\n'), ctx), [[], '']);
+      assert.deepStrictEqual(inspect(parser('\\ \\ \\\n'), ctx), [[], '']);
     });
 
   });

package/src/parser/source/line.ts

@@ -1,6 +1,6 @@
 import { AnyLineParser, EmptyLineParser, ContentLineParser } from '../source';
 import { line, isBlank } from '../../combinator';
 
-export const anyline: AnyLineParser = line(() => [[], '']);
-export const emptyline: EmptyLineParser = line(i => isBlank(i.source) ? [[], ''] : undefined);
-export const contentline: ContentLineParser = line(i => !isBlank(i.source) ? [[], ''] : undefined);
+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);

package/src/parser/source/str.ts

@@ -9,19 +9,36 @@ export function str(pattern: string | RegExp, not?: string): Parser<string, Cont
     ? /[^^\\*+][*+]/.test(pattern.source)
     : false;
   return typeof pattern === 'string'
-    ? ({ source }) => {
-        if (source === '') return;
-        if (not && source.slice(pattern.length, pattern.length + not.length) === not) return;
-        return source.slice(0, pattern.length) === pattern
-          ? [[pattern], source.slice(pattern.length)]
-          : undefined;
+    ? ({ 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]];
       }
-    : ({ source, context }) => {
-        if (source === '') return;
-        const m = source.match(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(m[0].length, m[0].length + not.length) === not) return;
-        return [[m[0]], source.slice(m[0].length)];
+        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 strs(pattern: string): StrParser;
+export function strs(pattern: string): Parser<string> {
+  assert(pattern);
+  return ({ context }) => {
+    const { source } = context;
+    let acc = '';
+    while (context.position < source.length && source.startsWith(pattern, context.position)) {
+      acc += pattern;
+      context.position += pattern.length;
+    }
+    return [[acc]];
+  };
+}

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

@@ -1,118 +1,120 @@
 import { text } from './text';
 import { some } from '../../combinator';
+import { input } from '../../combinator/data/parser';
 import { inspect } from '../../debug.test';
 
 describe('Unit: parser/source/text', () => {
   describe('text', () => {
-    const parser = (source: string) => some(text)({ source, context: {} });
+    const parser = (source: string) => some(text)(input(source, ctx));
+    const { context: ctx } = input('', {});
 
     it('invalid', () => {
-      assert.deepStrictEqual(inspect(parser('')), undefined);
+      assert.deepStrictEqual(inspect(parser(''), ctx), undefined);
     });
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser('a')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('ab')), [['ab'], '']);
-      assert.deepStrictEqual(inspect(parser('09あいAZaz')), [['09', 'あい', 'AZaz'], '']);
-      assert.deepStrictEqual(inspect(parser('a\nb')), [['a', '<br>', 'b'], '']);
+      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('a\nb'), ctx), [['a', '<br>', 'b'], '']);
     });
 
     it('escape', () => {
-      assert.deepStrictEqual(inspect(parser('\\')), [[], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\')), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\')), [['\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\\\')), [['\\', '\\'], '']);
-      assert.deepStrictEqual(inspect(parser('\\ ')), [[' '], '']);
-      assert.deepStrictEqual(inspect(parser('\\_')), [['_'], '']);
-      assert.deepStrictEqual(inspect(parser('\\0')), [['0'], '']);
-      assert.deepStrictEqual(inspect(parser('\\a')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\a')), [['\\', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('\\　')), [['　'], '']);
-      assert.deepStrictEqual(inspect(parser('\\。')), [['。'], '']);
+      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('\\_'), ctx), [['_'], '']);
+      assert.deepStrictEqual(inspect(parser('\\0'), ctx), [['0'], '']);
+      assert.deepStrictEqual(inspect(parser('\\a'), ctx), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\a'), ctx), [['\\', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser('\\　'), ctx), [['　'], '']);
+      assert.deepStrictEqual(inspect(parser('\\。'), ctx), [['。'], '']);
     });
 
     it('space', () => {
-      assert.deepStrictEqual(inspect(parser(' ')), [[], '']);
-      assert.deepStrictEqual(inspect(parser('  ')), [[], '']);
-      assert.deepStrictEqual(inspect(parser('   ')), [[], '']);
-      assert.deepStrictEqual(inspect(parser(' \n')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \n')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \\\n')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('  \\\n')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' a')), [[' ', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('  a')), [[' ', ' ', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('   a')), [['  ', ' ', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('a ')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('a  ')), [['a'], '']);
-      assert.deepStrictEqual(inspect(parser('a \n')), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a  \n')), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a \\\n')), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a  \\\n')), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a b')), [['a', ' ', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('a  b')), [['a', ' ', ' ', 'b'], '']);
-      assert.deepStrictEqual(inspect(parser('a   b')), [['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')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n ')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \n')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n\n')), [['<br>', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser(' \n\n')), [['<br>', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n \n')), [['<br>', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\n\n ')), [['<br>', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('。\n')), [['。', '<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'), ctx), [['。', '<br>'], '']);
     });
 
     it('softbreak', () => {
-      assert.deepStrictEqual(inspect(parser('\\\n')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\n ')), [['<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\na')), [['<br>', 'a'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\n')), [['a', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('a\\\nb\\\n')), [['a', '<br>', 'b', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser('\\\\\\\n')), [['\\', '<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>'], '']);
+      assert.deepStrictEqual(inspect(parser('\\\\\\\n'), ctx), [['\\', '<br>'], '']);
     });
 
     it('account', () => {
-      assert.deepStrictEqual(inspect(parser('@0')), [['@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('_@0')), [['_', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('$@0')), [['$', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('+@0')), [['+', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('-@0')), [['-', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('0@0')), [['0', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('a@0')), [['a', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('A@0')), [['A', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('aA@0')), [['aA', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser(' @0')), [[' ', '@', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('@@0')), [['@', '@', '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), [['a', 'A', '@', '0'], '']);
+      assert.deepStrictEqual(inspect(parser(' @0'), ctx), [[' ', '@', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('@@0'), ctx), [['@', '@', '0'], '']);
     });
 
     it('hashtag', () => {
-      assert.deepStrictEqual(inspect(parser('#0')), [['#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('_#0')), [['_', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('$#0')), [['$', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('+#0')), [['+', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('-#0')), [['-', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('0#0')), [['0', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('a#0')), [['a', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('A#0')), [['A', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('aA#0')), [['a', 'A', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser(' #0')), [[' ', '#', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('##0')), [['#', '#', '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), [['a', 'A', '#', '0'], '']);
+      assert.deepStrictEqual(inspect(parser(' #0'), ctx), [[' ', '#', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('##0'), ctx), [['#', '#', '0'], '']);
     });
 
     it('anchor', () => {
-      assert.deepStrictEqual(inspect(parser('>>0')), [['>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('_>>0')), [['_', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('$>>0')), [['$', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('+>>0')), [['+', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('->>0')), [['-', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('0>>0')), [['0', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('a>>0')), [['a', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('A>>0')), [['A', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('aA>>0')), [['a', 'A', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser(' >>0')), [[' ', '>', '>', '0'], '']);
-      assert.deepStrictEqual(inspect(parser('>>>>0')), [['>', '>', '>', '>', '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), [['a', 'A', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser(' >>0'), ctx), [[' ', '>', '>', '0'], '']);
+      assert.deepStrictEqual(inspect(parser('>>>>0'), ctx), [['>', '>', '>', '>', '0'], '']);
     });
 
   });