    {-# LANGUAGE CPP, DeriveDataTypeable #-}
    -----------------------------------------------------------------------------
    -- |
    -- Module      : Language.Python.Common.Token
    -- Copyright   : (c) 2009 Bernie Pope
    -- License     : BSD-style
    -- Maintainer  : bjpop@csse.unimelb.edu.au
    -- Stability   : experimental
    -- Portability : ghc
    --
    -- Lexical tokens for the Python lexer. Contains the superset of tokens from
    -- version 2 and version 3 of Python (they are mostly the same).
    -----------------------------------------------------------------------------

    module Language.JavaScript.Parser.Token
        (
          -- * The tokens
          Token (..)
        , CommentAnnotation (..)
        -- * String conversion
        , debugTokenString
        -- * Classification
        -- TokenClass (..),
        ) where

    import Data.Data
    import Language.JavaScript.Parser.SrcLocation

    data CommentAnnotation
        = CommentA TokenPosn String
        | WhiteSpace TokenPosn String
        | NoComment
        deriving (CommentAnnotation -> CommentAnnotation -> Bool
    (CommentAnnotation -> CommentAnnotation -> Bool)
    -> (CommentAnnotation -> CommentAnnotation -> Bool)
    -> Eq CommentAnnotation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CommentAnnotation -> CommentAnnotation -> Bool
    == :: CommentAnnotation -> CommentAnnotation -> Bool
    $c/= :: CommentAnnotation -> CommentAnnotation -> Bool
    /= :: CommentAnnotation -> CommentAnnotation -> Bool
    Eq, Int -> CommentAnnotation -> ShowS
    [CommentAnnotation] -> ShowS
    CommentAnnotation -> String
    (Int -> CommentAnnotation -> ShowS)
    -> (CommentAnnotation -> String)
    -> ([CommentAnnotation] -> ShowS)
    -> Show CommentAnnotation
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CommentAnnotation -> ShowS
    showsPrec :: Int -> CommentAnnotation -> ShowS
    $cshow :: CommentAnnotation -> String
    show :: CommentAnnotation -> String
    $cshowList :: [CommentAnnotation] -> ShowS
    showList :: [CommentAnnotation] -> ShowS
    Show, Typeable, Typeable CommentAnnotation
    Typeable CommentAnnotation =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> CommentAnnotation
     -> c CommentAnnotation)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c CommentAnnotation)
    -> (CommentAnnotation -> Constr)
    -> (CommentAnnotation -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c CommentAnnotation))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c CommentAnnotation))
    -> ((forall b. Data b => b -> b)
        -> CommentAnnotation -> CommentAnnotation)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> CommentAnnotation -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> CommentAnnotation -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> CommentAnnotation -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> CommentAnnotation -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> CommentAnnotation -> m CommentAnnotation)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> CommentAnnotation -> m CommentAnnotation)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> CommentAnnotation -> m CommentAnnotation)
    -> Data CommentAnnotation
    CommentAnnotation -> Constr
    CommentAnnotation -> DataType
    (forall b. Data b => b -> b)
    -> CommentAnnotation -> CommentAnnotation
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> CommentAnnotation -> u
    forall u. (forall d. Data d => d -> u) -> CommentAnnotation -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CommentAnnotation -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CommentAnnotation -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CommentAnnotation -> m CommentAnnotation
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommentAnnotation -> m CommentAnnotation
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CommentAnnotation
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CommentAnnotation -> c CommentAnnotation
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CommentAnnotation)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CommentAnnotation)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CommentAnnotation -> c CommentAnnotation
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CommentAnnotation -> c CommentAnnotation
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CommentAnnotation
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CommentAnnotation
    $ctoConstr :: CommentAnnotation -> Constr
    toConstr :: CommentAnnotation -> Constr
    $cdataTypeOf :: CommentAnnotation -> DataType
    dataTypeOf :: CommentAnnotation -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CommentAnnotation)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CommentAnnotation)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CommentAnnotation)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CommentAnnotation)
    $cgmapT :: (forall b. Data b => b -> b)
    -> CommentAnnotation -> CommentAnnotation
    gmapT :: (forall b. Data b => b -> b)
    -> CommentAnnotation -> CommentAnnotation
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CommentAnnotation -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CommentAnnotation -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CommentAnnotation -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CommentAnnotation -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> CommentAnnotation -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> CommentAnnotation -> [u]
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> CommentAnnotation -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> CommentAnnotation -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CommentAnnotation -> m CommentAnnotation
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CommentAnnotation -> m CommentAnnotation
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommentAnnotation -> m CommentAnnotation
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommentAnnotation -> m CommentAnnotation
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommentAnnotation -> m CommentAnnotation
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommentAnnotation -> m CommentAnnotation
    Data, ReadPrec [CommentAnnotation]
    ReadPrec CommentAnnotation
    Int -> ReadS CommentAnnotation
    ReadS [CommentAnnotation]
    (Int -> ReadS CommentAnnotation)
    -> ReadS [CommentAnnotation]
    -> ReadPrec CommentAnnotation
    -> ReadPrec [CommentAnnotation]
    -> Read CommentAnnotation
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS CommentAnnotation
    readsPrec :: Int -> ReadS CommentAnnotation
    $creadList :: ReadS [CommentAnnotation]
    readList :: ReadS [CommentAnnotation]
    $creadPrec :: ReadPrec CommentAnnotation
    readPrec :: ReadPrec CommentAnnotation
    $creadListPrec :: ReadPrec [CommentAnnotation]
    readListPrec :: ReadPrec [CommentAnnotation]
    Read)

    -- | Lexical tokens.
    -- Each may be annotated with any comment occurring between the prior token and this one
    data Token
        -- Comment
        = CommentToken { Token -> TokenPosn
    tokenSpan :: !TokenPosn, Token -> String
    tokenLiteral :: !String, Token -> [CommentAnnotation]
    tokenComment :: ![CommentAnnotation] } -- ^ Single line comment.
        | WsToken      { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation] } -- ^ White space, for preservation.

        -- Identifiers
        | IdentifierToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }    -- ^ Identifier.

        -- Javascript Literals

        | DecimalToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]   }
        -- ^ Literal: Decimal
        | HexIntegerToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]   }
        -- ^ Literal: Hexadecimal Integer
        | OctalToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]   }
        -- ^ Literal: Octal Integer
        | StringToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        -- ^ Literal: string, delimited by either single or double quotes
        | RegExToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]   }
        -- ^ Literal: Regular Expression

        -- Keywords
        | AsyncToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | AwaitToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | BreakToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | CaseToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | CatchToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ClassToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ConstToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | LetToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ContinueToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | DebuggerToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | DefaultToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | DeleteToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | DoToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ElseToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | EnumToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ExtendsToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | FalseToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | FinallyToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ForToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | FunctionToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | FromToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | IfToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | InToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | InstanceofToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | NewToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | NullToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | OfToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ReturnToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | StaticToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | SuperToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | SwitchToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ThisToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ThrowToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | TrueToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | TryToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | TypeofToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | VarToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | VoidToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | WhileToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | YieldToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ImportToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | WithToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | ExportToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        -- Future reserved words
        | FutureToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        -- Needed, not sure what they are though.
        | GetToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | SetToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }

        -- Delimiters
        -- Operators
        | AutoSemiToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | SemiColonToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | CommaToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | HookToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | ColonToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | OrToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | AndToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | BitwiseOrToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | BitwiseXorToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | BitwiseAndToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | StrictEqToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | EqToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | TimesAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | DivideAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | ModAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | PlusAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | MinusAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | LshAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | RshAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | UrshAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | AndAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | XorAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | OrAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | SimpleAssignToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | StrictNeToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | NeToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | LshToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | LeToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | LtToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | UrshToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | RshToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | GeToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | GtToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | IncrementToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | DecrementToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | PlusToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | MinusToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | MulToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | DivToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | ModToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | NotToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | BitwiseNotToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | ArrowToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | SpreadToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | DotToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | LeftBracketToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | RightBracketToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | LeftCurlyToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | RightCurlyToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | LeftParenToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | RightParenToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
        | CondcommentEndToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }

        -- Template literal lexical components
        | NoSubstitutionTemplateToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | TemplateHeadToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | TemplateMiddleToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | TemplateTailToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }

        -- Special cases
        | AsToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
        | TailToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  } -- ^ Stuff between last JS and EOF
        | EOFToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }  -- ^ End of file
        deriving (Token -> Token -> Bool
    (Token -> Token -> Bool) -> (Token -> Token -> Bool) -> Eq Token
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Token -> Token -> Bool
    == :: Token -> Token -> Bool
    $c/= :: Token -> Token -> Bool
    /= :: Token -> Token -> Bool
    Eq, Int -> Token -> ShowS
    [Token] -> ShowS
    Token -> String
    (Int -> Token -> ShowS)
    -> (Token -> String) -> ([Token] -> ShowS) -> Show Token
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Token -> ShowS
    showsPrec :: Int -> Token -> ShowS
    $cshow :: Token -> String
    show :: Token -> String
    $cshowList :: [Token] -> ShowS
    showList :: [Token] -> ShowS
    Show, Typeable)

    -- | Produce a string from a token containing detailed information. Mainly intended for debugging.
    debugTokenString :: Token -> String
    debugTokenString :: Token -> String
    debugTokenString = (Char -> Bool) -> ShowS
    forall a. (a -> Bool) -> [a] -> [a]
    takeWhile (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Char
    ' ') ShowS -> (Token -> String) -> Token -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Token -> String
    forall a. Show a => a -> String
    show