Trait TokenFactory

pub trait TokenFactory<'a, TokenAndSpan, I>: Sized + PartialEq
where
    I: Tokens<TokenAndSpan>,
{
    type Lexer: Lexer<'a, TokenAndSpan>;
    type Buffer: Buffer<'a, I = I, Token = Self, TokenAndSpan = TokenAndSpan>;

    const FROM: Self;
    const FOR: Self;
    const INSTANCEOF: Self;
    const SATISFIES: Self;
    const THROW: Self;
    const AS: Self;
    const NAMESPACE: Self;
    const RETURN: Self;
    const AT: Self;
    const EXPORT: Self;
    const DECLARE: Self;
    const ASSERTS: Self;
    const ASSERT: Self;
    const JSX_TAG_END: Self;
    const JSX_TAG_START: Self;
    const DOLLAR_LBRACE: Self;
    const BACKQUOTE: Self;
    const HASH: Self;
    const IN: Self;
    const IS: Self;
    const CONST: Self;
    const DOT: Self;
    const TARGET: Self;
    const GET: Self;
    const SET: Self;
    const DOTDOTDOT: Self;
    const NULLISH_ASSIGN: Self;
    const NULLISH_COALESCING: Self;
    const QUESTION: Self;
    const COLON: Self;
    const COMMA: Self;
    const BIT_AND: Self;
    const BIT_AND_EQ: Self;
    const BIT_OR: Self;
    const BIT_OR_EQ: Self;
    const LOGICAL_AND: Self;
    const LOGICAL_AND_EQ: Self;
    const LOGICAL_OR: Self;
    const LOGICAL_OR_EQ: Self;
    const MUL: Self;
    const MUL_EQ: Self;
    const MOD: Self;
    const MOD_EQ: Self;
    const EXP: Self;
    const EXP_EQ: Self;
    const DIV: Self;
    const DIV_EQ: Self;
    const EQUAL: Self;
    const LSHIFT: Self;
    const LSHIFT_EQ: Self;
    const LESS: Self;
    const GLOBAL: Self;
    const LESS_EQ: Self;
    const RSHIFT: Self;
    const RSHIFT_EQ: Self;
    const GREATER: Self;
    const GREATER_EQ: Self;
    const ZERO_FILL_RSHIFT: Self;
    const ZERO_FILL_RSHIFT_EQ: Self;
    const NULL: Self;
    const ANY: Self;
    const BOOLEAN: Self;
    const BIGINT: Self;
    const NEVER: Self;
    const NUMBER: Self;
    const OBJECT: Self;
    const STRING: Self;
    const SYMBOL: Self;
    const UNKNOWN: Self;
    const UNDEFINED: Self;
    const INTRINSIC: Self;
    const TRUE: Self;
    const TRY: Self;
    const FALSE: Self;
    const ENUM: Self;
    const YIELD: Self;
    const LET: Self;
    const VAR: Self;
    const STATIC: Self;
    const IMPLEMENTS: Self;
    const INTERFACE: Self;
    const TYPE: Self;
    const PACKAGE: Self;
    const PRIVATE: Self;
    const PROTECTED: Self;
    const PUBLIC: Self;
    const READONLY: Self;
    const ARROW: Self;
    const REQUIRE: Self;
    const AWAIT: Self;
    const BREAK: Self;
    const CONTINUE: Self;
    const THIS: Self;
    const SUPER: Self;
    const WHILE: Self;
    const DO: Self;
    const LPAREN: Self;
    const RPAREN: Self;
    const LBRACKET: Self;
    const RBRACKET: Self;
    const LBRACE: Self;
    const FINALLY: Self;
    const CATCH: Self;
    const SWITCH: Self;
    const RBRACE: Self;
    const FUNCTION: Self;
    const IF: Self;
    const ELSE: Self;
    const CLASS: Self;
    const NEW: Self;
    const ABSTRACT: Self;
    const ACCESSOR: Self;
    const IMPORT: Self;
    const PLUS: Self;
    const MINUS: Self;
    const BANG: Self;
    const TILDE: Self;
    const PLUS_PLUS: Self;
    const MINUS_MINUS: Self;
    const DELETE: Self;
    const TYPEOF: Self;
    const VOID: Self;
    const EXTENDS: Self;
    const SEMI: Self;
    const OF: Self;
    const KEYOF: Self;
    const UNIQUE: Self;
    const INFER: Self;
    const USING: Self;
    const WITH: Self;
    const ASYNC: Self;
    const CASE: Self;
    const DEFAULT: Self;
    const DEBUGGER: Self;
    const EOF: Self;

    // Required methods
    fn jsx_name(name: &'a str, lexer: &mut Self::Lexer) -> Self;
    fn is_jsx_name(&self) -> bool;
    fn take_jsx_name(self, buffer: &mut Self::Buffer) -> Atom;
    fn str(value: Atom, raw: Atom, lexer: &mut Self::Lexer) -> Self;
    fn is_str(&self) -> bool;
    fn is_str_raw_content(&self, content: &str, buffer: &Self::Buffer) -> bool;
    fn take_str(self, buffer: &mut Self::Buffer) -> (Atom, Atom);
    fn template(
        cooked: Result<Atom, Error>,
        raw: Atom,
        lexer: &mut Self::Lexer,
    ) -> Self;
    fn is_template(&self) -> bool;
    fn take_template(
        self,
        buffer: &mut Self::Buffer,
    ) -> (Result<Atom, Error>, Atom);
    fn jsx_text(value: Atom, raw: Atom, lexer: &mut Self::Lexer) -> Self;
    fn is_jsx_text(&self) -> bool;
    fn take_jsx_text(self, buffer: &mut Self::Buffer) -> (Atom, Atom);
    fn regexp(content: Atom, flags: Atom, lexer: &mut Self::Lexer) -> Self;
    fn is_regexp(&self) -> bool;
    fn take_regexp(self, buffer: &mut Self::Buffer) -> (Atom, Atom);
    fn num(value: f64, raw: Atom, lexer: &mut Self::Lexer) -> Self;
    fn is_num(&self) -> bool;
    fn take_num(self, buffer: &mut Self::Buffer) -> (f64, Atom);
    fn bigint(value: Box<BigInt>, raw: Atom, lexer: &mut Self::Lexer) -> Self;
    fn is_bigint(&self) -> bool;
    fn take_bigint(self, buffer: &mut Self::Buffer) -> (Box<BigInt>, Atom);
    fn shebang(value: Atom, lexer: &mut Self::Lexer) -> Self;
    fn is_shebang(&self) -> bool;
    fn take_shebang(self, buffer: &mut Self::Buffer) -> Atom;
    fn unknown_ident(value: Atom, lexer: &mut Self::Lexer) -> Self;
    fn is_unknown_ident(&self) -> bool;
    fn take_unknown_ident(self, buffer: &mut Self::Buffer) -> Atom;
    fn take_unknown_ident_ref<'b>(
        &'b self,
        buffer: &'b Self::Buffer,
    ) -> &'b Atom;
    fn is_known_ident(&self) -> bool;
    fn take_known_ident(&self) -> Atom;
    fn starts_expr(&self) -> bool;
    fn to_string(&self, buffer: &Self::Buffer) -> String;
    fn is_error(&self) -> bool;
    fn take_error(self, buffer: &mut Self::Buffer) -> Error;
    fn is_word(&self) -> bool;
    fn take_word(self, buffer: &Self::Buffer) -> Option<Atom>;
    fn is_keyword(&self) -> bool;
    fn is_reserved(&self, ctx: Context) -> bool;
    fn into_atom(self, lexer: &mut Self::Lexer) -> Option<Atom>;
    fn follows_keyword_let(&self) -> bool;
    fn is_bin_op(&self) -> bool;
    fn as_bin_op(&self) -> Option<BinaryOp>;
    fn is_assign_op(&self) -> bool;
    fn as_assign_op(&self) -> Option<AssignOp>;
    fn is_no_substitution_template_literal(&self) -> bool;
    fn is_template_head(&self) -> bool;

    // Provided methods
    fn is_less(&self) -> bool { ... }
    fn is_less_eq(&self) -> bool { ... }
    fn is_greater(&self) -> bool { ... }
    fn is_colon(&self) -> bool { ... }
    fn is_comma(&self) -> bool { ... }
    fn is_equal(&self) -> bool { ... }
    fn is_question(&self) -> bool { ... }
    fn is_null(&self) -> bool { ... }
    fn is_lshift(&self) -> bool { ... }
    fn is_rshift(&self) -> bool { ... }
    fn is_rshift_eq(&self) -> bool { ... }
    fn is_greater_eq(&self) -> bool { ... }
    fn is_true(&self) -> bool { ... }
    fn is_false(&self) -> bool { ... }
    fn is_enum(&self) -> bool { ... }
    fn is_yield(&self) -> bool { ... }
    fn is_let(&self) -> bool { ... }
    fn is_var(&self) -> bool { ... }
    fn is_static(&self) -> bool { ... }
    fn is_extends(&self) -> bool { ... }
    fn is_implements(&self) -> bool { ... }
    fn is_interface(&self) -> bool { ... }
    fn is_type(&self) -> bool { ... }
    fn is_package(&self) -> bool { ... }
    fn is_private(&self) -> bool { ... }
    fn is_protected(&self) -> bool { ... }
    fn is_public(&self) -> bool { ... }
    fn is_readonly(&self) -> bool { ... }
    fn is_await(&self) -> bool { ... }
    fn is_break(&self) -> bool { ... }
    fn is_continue(&self) -> bool { ... }
    fn is_arrow(&self) -> bool { ... }
    fn is_this(&self) -> bool { ... }
    fn is_super(&self) -> bool { ... }
    fn is_using(&self) -> bool { ... }
    fn is_backquote(&self) -> bool { ... }
    fn is_lparen(&self) -> bool { ... }
    fn is_rparen(&self) -> bool { ... }
    fn is_lbracket(&self) -> bool { ... }
    fn is_rbracket(&self) -> bool { ... }
    fn is_lbrace(&self) -> bool { ... }
    fn is_rbrace(&self) -> bool { ... }
    fn is_function(&self) -> bool { ... }
    fn is_class(&self) -> bool { ... }
    fn is_if(&self) -> bool { ... }
    fn is_return(&self) -> bool { ... }
    fn is_switch(&self) -> bool { ... }
    fn is_throw(&self) -> bool { ... }
    fn is_catch(&self) -> bool { ... }
    fn is_finally(&self) -> bool { ... }
    fn is_try(&self) -> bool { ... }
    fn is_with(&self) -> bool { ... }
    fn is_while(&self) -> bool { ... }
    fn is_new(&self) -> bool { ... }
    fn is_ident_ref(&self, ctx: Context) -> bool { ... }
    fn is_import(&self) -> bool { ... }
    fn is_export(&self) -> bool { ... }
    fn is_dot(&self) -> bool { ... }
    fn is_do(&self) -> bool { ... }
    fn is_for(&self) -> bool { ... }
    fn is_from(&self) -> bool { ... }
    fn is_dotdotdot(&self) -> bool { ... }
    fn is_plus(&self) -> bool { ... }
    fn is_minus(&self) -> bool { ... }
    fn is_bang(&self) -> bool { ... }
    fn is_tilde(&self) -> bool { ... }
    fn is_plus_plus(&self) -> bool { ... }
    fn is_minus_minus(&self) -> bool { ... }
    fn is_delete(&self) -> bool { ... }
    fn is_typeof(&self) -> bool { ... }
    fn is_of(&self) -> bool { ... }
    fn is_void(&self) -> bool { ... }
    fn is_hash(&self) -> bool { ... }
    fn is_in(&self) -> bool { ... }
    fn is_const(&self) -> bool { ... }
    fn is_star(&self) -> bool { ... }
    fn is_mod(&self) -> bool { ... }
    fn is_semi(&self) -> bool { ... }
    fn is_slash(&self) -> bool { ... }
    fn is_slash_eq(&self) -> bool { ... }
    fn is_jsx_tag_start(&self) -> bool { ... }
    fn is_jsx_tag_end(&self) -> bool { ... }
    fn is_asserts(&self) -> bool { ... }
    fn is_is(&self) -> bool { ... }
    fn is_as(&self) -> bool { ... }
    fn is_satisfies(&self) -> bool { ... }
    fn is_instanceof(&self) -> bool { ... }
    fn is_async(&self) -> bool { ... }
    fn is_case(&self) -> bool { ... }
    fn is_default(&self) -> bool { ... }
    fn is_debugger(&self) -> bool { ... }
    fn is_bit_and(&self) -> bool { ... }
    fn is_bit_or(&self) -> bool { ... }
    fn is_exp(&self) -> bool { ... }
    fn is_eof(&self) -> bool { ... }
}

