securemark 0.299.4 → 0.300.1

package/src/combinator/process/line.test.ts

@@ -0,0 +1,21 @@
+import { input } from '../parser';
+import { line } from './line';
+import { inspect } from '../../debug.test';
+
+describe('Unit: lib/parser/combinator/line', () => {
+  describe('line', () => {
+    it('invalid', () => {
+      assert.deepStrictEqual(inspect(line(() => []), input('')), undefined);
+    });
+
+    it('valid', () => {
+      assert.deepStrictEqual(inspect(line(input => { input.position = input.source.length; return []; }), input(' ')), [[], '']);
+      assert.deepStrictEqual(inspect(line(input => { input.position = input.source.length; return []; }), input('\n')), [[], '']);
+      assert.deepStrictEqual(inspect(line(input => { input.position = input.source.length; return []; }), input('\n\n')), [[], '\n']);
+      assert.deepStrictEqual(inspect(line(input => { input.position = input.source.length; return []; }), input(' \n')), [[], '']);
+      assert.deepStrictEqual(inspect(line(input => { input.position = input.source.length - 1; return []; }), input(' \n')), [[], '']);
+    });
+
+  });
+
+});

package/src/combinator/process/line.ts

@@ -0,0 +1,55 @@
+import { Parser, Result, Input } from '../parser';
+import { always } from '../control/state';
+
+export function line<P extends Parser>(parser: P, slice?: boolean): P;
+export function line<T>(parser: Parser<T>, slice: boolean = true): Parser<T> {
+  assert(parser);
+  interface Memory {
+    readonly position: number;
+  }
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const { source, position } = input;
+      if (position === source.length) return Result.skip;
+      input.memory = {
+        position,
+      };
+      if (slice) {
+        const line = firstline(source, position);
+        input.position += line.length;
+        input.scope.focus(line);
+      }
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      if (slice) {
+        input.scope.unfocus(output.state, true);
+      }
+      if (!output.state) return;
+      const { source, position, memory } = input;
+      if (position === memory.position || position !== source.length && source[position - 1] !== '\n' && isEmptyline(source, position)) {
+        input.position = source.indexOf('\n', position) + 1 || source.length;
+      }
+      return output.state && (input.position === source.length || source[input.position - 1] === '\n')
+        ? output.context
+        : Result.fail;
+    },
+  ]);
+}
+
+export function firstline(source: string, position: number): string {
+  if (position === source.length) return '';
+  const i = source.indexOf('\n', position);
+  return i === -1
+    ? source.slice(position)
+    : source.slice(position, i + 1);
+}
+
+const emptyline = /[^\S\r\n]*(?:$|\r?\n)/y;
+export function isEmptyline(source: string, position: number): boolean {
+  emptyline.lastIndex = position;
+  return source.length === position
+      || source[position] === '\n'
+      || emptyline.test(source);
+}

package/src/combinator/process/match.ts

@@ -0,0 +1,37 @@
+import { Parser, Result, Input } from '../parser';
+import { always } from '../control/state';
+import { spend } from '../effect/clock';
+
+export function match<P extends Parser>(pattern: RegExp, f: (matched: RegExpMatchArray) => P): P;
+export function match<T>(pattern: RegExp, f: (matched: RegExpMatchArray) => Parser<T>): Parser<T> {
+  assert(!pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^'));
+  interface Memory {
+    readonly position: number;
+    readonly range: number;
+  }
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const { source, position } = input;
+      if (position === source.length) return Result.skip;
+      pattern.lastIndex = position;
+      const params = pattern.exec(source);
+      if (!params) return Result.skip;
+      assert(source.startsWith(params[0], position));
+      spend(input, output, params[0].length);
+      input.memory = {
+        position,
+        range: params[0].length,
+      };
+      return f(params)(input, output);
+    },
+    (input, output) => {
+      const { position, memory } = input;
+      input.position += output.state
+        ? position === memory.position
+          ? memory.range
+          : 0
+        : position - memory.position;
+      return output.context;
+    },
+  ]);
+}

package/src/combinator/process/reverse.ts

