ometa KParser <: Parser {
    fromTo :x :y    = seq(x) (~seq(y) char)* seq(y),
    
    space           = ^space | fromTo('//', '\n') | fromTo('/*', '*/'),
    
    typeFirst       = upper,
    typeRest        = typeFirst | lower | digit,
    
    typeName        = firstAndRest(#typeFirst, #typeRest):r
                      -> [#typeName, r.join('')],
    
    nameFirst       = lower,
    nameRest        = nameFirst | upper | digit | '_',
    iName           = firstAndRest(#nameFirst, #nameRest):r     -> r.join(''),
    isKeyword :x    = ?KParser._isKeyword(x),
    
    name            = iName:n ~isKeyword(n)                     -> [#name, n],
    keyword         = iName:k isKeyword(k)                      -> [k, k],
    
    hexDigit        = char:x {KParser.hexDigits.indexOf(x.toLowerCase(x))}:v ?(v >= 0)
                      -> v,
    hexLit          = hexLit:l hexDigit:d                       -> ((l * 16) + d)
                    | hexDigit:d,
    number          = ``0x'' hexLit:l                           -> [#number, l]
                    | digit+:ds
                      -> [#number, parseFloat(ds.join(''))],
    
    escapeChar      = '\\' char:c                               -> unescape('\\' + c),
    str             = seq('"""') (escapeChar | ~seq('"""') char)*:cs seq('"""')
                      -> [#string, cs.join('')]
                    | '\'' (escapeChar | ~'\'' char)*:cs
                      -> [#string, cs.join('')]
                    | '"' (escapeChar | ~'"' char)*:cs '"'
                      -> [#string, cs.join('')],
    
    special         = ( '(' | ')' | '{' | '}' |
                        ``::'' | ';' | ',' | '=' ):s            -> [s, s],
    
    tok             = spaces (typeName | name | keyword | number | str | special),
    toks            = token*:ts spaces end                      -> ts,
    token :tt       = tok:t ?(t[0] == tt)                       -> t[1],
    
    alloc           = "new" "typeName":t "(" ")"                -> [#alloc, t],
    
    expr            = alloc | "name" | "number" | "string",
    
    block           = "{" stmt*:ss "}"                          -> [#block, ss],
    
    init            = "name":n ("=" expr:e                      -> [#init, n, e]
                               | empty                          -> [#init, n]
                               ),
    dynInit         = "name":n "=" expr:e                       -> [#dynInit, n, e],
    decl            = "var" listOf(#dynInit, ","):is ?(is.length > 0)
                      -> [#decl, 'var', is]
                    | "typeName":t listOf(#init, ","):is ?(is.length > 0)
                      -> [#decl, t, is],
                    
    stmt            = expr:e ";"                                -> [#exprs, e]
                    | decl:d ";"                                -> [#decls].concat(d)
                    | "if" "(" expr:e ")" block:b               -> [#if, e, b]
                    | "while" "(" expr:e ")" block:b            -> [#while, e, b]
                    | "do" block:b "while" "(" expr:e ")" ";"   -> [#doWhile, b, e]
                    | "for" "(" "var" "name":n "in" expr:e ")" block:b
                      -> [#forEach, n, e, b]
                    | "for" "(" expr:i ";" expr:g ";" expr:c ")" block:b
                      -> [#for, i, g, c, b]
                    | "with" "(" decl:d ")" block:b             -> [#with, d, b]
                    | "using" listOf(#name, "::"):ns ";"        -> [#using].concat(ns)
                    | "break" ";"                               -> [#break]
                    | "continue" ";"                            -> [#continue]
}

KParser.hexDigits = '0123456789abcdef';
KParser.keywords = {};
keywords = [
    'new', 'var', 'if', 'while', 'do', 'for', 'in', 'with', 'using', 'break',
    'continue'
];
for (var i = 0; i < keywords.length; i++) {
	KParser.keywords[keywords[i]] = true;
}
KParser._isKeyword = function (name) {
	return this.keywords.hasOwnProperty(name);
};

KParser.matchAll(' new Classe()', 'expr');