Required Associated Constants

const FROM: Self

const FOR: Self

const INSTANCEOF: Self

const SATISFIES: Self

const THROW: Self

const AS: Self

const NAMESPACE: Self

const RETURN: Self

const AT: Self

const EXPORT: Self

const DECLARE: Self

const ASSERTS: Self

const ASSERT: Self

const JSX_TAG_END: Self

const JSX_TAG_START: Self

const DOLLAR_LBRACE: Self

const BACKQUOTE: Self

const HASH: Self

const IN: Self

const IS: Self

const CONST: Self

const DOT: Self

const TARGET: Self

const GET: Self

const SET: Self

const DOTDOTDOT: Self

const NULLISH_ASSIGN: Self

const NULLISH_COALESCING: Self

const QUESTION: Self

const COLON: Self

const COMMA: Self

const BIT_AND: Self

const BIT_AND_EQ: Self

const BIT_OR: Self

const BIT_OR_EQ: Self

const LOGICAL_AND: Self

const LOGICAL_AND_EQ: Self

const LOGICAL_OR: Self

const LOGICAL_OR_EQ: Self

const MUL: Self

const MUL_EQ: Self

const MOD: Self

const MOD_EQ: Self

const EXP: Self

const EXP_EQ: Self

const DIV: Self

const DIV_EQ: Self