@@ -0,0 +1,7 @@
+import { Parser, List, Node } from '../parser';
+import { fmap } from './fmap';
+
+export function reverse<P extends Parser>(parser: P): P;
+export function reverse<T>(parser: Parser<T>): Parser<T> {
+  return fmap(parser, nodes => nodes.foldr((node, acc) => acc.push(nodes.delete(node)), new List<Node<T>>()));
+}

package/src/combinator/process/scope.ts

@@ -0,0 +1,102 @@
+import { Parser, Result, Input } from '../parser';
+import { matcher } from '../delimiter';
+import { always } from '../control/state';
+import { clear } from './clear';
+
+export function focus<P extends Parser>(scope: string | RegExp, parser: P, slice?: boolean): P;
+export function focus<T>(scope: string | RegExp, parser: Parser<T>, slice = true): Parser<T> {
+  assert(parser);
+  interface Memory {
+    readonly position: number;
+    readonly range: number;
+  }
+  const match = matcher(scope, slice);
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const { source, position } = input;
+      if (position === source.length) return Result.skip;
+      const src = match(input, output) ?? '';
+      assert(source.startsWith(src, position));
+      if (src === '') {
+        input.position = position;
+        return Result.skip;
+      }
+      input.range = src.length;
+      if (slice) {
+        input.scope.focus(src);
+      }
+      else {
+        input.memory = {
+          position,
+          range: input.range,
+        };
+      }
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      if (slice) {
+        input.scope.unfocus(output.state, true);
+      }
+      else {
+        input.position += output.state && input.position === input.memory.position
+          ? input.memory.range
+          : 0;
+      }
+      return output.context;
+    },
+  ]);
+}
+
+export function rewrite<P extends Parser>(scope: Parser<unknown, Parser.Input<P>>, parser: P, slice?: boolean): P;
+export function rewrite<T>(scope: Parser, parser: Parser<T>, slice = true): Parser<T> {
+  assert(scope);
+  assert(parser);
+  interface Memory {
+    readonly position: number;
+    range: number;
+    readonly linebreak: number;
+  }
+  return always<Parser<T, Input<Memory>>>([
+    (input, output) => {
+      const { source, position, linebreak } = input;
+      if (position === source.length) return Result.skip;
+      input.memory = {
+        position,
+        range: 0,
+        linebreak,
+      };
+      return output.context;
+    },
+    clear(scope),
+    (input, output) => {
+      const { source, position, memory } = input;
+      const range = position - memory.position;
+      input.range = memory.range = range;
+      input.linebreak = memory.linebreak;
+      if (!output.state || range === 0) {
+        input.position = memory.position;
+        return Result.skip;
+      }
+      if (slice) {
+        input.scope.focus(source.slice(position - range, position));
+      }
+      else {
+        input.position -= range;
+      }
+      return output.context;
+    },
+    parser,
+    (input, output) => {
+      if (slice) {
+        input.scope.unfocus(output.state, true);
+      }
+      else {
+        input.position += output.state && input.position === input.memory.position
+          ? input.memory.range
+          : 0;
+      }
+      return output.context;
+    },
+  ]);
+}

package/src/combinator/process/surround.ts

