diff --git a/examples/calculator/src/index.ts b/examples/calculator/src/index.ts
index 9967b64..0c799ba 100644
--- a/examples/calculator/src/index.ts
+++ b/examples/calculator/src/index.ts
@@ -1,4 +1,4 @@
-import { token as T } from 'terrario';
+import { tokenParsers as T } from 'terrario';
 import { Operator, buildPrattParser } from './pratt.js';
 
 type Expr = { kind: 'number', value: number } | Operator<Expr>;
diff --git a/examples/calculator/src/pratt.ts b/examples/calculator/src/pratt.ts
index c1b7482..a346ed0 100644
--- a/examples/calculator/src/pratt.ts
+++ b/examples/calculator/src/pratt.ts
@@ -1,4 +1,4 @@
-import { token as T } from 'terrario';
+import { tokenParsers as T } from 'terrario';
 
 type OperatorInfo = {
   kind: 'prefix' | 'postfix',
diff --git a/examples/json/src/index.ts b/examples/json/src/index.ts
index 6617ca1..9549696 100644
--- a/examples/json/src/index.ts
+++ b/examples/json/src/index.ts
@@ -1,6 +1,6 @@
-import { string as T } from 'terrario';
+import * as T from 'terrario';
 
-const spaces = T.str(/[ \t\r\n]/).many();
+const spaces = T.token(/[ \t\r\n]/).many();
 
 type JsonValue = null | boolean | string | number | Record<string, unknown> | unknown[];
 
@@ -31,35 +31,35 @@ const lang = T.language<Json>({
     r.number,
   ]),
 
-  null: r => T.str('null').map(() => null),
+  null: r => T.token('null').map(() => null),
 
   bool: r => T.alt([
-    T.str('true'),
-    T.str('false'),
+    T.token('true'),
+    T.token('false'),
   ]).map(value => (value === 'true')),
 
   string: r => T.seq([
-    T.str('"'),
-    T.char.many({ notMatch: T.alt([T.str('"'), T.cr, T.lf]) }).text(),
-    T.str('"'),
+    T.token('"'),
+    T.any.many({ notMatch: T.alt([T.token('"'), T.cr, T.lf]) }).span(),
+    T.token('"'),
   ], 1),
 
   number: r => T.alt([
     T.seq([
-      T.str(/[+-]/).option(),
-      T.str(/[0-9]/).many(1),
+      T.token(/[+-]/).option(),
+      T.token(/[0-9]/).many(1),
       T.seq([
-        T.str('.'),
-        T.str(/[0-9]/).many(1),
+        T.token('.'),
+        T.token(/[0-9]/).many(1),
       ]).option(),
-    ]).text(),
+    ]).span(),
   ]).map(value => Number(value)),
 
   object: r => {
     const entry = T.seq([
       r.string,
       spaces,
-      T.str(':'),
+      T.token(':'),
       spaces,
       r.value,
     ]).map(value => {
@@ -67,11 +67,11 @@ const lang = T.language<Json>({
     });
     const separator = T.seq([
       spaces,
-      T.str(','),
+      T.token(','),
       spaces,
     ]);
     return T.seq([
-      T.str('{'),
+      T.token('{'),
       spaces,
       T.seq([
         entry,
@@ -80,7 +80,7 @@ const lang = T.language<Json>({
         ], 1).many(),
       ]).map(x => [x[0], ...x[1]]).option(),
       spaces,
-      T.str('}'),
+      T.token('}'),
     ], 2).map(value => {
       if (value == null) {
         return {};
@@ -96,11 +96,11 @@ const lang = T.language<Json>({
   array: r => {
     const separator = T.seq([
       spaces,
-      T.str(','),
+      T.token(','),
       spaces,
     ]);
     return T.seq([
-      T.str('['),
+      T.token('['),
       spaces,
       T.seq([
         r.value,
@@ -110,7 +110,7 @@ const lang = T.language<Json>({
         ], 1).many(),
       ]).map(x => [x[0], ...x[1]]).option(),
       spaces,
-      T.str(']'),
+      T.token(']'),
     ], 2).map(value => {
       return (value != null ? value : []);
     });
diff --git a/src/index.ts b/src/index.ts
index 78b7852..c0e7940 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,7 +1,79 @@
-import * as string from './string-parser.js';
-import * as token from './token-parser.js';
+import {
+  Failure,
+  Language,
+  LanguageSource,
+  LazyContext,
+  LazyParserOpts,
+  ParserContext,
+  ParserHandler,
+  Result,
+  ResultType,
+  ResultTypes,
+  StrictParserOpts,
+  Success,
+  Parser,
+  alt,
+  any,
+  cr,
+  crlf,
+  eof,
+  failure,
+  language,
+  lazy,
+  lf,
+  lineBegin,
+  lineEnd,
+  match,
+  newline,
+  notMatch,
+  parser,
+  seq,
+  sof,
+  succeeded,
+  success,
+  token,
+  where,
+} from './string-parsers.js';
 
 export {
-  string,
+  Failure,
+  Language,
+  LanguageSource,
+  LazyContext,
+  LazyParserOpts,
+  ParserContext,
+  ParserHandler,
+  Result,
+  ResultType,
+  ResultTypes,
+  StrictParserOpts,
+  Success,
+  Parser,
+  alt,
+  any,
+  cr,
+  crlf,
+  eof,
+  failure,
+  language,
+  lazy,
+  lf,
+  lineBegin,
+  lineEnd,
+  match,
+  newline,
+  notMatch,
+  parser,
+  seq,
+  sof,
+  succeeded,
+  success,
   token,
+  where,
+};
+
+import * as tokenParsers from './token-parsers.js';
+
+export {
+  tokenParsers,
 };
diff --git a/src/string-parser.ts b/src/string-parsers.ts
similarity index 80%
rename from src/string-parser.ts
rename to src/string-parsers.ts
index 9982fb8..2198efe 100644
--- a/src/string-parser.ts
+++ b/src/string-parsers.ts
@@ -1,11 +1,25 @@
-import { success, failure, Result } from './result.js';
+import {
+  Failure,
+  Result,
+  Success,
+  failure,
+  success,
+} from './result.js';
+
+export {
+  Failure,
+  Result,
+  Success,
+  failure,
+  success,
+};
 
 /**
  * String Parser
  * 
  * @public
 */
-export class StringParser<U> {
+export class Parser<U> {
   tag: string;
   ctx: ParserContext<U> | LazyContext<U>;
 
@@ -109,7 +123,7 @@ export class StringParser<U> {
    * 
    * @public
   */
-  map<V>(fn: (value: U) => V): StringParser<V> {
+  map<V>(fn: (value: U) => V): Parser<V> {
     return createParser((input, index, state) => {
       const result = this.exec(input, state, index);
       if (!result.success) {
@@ -124,14 +138,14 @@ export class StringParser<U> {
    * 
    * @public
   */
-  many(min?: number, max?: number): StringParser<U[]>
+  many(min?: number, max?: number): Parser<U[]>
   /**
    * Create a new parser that tries to apply the parser iteratively.
    * 
    * @public
   */
-  many(opts: { min?: number, max?: number, notMatch?: StringParser<unknown> }): StringParser<U[]>
-  many(arg1?: number | { min?: number, max?: number, notMatch?: StringParser<unknown> }, arg2?: number): StringParser<U[]> {
+  many(opts: { min?: number, max?: number, notMatch?: Parser<unknown> }): Parser<U[]>
+  many(arg1?: number | { min?: number, max?: number, notMatch?: Parser<unknown> }, arg2?: number): Parser<U[]> {
     if (typeof arg1 === 'number') {
       // with min, max
       return many(this, { min: arg1, max: arg2 });
@@ -148,7 +162,7 @@ export class StringParser<U> {
    * 
    * @public
   */
-  option(): StringParser<U | null> {
+  option(): Parser<U | null> {
     return alt([
       this,
       succeeded(null),
@@ -163,7 +177,7 @@ export class StringParser<U> {
    * 
    * @public
   */
-  state(key: string, value: (state: any) => any): StringParser<U> {
+  state(key: string, value: (state: any) => any): Parser<U> {
     return createParser((input, index, state) => {
       const storedValue = state[key];
       state[key] = value(state);
@@ -175,11 +189,11 @@ export class StringParser<U> {
 
   /**
    * Create a new parser that wraps the current parser.
-   * The generated parser will return the text in the range matched by the inner parser.
+   * The generated parser will return the span in the range matched by the inner parser.
    * 
    * @public
   */
-  text(): StringParser<string> {
+  span(): Parser<string> {
     return createParser((input, index, state) => {
       const result = this.exec(input, state, index);
       if (!result.success) {
@@ -187,7 +201,7 @@ export class StringParser<U> {
       }
       const text = input.slice(index, result.index);
       return success(result.index, text);
-    }, 'text');
+    }, 'span');
   }
 }
 
@@ -204,7 +218,7 @@ export type StrictParserOpts<U> = {
  * @internal
 */
 export type LazyParserOpts<U> = {
-  lazy: () => StringParser<U>,
+  lazy: () => Parser<U>,
   tag?: string,
   handler?: undefined,
 };
@@ -229,7 +243,7 @@ export type ParserContext<U> = {
 */
 export type LazyContext<U> = {
   kind: 'lazy',
-  handler: () => StringParser<U>,
+  handler: () => Parser<U>,
 };
 
 /**
@@ -237,7 +251,7 @@ export type LazyContext<U> = {
  * 
  * @internal
 */
-export type ResultType<U> = U extends StringParser<infer R> ? R : never;
+export type ResultType<U> = U extends Parser<infer R> ? R : never;
 
 /**
  * Get result types of Parsers.
@@ -265,7 +279,7 @@ function wrapByTraceHandler<U>(handler: ParserHandler<U>, tag: string): ParserHa
   };
 }
 
-function many<U>(parser: StringParser<U>, opts: { min?: number, max?: number, notMatch?: StringParser<unknown> } = {}): StringParser<U[]> {
+function many<U>(parser: Parser<U>, opts: { min?: number, max?: number, notMatch?: Parser<unknown> } = {}): Parser<U[]> {
   if (opts.notMatch != null) {
     return many(seq([
       notMatch(opts.notMatch),
@@ -299,19 +313,19 @@ function many<U>(parser: StringParser<U>, opts: { min?: number, max?: number, no
  * 
  * @public
 */
-export function seq<U extends StringParser<any>[]>(parsers: [...U]): StringParser<ResultTypes<[...U]>>
+export function seq<U extends Parser<any>[]>(parsers: [...U]): Parser<ResultTypes<[...U]>>
 /**
  * Create a new parser that sequentially applies an array of parser.
  * 
  * @public
  * @param select - The index of the data returned in the result.
 */
-export function seq<U extends StringParser<any>[], V extends number>(parsers: [...U], select: V): U[V]
-export function seq(parsers: StringParser<any>[], select?: number) {
+export function seq<U extends Parser<any>[], V extends number>(parsers: [...U], select: V): U[V]
+export function seq(parsers: Parser<any>[], select?: number) {
   return (select == null) ? seqAll(parsers) : seqSelect(parsers, select);
 }
 
-function seqAll<U extends StringParser<any>[]>(parsers: [...U]): StringParser<ResultTypes<[...U]>> {
+function seqAll<U extends Parser<any>[]>(parsers: [...U]): Parser<ResultTypes<[...U]>> {
   return createParser((input, index, state) => {
     let result;
     let latestIndex = index;
@@ -328,7 +342,7 @@ function seqAll<U extends StringParser<any>[]>(parsers: [...U]): StringParser<Re
   }, `seq length=${parsers.length}`);
 }
 
-function seqSelect<U extends StringParser<any>[], V extends number>(parsers: [...U], select: V): U[V] {
+function seqSelect<U extends Parser<any>[], V extends number>(parsers: [...U], select: V): U[V] {
   return seqAll(parsers).map(values => values[select]);
 }
 
@@ -337,7 +351,7 @@ function seqSelect<U extends StringParser<any>[], V extends number>(parsers: [..
  * 
  * @public
 */
-export function alt<U extends StringParser<unknown>[]>(parsers: [...U]): StringParser<ResultTypes<U>[number]> {
+export function alt<U extends Parser<unknown>[]>(parsers: [...U]): Parser<ResultTypes<U>[number]> {
   return createParser((input, index, state) => {
     let result;
     for (let i = 0; i < parsers.length; i++) {
@@ -355,8 +369,8 @@ export function alt<U extends StringParser<unknown>[]>(parsers: [...U]): StringP
  * 
  * @public
 */
-function createParser<U>(handler: ParserHandler<U>, tag?: string): StringParser<U> {
-  return new StringParser({ handler, tag });
+function createParser<U>(handler: ParserHandler<U>, tag?: string): Parser<U> {
+  return new Parser({ handler, tag });
 }
 export { createParser as parser };
 
@@ -365,8 +379,8 @@ export { createParser as parser };
  * 
  * @public
 */
-export function lazy<U>(fn: () => StringParser<U>, tag?: string): StringParser<U> {
-  return new StringParser({ lazy: fn, tag });
+export function lazy<U>(fn: () => Parser<U>, tag?: string): Parser<U> {
+  return new Parser({ lazy: fn, tag });
 }
 
 /**
@@ -374,7 +388,7 @@ export function lazy<U>(fn: () => StringParser<U>, tag?: string): StringParser<U
  * 
  * @public
 */
-export function succeeded<U>(value: U): StringParser<U> {
+export function succeeded<U>(value: U): Parser<U> {
   return createParser((_input, index, _state) => {
     return success(index, value);
   }, 'succeeded');
@@ -385,7 +399,7 @@ export function succeeded<U>(value: U): StringParser<U> {
  * 
  * @public
 */
-export function match<U>(parser: StringParser<U>): StringParser<U> {
+export function match<U>(parser: Parser<U>): Parser<U> {
   return createParser((input, index, state) => {
     const result = parser.exec(input, state, index);
     return result.success
@@ -399,7 +413,7 @@ export function match<U>(parser: StringParser<U>): StringParser<U> {
  * 
  * @public
 */
-export function notMatch(parser: StringParser<unknown>): StringParser<null> {
+export function notMatch(parser: Parser<unknown>): Parser<null> {
   return createParser((input, index, state) => {
     const result = parser.exec(input, state, index);
     return !result.success
@@ -413,7 +427,7 @@ export function notMatch(parser: StringParser<unknown>): StringParser<null> {
  * 
  * @public
 */
-export function where<U>(condition: (state: any) => boolean, parser: StringParser<U>): StringParser<U> {
+export function where<U>(condition: (state: any) => boolean, parser: Parser<U>): Parser<U> {
   return createParser((input, index, state) => {
     return condition(state)
       ? parser.exec(input, state, index)
@@ -449,11 +463,11 @@ export const eof = createParser((input, index, _state) => {
  * @public
 */
 export function language<U extends Language<U>>(source: LanguageSource<U>): U {
-  const lang: Record<string, StringParser<any>> = {};
+  const lang: Record<string, Parser<any>> = {};
   for (const key of Object.keys(source)) {
     lang[key] = lazy(() => {
       const parser = (source as any)[key](lang);
-      if (parser == null || !(parser instanceof StringParser)) {
+      if (parser == null || !(parser instanceof Parser)) {
         throw new Error('syntax must return a Parser.');
       }
       parser.tag = `${parser.tag} key=${key}`;
@@ -468,7 +482,7 @@ export function language<U extends Language<U>>(source: LanguageSource<U>): U {
  * 
  * @public
 */
-export type Language<U> = {[K in keyof U]: U[K] extends StringParser<unknown> ? U[K] : never };
+export type Language<U> = {[K in keyof U]: U[K] extends Parser<unknown> ? U[K] : never };
 
 /**
  * Language source
@@ -477,26 +491,23 @@ export type Language<U> = {[K in keyof U]: U[K] extends StringParser<unknown> ?
 */
 export type LanguageSource<U extends Language<U>> = { [K in keyof U]: (lang: U) => U[K] };
 
-
-
-
 /**
  * Create a new parser that matches the given string.
  * 
  * @public
 */
-export function str<U extends string>(value: U): StringParser<U>
+export function token<U extends string>(value: U): Parser<U>
 /**
  * Create a new parser that matches the given regular expression.
  * 
  * @public
 */
-export function str(pattern: RegExp): StringParser<string>
-export function str(value: string | RegExp): StringParser<string> {
-  return (typeof value === 'string') ? strWithString(value) : strWithRegExp(value);
+export function token(pattern: RegExp): Parser<string>
+export function token(value: string | RegExp): Parser<string> {
+  return (typeof value === 'string') ? tokenWithString(value) : tokenWithRegExp(value);
 }
 
-function strWithString<U extends string>(value: U): StringParser<U> {
+function tokenWithString<U extends string>(value: U): Parser<U> {
   return createParser((input, index, _state) => {
     if ((input.length - index) < value.length) {
       return failure(index);
@@ -505,10 +516,10 @@ function strWithString<U extends string>(value: U): StringParser<U> {
       return failure(index);
     }
     return success(index + value.length, value);
-  }, `str value=${value}`);
+  }, `token value=${value}`);
 }
 
-function strWithRegExp(pattern: RegExp): StringParser<string> {
+function tokenWithRegExp(pattern: RegExp): Parser<string> {
   const re = RegExp(`^(?:${pattern.source})`, pattern.flags);
   return createParser((input, index, _state) => {
     const text = input.slice(index);
@@ -517,7 +528,7 @@ function strWithRegExp(pattern: RegExp): StringParser<string> {
       return failure(index);
     }
     return success(index + result[0].length, result[0]);
-  }, `str pattern=${pattern}`);
+  }, `token pattern=${pattern}`);
 }
 
 /**
@@ -525,18 +536,17 @@ function strWithRegExp(pattern: RegExp): StringParser<string> {
  * 
  * @public
 */
-export const char = createParser((input, index, _state) => {
+export const any = createParser((input, index, _state) => {
   if ((input.length - index) < 1) {
     return failure(index);
   }
   const value = input.charAt(index);
   return success(index + 1, value);
-}, 'char');
-
+}, 'any');
 
-export const cr = str('\r');
-export const lf = str('\n');
-export const crlf = str('\r\n');
+export const cr = token('\r');
+export const lf = token('\n');
+export const crlf = token('\r\n');
 
 /**
  * newline
diff --git a/src/token-parser.ts b/src/token-parsers.ts
similarity index 78%
rename from src/token-parser.ts
rename to src/token-parsers.ts
index 70716b7..bc7fc86 100644
--- a/src/token-parser.ts
+++ b/src/token-parsers.ts
@@ -1,11 +1,25 @@
-import { success, failure, Result } from './result.js';
+import {
+  Failure,
+  Result,
+  Success,
+  failure,
+  success,
+} from './result.js';
+
+export {
+  Failure,
+  Result,
+  Success,
+  failure,
+  success,
+};
 
 /**
  * Token Parser
  * 
  * @public
 */
-export class TokenParser<U> {
+export class Parser<U> {
   tag: string;
   ctx: ParserContext<U> | LazyContext<U>;
 
@@ -109,7 +123,7 @@ export class TokenParser<U> {
    * 
    * @public
   */
-  map<V>(fn: (value: U) => V): TokenParser<V> {
+  map<V>(fn: (value: U) => V): Parser<V> {
     return createParser((input, index, state) => {
       const result = this.exec(input, state, index);
       if (!result.success) {
@@ -124,14 +138,14 @@ export class TokenParser<U> {
    * 
    * @public
   */
-  many(min?: number, max?: number): TokenParser<U[]>
+  many(min?: number, max?: number): Parser<U[]>
   /**
    * Create a new parser that tries to apply the parser iteratively.
    * 
    * @public
   */
-  many(opts: { min?: number, max?: number, notMatch?: TokenParser<unknown> }): TokenParser<U[]>
-  many(arg1?: number | { min?: number, max?: number, notMatch?: TokenParser<unknown> }, arg2?: number): TokenParser<U[]> {
+  many(opts: { min?: number, max?: number, notMatch?: Parser<unknown> }): Parser<U[]>
+  many(arg1?: number | { min?: number, max?: number, notMatch?: Parser<unknown> }, arg2?: number): Parser<U[]> {
     if (typeof arg1 === 'number') {
       // with min, max
       return many(this, { min: arg1, max: arg2 });
@@ -148,7 +162,7 @@ export class TokenParser<U> {
    * 
    * @public
   */
-  option(): TokenParser<U | null> {
+  option(): Parser<U | null> {
     return alt([
       this,
       succeeded(null),
@@ -163,7 +177,7 @@ export class TokenParser<U> {
    * 
    * @public
   */
-  state(key: string, value: (state: any) => any): TokenParser<U> {
+  state(key: string, value: (state: any) => any): Parser<U> {
     return createParser((input, index, state) => {
       const storedValue = state[key];
       state[key] = value(state);
@@ -172,6 +186,23 @@ export class TokenParser<U> {
       return result;
     }, 'state');
   }
+
+  /**
+   * Create a new parser that wraps the current parser.
+   * The generated parser will return the span in the range matched by the inner parser.
+   * 
+   * @public
+  */
+  span(): Parser<string[]> {
+    return createParser((input, index, state) => {
+      const result = this.exec(input, state, index);
+      if (!result.success) {
+        return result;
+      }
+      const text = input.slice(index, result.index);
+      return success(result.index, text);
+    }, 'span');
+  }
 }
 
 /**
@@ -187,7 +218,7 @@ export type StrictParserOpts<U> = {
  * @internal
 */
 export type LazyParserOpts<U> = {
-  lazy: () => TokenParser<U>,
+  lazy: () => Parser<U>,
   tag?: string,
   handler?: undefined,
 };
@@ -212,7 +243,7 @@ export type ParserContext<U> = {
 */
 export type LazyContext<U> = {
   kind: 'lazy',
-  handler: () => TokenParser<U>,
+  handler: () => Parser<U>,
 };
 
 /**
@@ -220,7 +251,7 @@ export type LazyContext<U> = {
  * 
  * @internal
 */
-export type ResultType<U> = U extends TokenParser<infer R> ? R : never;
+export type ResultType<U> = U extends Parser<infer R> ? R : never;
 
 /**
  * Get result types of Parsers.
@@ -248,7 +279,7 @@ function wrapByTraceHandler<U>(handler: ParserHandler<U>, tag: string): ParserHa
   };
 }
 
-function many<U>(parser: TokenParser<U>, opts: { min?: number, max?: number, notMatch?: TokenParser<unknown> } = {}): TokenParser<U[]> {
+function many<U>(parser: Parser<U>, opts: { min?: number, max?: number, notMatch?: Parser<unknown> } = {}): Parser<U[]> {
   if (opts.notMatch != null) {
     return many(seq([
       notMatch(opts.notMatch),
@@ -282,19 +313,19 @@ function many<U>(parser: TokenParser<U>, opts: { min?: number, max?: number, not
  * 
  * @public
 */
-export function seq<U extends TokenParser<any>[]>(parsers: [...U]): TokenParser<ResultTypes<[...U]>>
+export function seq<U extends Parser<any>[]>(parsers: [...U]): Parser<ResultTypes<[...U]>>
 /**
  * Create a new parser that sequentially applies an array of parser.
  * 
  * @public
  * @param select - The index of the data returned in the result.
 */
-export function seq<U extends TokenParser<any>[], V extends number>(parsers: [...U], select: V): U[V]
-export function seq(parsers: TokenParser<any>[], select?: number) {
+export function seq<U extends Parser<any>[], V extends number>(parsers: [...U], select: V): U[V]
+export function seq(parsers: Parser<any>[], select?: number) {
   return (select == null) ? seqAll(parsers) : seqSelect(parsers, select);
 }
 
-function seqAll<U extends TokenParser<any>[]>(parsers: [...U]): TokenParser<ResultTypes<[...U]>> {
+function seqAll<U extends Parser<any>[]>(parsers: [...U]): Parser<ResultTypes<[...U]>> {
   return createParser((input, index, state) => {
     let result;
     let latestIndex = index;
@@ -311,7 +342,7 @@ function seqAll<U extends TokenParser<any>[]>(parsers: [...U]): TokenParser<Resu
   }, `seq length=${parsers.length}`);
 }
 
-function seqSelect<U extends TokenParser<any>[], V extends number>(parsers: [...U], select: V): U[V] {
+function seqSelect<U extends Parser<any>[], V extends number>(parsers: [...U], select: V): U[V] {
   return seqAll(parsers).map(values => values[select]);
 }
 
@@ -320,7 +351,7 @@ function seqSelect<U extends TokenParser<any>[], V extends number>(parsers: [...
  * 
  * @public
 */
-export function alt<U extends TokenParser<unknown>[]>(parsers: [...U]): TokenParser<ResultTypes<U>[number]> {
+export function alt<U extends Parser<unknown>[]>(parsers: [...U]): Parser<ResultTypes<U>[number]> {
   return createParser((input, index, state) => {
     let result;
     for (let i = 0; i < parsers.length; i++) {
@@ -338,8 +369,8 @@ export function alt<U extends TokenParser<unknown>[]>(parsers: [...U]): TokenPar
  * 
  * @public
 */
-function createParser<U>(handler: ParserHandler<U>, tag?: string): TokenParser<U> {
-  return new TokenParser({ handler, tag });
+function createParser<U>(handler: ParserHandler<U>, tag?: string): Parser<U> {
+  return new Parser({ handler, tag });
 }
 export { createParser as parser };
 
@@ -348,8 +379,8 @@ export { createParser as parser };
  * 
  * @public
 */
-export function lazy<U>(fn: () => TokenParser<U>, tag?: string): TokenParser<U> {
-  return new TokenParser({ lazy: fn, tag });
+export function lazy<U>(fn: () => Parser<U>, tag?: string): Parser<U> {
+  return new Parser({ lazy: fn, tag });
 }
 
 /**
@@ -357,7 +388,7 @@ export function lazy<U>(fn: () => TokenParser<U>, tag?: string): TokenParser<U>
  * 
  * @public
 */
-export function succeeded<U>(value: U): TokenParser<U> {
+export function succeeded<U>(value: U): Parser<U> {
   return createParser((_input, index, _state) => {
     return success(index, value);
   }, 'succeeded');
@@ -368,7 +399,7 @@ export function succeeded<U>(value: U): TokenParser<U> {
  * 
  * @public
 */
-export function match<U>(parser: TokenParser<U>): TokenParser<U> {
+export function match<U>(parser: Parser<U>): Parser<U> {
   return createParser((input, index, state) => {
     const result = parser.exec(input, state, index);
     return result.success
@@ -382,7 +413,7 @@ export function match<U>(parser: TokenParser<U>): TokenParser<U> {
  * 
  * @public
 */
-export function notMatch(parser: TokenParser<unknown>): TokenParser<null> {
+export function notMatch(parser: Parser<unknown>): Parser<null> {
   return createParser((input, index, state) => {
     const result = parser.exec(input, state, index);
     return !result.success
@@ -396,7 +427,7 @@ export function notMatch(parser: TokenParser<unknown>): TokenParser<null> {
  * 
  * @public
 */
-export function where<U>(condition: (state: any) => boolean, parser: TokenParser<U>): TokenParser<U> {
+export function where<U>(condition: (state: any) => boolean, parser: Parser<U>): Parser<U> {
   return createParser((input, index, state) => {
     return condition(state)
       ? parser.exec(input, state, index)
@@ -432,11 +463,11 @@ export const eof = createParser((input, index, _state) => {
  * @public
 */
 export function language<U extends Language<U>>(source: LanguageSource<U>): U {
-  const lang: Record<string, TokenParser<any>> = {};
+  const lang: Record<string, Parser<any>> = {};
   for (const key of Object.keys(source)) {
     lang[key] = lazy(() => {
       const parser = (source as any)[key](lang);
-      if (parser == null || !(parser instanceof TokenParser)) {
+      if (parser == null || !(parser instanceof Parser)) {
         throw new Error('syntax must return a Parser.');
       }
       parser.tag = `${parser.tag} key=${key}`;
@@ -451,7 +482,7 @@ export function language<U extends Language<U>>(source: LanguageSource<U>): U {
  * 
  * @public
 */
-export type Language<U> = {[K in keyof U]: U[K] extends TokenParser<unknown> ? U[K] : never };
+export type Language<U> = {[K in keyof U]: U[K] extends Parser<unknown> ? U[K] : never };
 
 /**
  * Language source
@@ -465,18 +496,18 @@ export type LanguageSource<U extends Language<U>> = { [K in keyof U]: (lang: U)
  * 
  * @public
 */
-export function token<U extends string>(value: U): TokenParser<U>
+export function token<U extends string>(value: U): Parser<U>
 /**
  * Create a new parser that matches the given regular expression.
  * 
  * @public
 */
-export function token(pattern: RegExp): TokenParser<string>
-export function token(value: string | RegExp): TokenParser<string> {
+export function token(pattern: RegExp): Parser<string>
+export function token(value: string | RegExp): Parser<string> {
   return (typeof value === 'string') ? tokenWithString(value) : tokenWithRegExp(value);
 }
 
-function tokenWithString<U extends string>(value: U): TokenParser<U> {
+function tokenWithString<U extends string>(value: U): Parser<U> {
   return createParser((input, index, _state) => {
     if (index >= input.length) {
       return failure(index);
@@ -485,10 +516,10 @@ function tokenWithString<U extends string>(value: U): TokenParser<U> {
       return failure(index);
     }
     return success(index + 1, value);
-  }, `str value=${value}`);
+  }, `token value=${value}`);
 }
 
-function tokenWithRegExp(pattern: RegExp): TokenParser<string> {
+function tokenWithRegExp(pattern: RegExp): Parser<string> {
   const re = RegExp(`^(?:${pattern.source})$`, pattern.flags);
   return createParser((input, index, _state) => {
     if (index >= input.length) {
@@ -499,9 +530,22 @@ function tokenWithRegExp(pattern: RegExp): TokenParser<string> {
       return failure(index);
     }
     return success(index + 1, result[0]);
-  }, `str pattern=${pattern}`);
+  }, `token pattern=${pattern}`);
 }
 
+/**
+ * any token
+ * 
+ * @public
+*/
+export const any = createParser((input, index, _state) => {
+  if ((input.length - index) < 1) {
+    return failure(index);
+  }
+  const value = input[index];
+  return success(index + 1, value);
+}, 'any');
+
 export const cr = token('\r');
 export const lf = token('\n');
 export const crlf = seq([cr, lf]);