const EQUAL: Self

const LSHIFT: Self

const LSHIFT_EQ: Self

const LESS: Self

const GLOBAL: Self

const LESS_EQ: Self

const RSHIFT: Self

const RSHIFT_EQ: Self

const GREATER: Self

const GREATER_EQ: Self

const ZERO_FILL_RSHIFT: Self

const ZERO_FILL_RSHIFT_EQ: Self

const NULL: Self

const ANY: Self

const BOOLEAN: Self

const BIGINT: Self

const NEVER: Self

const NUMBER: Self

const OBJECT: Self

const STRING: Self

const SYMBOL: Self

const UNKNOWN: Self

const UNDEFINED: Self

const INTRINSIC: Self

const TRUE: Self

const TRY: Self

const FALSE: Self

const ENUM: Self

const YIELD: Self

const LET: Self

const VAR: Self

const STATIC: Self

const IMPLEMENTS: Self

const INTERFACE: Self

const TYPE: Self

const PACKAGE: Self

const PRIVATE: Self

const PROTECTED: Self

const PUBLIC: Self

const READONLY: Self

const ARROW: Self

const REQUIRE: Self

const AWAIT: Self

const BREAK: Self

const CONTINUE: Self

const THIS: Self

const SUPER: Self

const WHILE: Self