@@ -0,0 +1,273 @@
+import { Parser, Result, Input, Output, List, Node } from '../parser';
+import { tester } from '../delimiter';
+
+export function surround<P extends Parser, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: Parser.IntermediateParser<P>,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: false,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>>, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<P extends Parser, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: Parser.IntermediateParser<P>,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.SubNode<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<P extends Parser, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: P,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: false,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>>, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<P extends Parser, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: P,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<P extends Parser<string>, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: string | RegExp | P,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: false,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>>, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<P extends Parser<string>, S = string>(
+  opener: string | RegExp | Parser<S, Parser.Input<P>>,
+  parser: string | RegExp | P,
+  closer: string | RegExp | Parser<S, Parser.Input<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+  f?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined, List<Node<S>>], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+  g?: (rss: [List<Node<S>>, List<Node<Parser.Node<P>>> | undefined], input: Parser.Input<P>, output: Output<Parser.Node<P>>) => Result<Parser.Node<P>, Parser.Input<P>, Parser.SubParsers<P>>,
+): P;
+export function surround<T>(
+  opener: string | RegExp | Parser<T>,
+  parser: string | RegExp | Parser<T>,
+  closer: string | RegExp | Parser<T>,
+  optional: boolean = false,
+  backtracks: readonly number[] = [],
+  f?: (rss: [List<Node<T>>, List<Node<T>>, List<Node<T>>], input: Input, output: Output<T>) => Result<T>,
+  g?: (rss: [List<Node<T>>, List<Node<T>> | undefined], input: Input, output: Output<T>) => Result<T>,
+): Parser<T> {
+  switch (typeof opener) {
+    case 'string':
+    case 'object':
+      opener = wrap(opener);
+  }
+  assert(opener);
+  switch (typeof parser) {
+    case 'string':
+    case 'object':
+      parser = wrap(parser);
+  }
+  assert(parser);
+  switch (typeof closer) {
+    case 'string':
+    case 'object':
+      closer = wrap(closer);
+  }
+  assert(closer);
+  const [blen, rbs, wbs] = reduce(backtracks);
+  interface Memory {
+    readonly position: number;
+    readonly linebreak: number;
+    state: boolean;
+  }
+  const cont1: Result<T, Input<Memory>> = [
+    (input, output) => {
+      const { source, position, linebreak } = input;
+      if (position === source.length) return Result.skip;
+      input.linebreak = 0;
+      input.memory = {
+        position,
+        linebreak,
+        state: false,
+      };
+      output.push();
+      return cont2;
+    },
+    (input, output) => {
+      const { memory: { linebreak } } = input;
+      if (output.state) {
+        input.linebreak ||= linebreak;
+      }
+      else {
+        input.linebreak = linebreak;
+      }
+      return output.context;
+    },
+  ];
+  const cont2: Result<T, Input<Memory>> = [
+    opener,
+    (input, output) => {
+      const { memory: { position } } = input;
+      if (!output.state || rbs && isBacktrack(input, rbs, position, blen)) {
+        output.pop();
+        return;
+      }
+      output.push();
+      return cont3;
+    },
+  ];
+  const cont3: Result<T, Input<Memory>> = [
+    parser,
+    (input, output) => {
+      const { state } = output;
+      const { memory: { position } } = input;
+      input.range = input.position - position;
+      if (!output.state && !optional) {
+        wbs && setBacktrack(input, wbs, position);
+        const m = output.pop();
+        const o = output.pop();
+        if (!g) return;
+        output.state = true;
+        // @ts-expect-error
+        output.context = Result.succ;
+        return g([o, state ? m : undefined], input, output);
+      }
+      input.memory.state = output.state;
+      output.push();
+      return cont4;
+    },
+  ];
+  const cont4: Result<T, Input<Memory>> = [
+    closer,
+    (input, output) => {
+      const { memory: { position, state } } = input;
+      const c = output.pop();
+      const m = output.pop();
+      const o = output.pop();
+      input.range = input.position - position;
+      if (!output.state) {
+        wbs && setBacktrack(input, wbs, position);
+        if (!g) return;
+        output.state = true;
+        // @ts-expect-error
+        output.context = Result.succ;
+        return g([o, state ? m : undefined], input, output);
+      }
+      if (input.range === 0) return;
+      if (f) {
+        return f([o, state ? m : undefined as any, c], input, output);
+      }
+      else {
+        output.import(o.import(m).import(c));
+        return output.context;
+      }
+    },
+  ];
+  return () => cont1;
+}
+export function open<P extends Parser>(
+  opener: string | RegExp | Parser<Parser.Node<P>, Parser.Input<P>>,
+  parser: P,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
+export function open<P extends Parser<string>>(
+  opener: string | RegExp | Parser<Parser.Node<P>, Parser.Input<P>>,
+  parser: string | RegExp | P,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
+export function open<N>(
+  opener: string | RegExp | Parser<N, Input>,
+  parser: string | RegExp | Parser<N>,
+  optional?: boolean,
+  backtracks: readonly number[] = [],
+): Parser<N> {
+  return surround(opener, parser as Parser<N>, '', optional, backtracks);
+}
+export function close<P extends Parser>(
+  parser: P,
+  closer: string | RegExp | Parser<Parser.Node<P>, Parser.Input<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
+export function close<P extends Parser<string>>(
+  parser: string | RegExp | P,
+  closer: string | RegExp | Parser<Parser.Node<P>, Parser.Input<P>>,
+  optional?: boolean,
+  backtracks?: readonly number[],
+): P;
+export function close<N>(
+  parser: string | RegExp | Parser<N>,
+  closer: string | RegExp | Parser<N, Input>,
+  optional?: boolean,
+  backtracks: readonly number[] = [],
+): Parser<N> {
+  return surround('', parser as Parser<N>, closer, optional, backtracks);
+}
+
+const commandsize = 2;
+export function isBacktrack(
+  input: Input,
+  backtrack: number,
+  position: number = input.position,
+  length: number = 1,
+): boolean {
+  assert(1 & backtrack);
+  assert(backtrack >>> commandsize);
+  assert(0 < length && length < 3);
+  const { backtracks, offset } = input;
+  for (let i = 0; i < length; ++i) {
+    if (backtracks[position + i + offset] & backtrack >>> commandsize) return true;
+  }
+  return false;
+}
+export function setBacktrack(
+  input: Input,
+  backtrack: number,
+  position: number,
+  length: number = 1,
+): void {
+  // バックトラックの可能性がなく記録不要の場合もあるが判別が面倒なので省略
+  assert(2 & backtrack);
+  assert(backtrack >>> commandsize);
+  assert(0 < length && length < 3);
+  const { backtracks, offset } = input;
+  for (let i = 0; i < length; ++i) {
+    backtracks[position + i + offset] |= backtrack >>> commandsize;
+  }
+}
+
+function wrap<T>(pattern: string | RegExp): Parser<T> {
+  const test = tester(pattern, true);
+  return (input, output) => test(input, output) ? output.context : Result.fail;
+}
+
+function reduce(backtracks: readonly number[]): readonly [number, number, number] {
+  let len = 1;
+  let rbs = 0;
+  let wbs = 0;
+  for (const backtrack of backtracks) {
+    if (backtrack >>> commandsize === 0) {
+      len = backtrack;
+      assert(len > 0);
+      continue;
+    }
+    assert(backtrack >>> commandsize);
+    if (1 & backtrack) {
+      rbs |= backtrack;
+    }
+    if (2 & backtrack) {
+      wbs |= backtrack;
+    }
+  }
+  return [len, rbs, wbs];
+}

package/src/combinator.ts

@@ -1,24 +1,28 @@
-export * from './combinator/data/parser/union';
-export * from './combinator/data/parser/inits';
-export * from './combinator/data/parser/tails';
-export * from './combinator/data/parser/sequence';
-export * from './combinator/data/parser/subsequence';
-export * from './combinator/data/parser/some';
-export * from './combinator/data/parser/context';
-export * from './combinator/control/constraint/block';
-export * from './combinator/control/constraint/line';
-export * from './combinator/control/constraint/contract';
-export * from './combinator/control/manipulation/fence';
-export * from './combinator/control/manipulation/indent';
-export * from './combinator/control/manipulation/scope';
-export * from './combinator/control/manipulation/clear';
-export * from './combinator/control/manipulation/surround';
-export * from './combinator/control/manipulation/match';
-export * from './combinator/control/manipulation/convert';
-export * from './combinator/control/manipulation/duplicate';
-export * from './combinator/control/manipulation/reverse';
-export * from './combinator/control/manipulation/fallback';
-export * from './combinator/control/manipulation/recovery';
-export * from './combinator/control/manipulation/lazy';
-export * from './combinator/control/monad/fmap';
-export * from './combinator/control/monad/bind';
+export * from './combinator/control/union';
+export * from './combinator/control/inits';
+export * from './combinator/control/tails';
+export * from './combinator/control/sequence';
+export * from './combinator/control/subsequence';
+export * from './combinator/control/some';
+export * from './combinator/control/state';
+export * from './combinator/effect/state';
+export * from './combinator/effect/clock';
+export * from './combinator/effect/recursion';
+export * from './combinator/effect/precedence';
+export * from './combinator/effect/scope';
+export * from './combinator/effect/backtrack';
+export * from './combinator/process/block';
+export * from './combinator/process/line';
+export * from './combinator/process/contract';
+export * from './combinator/process/fence';
+export * from './combinator/process/indent';
+export * from './combinator/process/scope';
+export * from './combinator/process/clear';
+export * from './combinator/process/surround';
+export * from './combinator/process/match';
+export * from './combinator/process/duplicate';
+export * from './combinator/process/reverse';
+export * from './combinator/process/fallback';
+export * from './combinator/process/lazy';
+export * from './combinator/process/fmap';
+export * from './combinator/process/bind';

package/src/debug.test.ts

@@ -1,12 +1,15 @@
-import { Parser, Input } from './combinator/data/parser';
+import { Parser, Input, Output, run } from './combinator/parser';
 import { html, define } from 'typed-dom/dom';
 import { querySelectorWith, querySelectorAllWith } from 'typed-dom/query';
 
-export function inspect(parser: Parser<DocumentFragment | HTMLElement | string>, input: Input, until: number | string = Infinity): [string[], string] | undefined {
-  const context = input;
-  const result = parser(input);
-  return result && [
-    result.foldl<string[]>((acc, { value: node }) => {
+export function inspect(parser: Parser<DocumentFragment | HTMLElement | string>, input: Input, until: number | string = Infinity): [...string[][], string] | undefined {
+  const output = new Output<DocumentFragment | HTMLElement | string>();
+  for (const _ of run(parser, input, output));
+  assert.deepStrictEqual(output.data, [output.data[0]]);
+  assert(output.state || output.peek().length === 0);
+  assert(!output.error);
+  return !output.state ? undefined : [
+    ...output.data.map(nodes => nodes.foldl<string[]>((acc, { value: node }) => {
       assert(node);
       if (typeof node === 'string') return acc.push(node), acc;
       if (node instanceof DocumentFragment) return acc.push(html('div', [node]).innerHTML), acc;
@@ -35,8 +38,8 @@ export function inspect(parser: Parser<DocumentFragment | HTMLElement | string>,
         assert(el.innerHTML.startsWith(node.outerHTML.slice(0, until)));
       }
       return acc.push(normalize(node.outerHTML.slice(0, until))), acc;
-    }, []),
-    context.source.slice(context.position),
+    }, [])),
+    input.source.slice(input.position),
   ];
 }
 

package/src/parser/autolink.test.ts

@@ -1,6 +1,5 @@
 import { autolink } from './autolink';
-import { input } from '../combinator/data/parser';
-import { Context } from './context';
+import { input } from './context';
 import { inspect } from '../debug.test';
 
 describe('Unit: parser/autolink', () => {
@@ -8,22 +7,22 @@ describe('Unit: parser/autolink', () => {
     const parser = autolink;
 
     it('basic', () => {
-      assert.deepStrictEqual(inspect(parser, input('http://host)', new Context())), [['<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('http://host\\', new Context())), [['<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('!http://host)', new Context())), [['!', '<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('!http://host\\', new Context())), [['!', '<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('#a', new Context())), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('@a#b', new Context())), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('\\\n', new Context())), [['\\', '<br>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('a#b', new Context())), [['a', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('0a#b', new Context())), [['0a', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('あ#b', new Context())), [['あ', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('あい#b', new Context())), [['あい', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('0aあ#b', new Context())), [['0a', 'あ', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('0aあい#b', new Context())), [['0a', 'あい', '#b'], '']);
-      assert.deepStrictEqual(inspect(parser, input('a\n#b', new Context())), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('a\\\n#b', new Context())), [['a', '\\', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
-      assert.deepStrictEqual(inspect(parser, input('0a>>b', new Context())), [['0a', '>', '>b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('http://host)')), [['<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('http://host\\')), [['<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('!http://host)')), [['!', '<a class="url" href="http://host)" target="_blank">http://host)</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('!http://host\\')), [['!', '<a class="url" href="http://host\\" target="_blank">http://host\\</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('#a')), [['<a class="hashtag" href="/hashtags/a">#a</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('@a#b')), [['<a class="channel" href="/@a?ch=b">@a#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('\\\n')), [['\\', '<br>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a#b')), [['a', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0a#b')), [['0a', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('あ#b')), [['あ', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('あい#b')), [['あい', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0aあ#b')), [['0a', 'あ', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0aあい#b')), [['0a', 'あい', '#b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\n#b')), [['a', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('a\\\n#b')), [['a', '\\', '<br>', '<a class="hashtag" href="/hashtags/b">#b</a>'], '']);
+      assert.deepStrictEqual(inspect(parser, input('0a>>b')), [['0a', '>', '>b'], '']);
     });
 
   });