const DO: Self

const LPAREN: Self

const RPAREN: Self

const LBRACKET: Self

const RBRACKET: Self

const LBRACE: Self

const FINALLY: Self

const CATCH: Self

const SWITCH: Self

const RBRACE: Self

const FUNCTION: Self

const IF: Self

const ELSE: Self

const CLASS: Self

const NEW: Self

const ABSTRACT: Self

const ACCESSOR: Self

const IMPORT: Self

const PLUS: Self

const MINUS: Self

const BANG: Self

const TILDE: Self

const PLUS_PLUS: Self

const MINUS_MINUS: Self

const DELETE: Self

const TYPEOF: Self

const VOID: Self

const EXTENDS: Self

const SEMI: Self

const OF: Self

const KEYOF: Self

const UNIQUE: Self

const INFER: Self

const USING: Self

const WITH: Self

const ASYNC: Self

const CASE: Self

const DEFAULT: Self

const DEBUGGER: Self

const EOF: Self

Required Associated Types

type Lexer: Lexer<'a, TokenAndSpan>

type Buffer: Buffer<'a, I = I, Token = Self, TokenAndSpan = TokenAndSpan>

Required Methods

fn jsx_name(name: &'a str, lexer: &mut Self::Lexer) -> Self

fn is_jsx_name(&self) -> bool

fn take_jsx_name(self, buffer: &mut Self::Buffer) -> Atom

fn str(value: Atom, raw: Atom, lexer: &mut Self::Lexer) -> Self

fn is_str(&self) -> bool

fn is_str_raw_content(&self, content: &str, buffer: &Self::Buffer) -> bool

fn take_str(self, buffer: &mut Self::Buffer) -> (Atom, Atom)

fn template( cooked: Result<Atom, Error>, raw: Atom, lexer: &mut Self::Lexer, ) -> Self

fn is_template(&self) -> bool

fn take_template(self, buffer: &mut Self::Buffer) -> (Result<Atom, Error>, Atom)

fn jsx_text(value: Atom, raw: Atom, lexer: &mut Self::Lexer) -> Self

fn is_jsx_text(&self) -> bool

fn take_jsx_text(self, buffer: &mut Self::Buffer) -> (Atom, Atom)

fn regexp(content: Atom, flags: Atom, lexer: &mut Self::Lexer) -> Self

fn is_regexp(&self) -> bool

fn take_regexp(self, buffer: &mut Self::Buffer) -> (Atom, Atom)

fn num(value: f64, raw: Atom, lexer: &mut Self::Lexer) -> Self

fn is_num(&self) -> bool

fn take_num(self, buffer: &mut Self::Buffer) -> (f64, Atom)

fn bigint(value: Box<BigInt>, raw: Atom, lexer: &mut Self::Lexer) -> Self

fn is_bigint(&self) -> bool

fn take_bigint(self, buffer: &mut Self::Buffer) -> (Box<BigInt>, Atom)

fn shebang(value: Atom, lexer: &mut Self::Lexer) -> Self

fn is_shebang(&self) -> bool

fn take_shebang(self, buffer: &mut Self::Buffer) -> Atom

fn unknown_ident(value: Atom, lexer: &mut Self::Lexer) -> Self

fn is_unknown_ident(&self) -> bool

fn take_unknown_ident(self, buffer: &mut Self::Buffer) -> Atom

fn take_unknown_ident_ref<'b>(&'b self, buffer: &'b Self::Buffer) -> &'b Atom

fn is_known_ident(&self) -> bool

fn take_known_ident(&self) -> Atom

fn starts_expr(&self) -> bool

fn to_string(&self, buffer: &Self::Buffer) -> String

fn is_error(&self) -> bool

fn take_error(self, buffer: &mut Self::Buffer) -> Error

fn is_word(&self) -> bool

fn take_word(self, buffer: &Self::Buffer) -> Option<Atom>

fn is_keyword(&self) -> bool

fn is_reserved(&self, ctx: Context) -> bool

fn into_atom(self, lexer: &mut Self::Lexer) -> Option<Atom>

fn follows_keyword_let(&self) -> bool

fn is_bin_op(&self) -> bool

fn as_bin_op(&self) -> Option<BinaryOp>

fn is_assign_op(&self) -> bool

fn as_assign_op(&self) -> Option<AssignOp>

fn is_no_substitution_template_literal(&self) -> bool

fn is_template_head(&self) -> bool

Provided Methods

fn is_less(&self) -> bool

fn is_less_eq(&self) -> bool

fn is_greater(&self) -> bool

fn is_colon(&self) -> bool

fn is_comma(&self) -> bool

fn is_equal(&self) -> bool

fn is_question(&self) -> bool

fn is_null(&self) -> bool

fn is_lshift(&self) -> bool

fn is_rshift(&self) -> bool

fn is_rshift_eq(&self) -> bool

fn is_greater_eq(&self) -> bool

fn is_true(&self) -> bool

fn is_false(&self) -> bool

fn is_enum(&self) -> bool

fn is_yield(&self) -> bool

fn is_let(&self) -> bool

fn is_var(&self) -> bool

fn is_static(&self) -> bool

fn is_extends(&self) -> bool

fn is_implements(&self) -> bool

fn is_interface(&self) -> bool

fn is_type(&self) -> bool

fn is_package(&self) -> bool

fn is_private(&self) -> bool

fn is_protected(&self) -> bool

fn is_public(&self) -> bool

fn is_readonly(&self) -> bool

fn is_await(&self) -> bool

fn is_break(&self) -> bool

fn is_continue(&self) -> bool

fn is_arrow(&self) -> bool

fn is_this(&self) -> bool

fn is_super(&self) -> bool

fn is_using(&self) -> bool

fn is_backquote(&self) -> bool

fn is_lparen(&self) -> bool

fn is_rparen(&self) -> bool

fn is_lbracket(&self) -> bool

fn is_rbracket(&self) -> bool

fn is_lbrace(&self) -> bool

fn is_rbrace(&self) -> bool

fn is_function(&self) -> bool

fn is_class(&self) -> bool

fn is_if(&self) -> bool

fn is_return(&self) -> bool

fn is_switch(&self) -> bool

fn is_throw(&self) -> bool

fn is_catch(&self) -> bool

fn is_finally(&self) -> bool

fn is_try(&self) -> bool

fn is_with(&self) -> bool

fn is_while(&self) -> bool

fn is_new(&self) -> bool

fn is_ident_ref(&self, ctx: Context) -> bool

fn is_import(&self) -> bool

fn is_export(&self) -> bool

fn is_dot(&self) -> bool

fn is_do(&self) -> bool

fn is_for(&self) -> bool

fn is_from(&self) -> bool

fn is_dotdotdot(&self) -> bool

fn is_plus(&self) -> bool

fn is_minus(&self) -> bool

fn is_bang(&self) -> bool

fn is_tilde(&self) -> bool

fn is_plus_plus(&self) -> bool

fn is_minus_minus(&self) -> bool

fn is_delete(&self) -> bool

fn is_typeof(&self) -> bool

fn is_of(&self) -> bool

fn is_void(&self) -> bool

fn is_hash(&self) -> bool

fn is_in(&self) -> bool

fn is_const(&self) -> bool

fn is_star(&self) -> bool

fn is_mod(&self) -> bool

fn is_semi(&self) -> bool

fn is_slash(&self) -> bool

fn is_slash_eq(&self) -> bool

fn is_jsx_tag_start(&self) -> bool

fn is_jsx_tag_end(&self) -> bool

fn is_asserts(&self) -> bool

fn is_is(&self) -> bool

fn is_as(&self) -> bool

fn is_satisfies(&self) -> bool

fn is_instanceof(&self) -> bool

fn is_async(&self) -> bool

fn is_case(&self) -> bool

fn is_default(&self) -> bool

fn is_debugger(&self) -> bool

fn is_bit_and(&self) -> bool

fn is_bit_or(&self) -> bool

fn is_exp(&self) -> bool

fn is_eof(&self) -> bool

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, I> TokenFactory<'a, TokenAndSpan, I> for swc_ecma_parser::token::Token

where I: Tokens<TokenAndSpan>,

const ABSTRACT: Token

const ACCESSOR: Token

const ANY: Token

const ARROW: Token = Self::Arrow

const AS: Token

const ASSERT: Token

const ASSERTS: Token

const ASYNC: Token

const AT: Token = Self::At

const AWAIT: Token

const BACKQUOTE: Token = Self::BackQuote

const BANG: Token = Self::Bang

const BIGINT: Token

const BIT_AND: Token

const BIT_AND_EQ: Token

const BIT_OR: Token

const BIT_OR_EQ: Token

const BOOLEAN: Token

const BREAK: Token

const CASE: Token

const CATCH: Token

const CLASS: Token

const COLON: Token = Self::Colon

const COMMA: Token = Self::Comma

const CONST: Token

const CONTINUE: Token

const DEBUGGER: Token

const DECLARE: Token

const DEFAULT: Token

const DELETE: Token

const DIV: Token

const DIV_EQ: Token

const DO: Token

const DOLLAR_LBRACE: Token = Self::DollarLBrace

const DOT: Token = Self::Dot

const DOTDOTDOT: Token = Self::DotDotDot

const ELSE: Token

const ENUM: Token

const EOF: Token = Token::Eof

const EQUAL: Token

const EXP: Token

const EXPORT: Token

const EXP_EQ: Token

const EXTENDS: Token

const FALSE: Token

const FINALLY: Token

const FOR: Token

const FROM: Token

const FUNCTION: Token

const GET: Token

const GLOBAL: Token

const GREATER: Token

const GREATER_EQ: Token

const HASH: Token = Self::Hash

const IF: Token

const IMPLEMENTS: Token

const IMPORT: Token

const IN: Token

const INFER: Token

const INSTANCEOF: Token

const INTERFACE: Token

const INTRINSIC: Token

const IS: Token

const JSX_TAG_END: Token = Self::JSXTagEnd

const JSX_TAG_START: Token = Self::JSXTagStart

const KEYOF: Token

const LBRACE: Token = Self::LBrace

const LBRACKET: Token = Self::LBracket

const LESS: Token

const LESS_EQ: Token

const LET: Token

const LOGICAL_AND: Token

const LOGICAL_AND_EQ: Token

const LOGICAL_OR: Token

const LOGICAL_OR_EQ: Token

const LPAREN: Token = Self::LParen

const LSHIFT: Token

const LSHIFT_EQ: Token

const MINUS: Token

const MINUS_MINUS: Token = Self::MinusMinus

const MOD: Token

const MOD_EQ: Token

const MUL: Token

const MUL_EQ: Token

const NAMESPACE: Token

const NEVER: Token

const NEW: Token

const NULL: Token

const NULLISH_ASSIGN: Token

const NULLISH_COALESCING: Token

const NUMBER: Token

const OBJECT: Token

const OF: Token

const PACKAGE: Token

const PLUS: Token

const PLUS_PLUS: Token = Self::PlusPlus

const PRIVATE: Token

const PROTECTED: Token

const PUBLIC: Token

const QUESTION: Token = Token::QuestionMark

const RBRACE: Token = Self::RBrace

const RBRACKET: Token = Self::RBracket

const READONLY: Token

const REQUIRE: Token

const RETURN: Token

const RPAREN: Token = Self::RParen

const RSHIFT: Token

const RSHIFT_EQ: Token

const SATISFIES: Token

const SEMI: Token = Self::Semi

const SET: Token

const STATIC: Token

const STRING: Token

const SUPER: Token

const SWITCH: Token

const SYMBOL: Token

const TARGET: Token

const THIS: Token

const THROW: Token

const TILDE: Token = Self::Tilde

const TRUE: Token

const TRY: Token

const TYPE: Token

const TYPEOF: Token

const UNDEFINED: Token

const UNIQUE: Token

const UNKNOWN: Token

const USING: Token

const VAR: Token

const VOID: Token

const WHILE: Token

const WITH: Token

const YIELD: Token

const ZERO_FILL_RSHIFT: Token

const ZERO_FILL_RSHIFT_EQ: Token

type Buffer = Buffer<I>

type Lexer = Lexer<'a>

impl<'a, I: Tokens> TokenFactory<'a, TokenAndSpan, I> for swc_ecma_parser::unstable::Token

const ABSTRACT: Self = Token::Abstract

const ACCESSOR: Self = Token::Accessor

const ANY: Self = Token::Any

const ARROW: Self = Token::Arrow

const AS: Self = Token::As

const ASSERT: Self = Token::Assert

const ASSERTS: Self = Token::Asserts

const ASYNC: Self = Token::Async

const AT: Self = Token::At

const AWAIT: Self = Token::Await

const BACKQUOTE: Self = Token::BackQuote

const BANG: Self = Self::Bang

const BIGINT: Self = Token::Bigint

const BIT_AND: Self = Self::Ampersand

const BIT_AND_EQ: Self = Self::BitAndEq

const BIT_OR: Self = Self::Pipe

const BIT_OR_EQ: Self = Self::BitOrEq

const BOOLEAN: Self = Token::Boolean

const BREAK: Self = Token::Break

const CASE: Self = Token::Case

const CATCH: Self = Token::Catch

const CLASS: Self = Self::Class

const COLON: Self = Self::Colon

const COMMA: Self = Token::Comma

const CONST: Self = Self::Const

const CONTINUE: Self = Token::Continue

const DEBUGGER: Self = Token::Debugger

const DECLARE: Self = Token::Declare

const DEFAULT: Self = Token::Default

const DELETE: Self = Self::Delete

const DIV: Self = Token::Slash

const DIV_EQ: Self = Token::DivEq

const DO: Self = Token::Do

const DOLLAR_LBRACE: Self = Token::DollarLBrace

const DOT: Self = Self::Dot

const DOTDOTDOT: Self = Self::DotDotDot

const ELSE: Self = Self::Else

const ENUM: Self = Token::Enum

const EOF: Self = Token::Eof

const EQUAL: Self = Token::Eq

const EXP: Self = Token::Exp

const EXPORT: Self = Token::Export

const EXP_EQ: Self = Token::ExpEq

const EXTENDS: Self = Token::Extends

const FALSE: Self = Token::False

const FINALLY: Self = Token::Finally

const FOR: Self = Token::For

const FROM: Self = Token::From

const FUNCTION: Self = Self::Function

const GET: Self = Token::Get

const GLOBAL: Self = Token::Global

const GREATER: Self = Token::Gt

const GREATER_EQ: Self = Token::GtEq

const HASH: Self = Self::Hash

const IF: Self = Self::If

const IMPLEMENTS: Self = Token::Implements

const IMPORT: Self = Self::Import

const IN: Self = Self::In

const INFER: Self = Token::Infer

const INSTANCEOF: Self = Token::InstanceOf

const INTERFACE: Self = Token::Interface

const INTRINSIC: Self = Token::Intrinsic

const IS: Self = Token::Is

const JSX_TAG_END: Self = Token::JSXTagEnd

const JSX_TAG_START: Self = Token::JSXTagStart

const KEYOF: Self = Token::Keyof

const LBRACE: Self = Self::LBrace

const LBRACKET: Self = Self::LBracket

const LESS: Self = Token::Lt

const LESS_EQ: Self = Token::LtEq

const LET: Self = Token::Let

const LOGICAL_AND: Self = Token::LogicalAnd

const LOGICAL_AND_EQ: Self = Self::LogicalAndEq

const LOGICAL_OR: Self = Token::LogicalOr

const LOGICAL_OR_EQ: Self = Self::LogicalOrEq

const LPAREN: Self = Self::LParen

const LSHIFT: Self = Token::LShift

const LSHIFT_EQ: Self = Token::LShiftEq

const MINUS: Self = Self::Minus

const MINUS_MINUS: Self = Self::MinusMinus

const MOD: Self = Token::Percent

const MOD_EQ: Self = Token::ModEq

const MUL: Self = Token::Asterisk

const MUL_EQ: Self = Token::MulEq

const NAMESPACE: Self = Token::Namespace

const NEVER: Self = Token::Never

const NEW: Self = Self::New

const NULL: Self = Token::Null

const NULLISH_ASSIGN: Self = Token::NullishEq

const NULLISH_COALESCING: Self = Token::NullishCoalescing

const NUMBER: Self = Token::Number

const OBJECT: Self = Token::Object

const OF: Self = Token::Of

const PACKAGE: Self = Token::Package

const PLUS: Self = Self::Plus

const PLUS_PLUS: Self = Self::PlusPlus

const PRIVATE: Self = Token::Private

const PROTECTED: Self = Token::Protected

const PUBLIC: Self = Token::Public

const QUESTION: Self = Token::QuestionMark

const RBRACE: Self = Self::RBrace

const RBRACKET: Self = Self::RBracket

const READONLY: Self = Token::Readonly

const REQUIRE: Self = Token::Require

const RETURN: Self = Token::Return

const RPAREN: Self = Self::RParen

const RSHIFT: Self = Token::RShift

const RSHIFT_EQ: Self = Token::RShiftEq

const SATISFIES: Self = Token::Satisfies

const SEMI: Self = Token::Semi

const SET: Self = Token::Set

const STATIC: Self = Token::Static

const STRING: Self = Token::String

const SUPER: Self = Self::Super

const SWITCH: Self = Token::Switch

const SYMBOL: Self = Token::Symbol

const TARGET: Self = Token::Target

const THIS: Self = Token::This

const THROW: Self = Token::Throw

const TILDE: Self = Self::Tilde

const TRUE: Self = Token::True

const TRY: Self = Token::Try

const TYPE: Self = Token::Type

const TYPEOF: Self = Self::TypeOf

const UNDEFINED: Self = Token::Undefined

const UNIQUE: Self = Token::Unique

const UNKNOWN: Self = Token::Unknown

const USING: Self = Self::Using

const VAR: Self = Self::Var

const VOID: Self = Self::Void

const WHILE: Self = Token::While

const WITH: Self = Token::With

const YIELD: Self = Token::Yield

const ZERO_FILL_RSHIFT: Self = Token::ZeroFillRShift

const ZERO_FILL_RSHIFT_EQ: Self = Token::ZeroFillRShiftEq

type Buffer = Buffer<I>

type Lexer = Lexer<'a>