jseption 0.0.2 → 0.0.4

package/dist/parser.js

@@ -10,7 +10,8 @@
  * ("phase 2": resolve_variables) and a label resolution / peephole pass
  * ("phase 3": resolve_labels).
  */
-import { JS_ATOM_NULL, JS_EXCEPTION, JS_IsException, JSFunctionBytecode, JSVarDef, JSClosureVar, JS_MODE_STRICT, JS_MODE_BACKTRACE_BARRIER, JS_EVAL_TYPE_GLOBAL, JS_EVAL_TYPE_MODULE, JS_EVAL_TYPE_DIRECT, JS_EVAL_TYPE_INDIRECT, JS_EVAL_TYPE_MASK, JS_EVAL_FLAG_STRICT, JS_EVAL_FLAG_COMPILE_ONLY, JS_EVAL_FLAG_BACKTRACE_BARRIER, JS_EVAL_FLAG_ASYNC, JS_NewAtom, JS_AtomToString, JS_AtomGetStr, JS_ThrowSyntaxError, JS_ThrowError2, JS_Throw, JS_NewErrorNative, JS_DefinePropertyValue, JS_PROP_WRITABLE, JS_PROP_CONFIGURABLE, JS_SetErrorBacktraceDone, JS_ATOM_stack, JS_ATOM_lineNumber, JS_ATOM_columnNumber, JS_ATOM_fileName, hooks, JS_Call, JS_ATOM_empty_string, JS_ATOM_arguments, JS_ATOM_eval, JS_ATOM_this, JS_ATOM_new_target, JS_ATOM_home_object, JS_ATOM_this_active_func, JS_ATOM__eval_, JS_ATOM__ret_, JS_ATOM__var_, JS_ATOM__arg_var_, JS_ATOM_length, JS_ATOM_prototype, JS_ATOM_constructor, JS_ATOM_get, JS_ATOM_set, JS_ATOM_of, JS_ATOM___proto__, JS_ATOM_let, JS_ATOM_yield, JS_ATOM_await, JS_ATOM_async, JS_ATOM_static, JS_ATOM_target, JS_ATOM_meta, JS_ATOM_undefined, JS_ATOM_class_fields_init, JS_ATOM_computed_field, JS_ATOM_hash_constructor, JS_ATOM_raw, JS_ATOM_implements, JS_ATOM_null, JS_ATOM_default, JS_ATOM_function, JS_ATOM_done, JS_ATOM_value, JS_NewArray, JS_DefinePropertyValueUint32, JS_PROP_ENUMERABLE, JS_GetFunctionData, __JS_AtomIsTaggedInt, __JS_AtomFromUInt32, JS_GetException, JS_ATOM_super, JS_ATOM__with_, JS_ATOM_return, JS_ATOM__default_, } from "./quickjs.js";
+import { JS_ATOM_NULL, JS_EXCEPTION, JS_IsException, JSFunctionBytecode, JSVarDef, JSClosureVar, JS_MODE_STRICT, JS_MODE_BACKTRACE_BARRIER, JS_EVAL_TYPE_GLOBAL, JS_EVAL_TYPE_MODULE, JS_EVAL_TYPE_DIRECT, JS_EVAL_TYPE_INDIRECT, JS_EVAL_TYPE_MASK, JS_EVAL_FLAG_STRICT, JS_EVAL_FLAG_COMPILE_ONLY, JS_EVAL_FLAG_BACKTRACE_BARRIER, JS_EVAL_FLAG_ASYNC, JS_EVAL_FLAG_STRIP_TYPES, JS_EVAL_FLAG_JSX, JS_NewAtom, JS_AtomToString, JS_AtomGetStr, JS_ThrowSyntaxError, JS_ThrowError2, JS_Throw, JS_NewErrorNative, JS_DefinePropertyValue, JS_PROP_WRITABLE, JS_PROP_CONFIGURABLE, JS_SetErrorBacktraceDone, JS_ATOM_stack, JS_ATOM_lineNumber, JS_ATOM_columnNumber, JS_ATOM_fileName, hooks, JS_Call, JS_ATOM_empty_string, JS_ATOM_arguments, JS_ATOM_eval, JS_ATOM_this, JS_ATOM_new_target, JS_ATOM_home_object, JS_ATOM_this_active_func, JS_ATOM__eval_, JS_ATOM__ret_, JS_ATOM__var_, JS_ATOM__arg_var_, JS_ATOM_length, JS_ATOM_prototype, JS_ATOM_constructor, JS_ATOM_get, JS_ATOM_set, JS_ATOM_of, JS_ATOM___proto__, JS_ATOM_let, JS_ATOM_yield, JS_ATOM_await, JS_ATOM_async, JS_ATOM_static, JS_ATOM_as, JS_ATOM_from, JS_ATOM_target, JS_ATOM_meta, JS_ATOM_undefined, JS_ATOM_class_fields_init, JS_ATOM_computed_field, JS_ATOM_hash_constructor, JS_ATOM_raw, JS_ATOM_implements, JS_ATOM_interface, JS_ATOM_private, JS_ATOM_protected, JS_ATOM_public, JS_ATOM_global, JS_ATOM_null, JS_ATOM_default, JS_ATOM_function, JS_ATOM_done, JS_ATOM_value, JS_NewArray, JS_DefinePropertyValueUint32, JS_PROP_ENUMERABLE, JS_GetFunctionData, __JS_AtomIsTaggedInt, __JS_AtomFromUInt32, JS_GetException, JS_HasException, JS_ATOM_super, JS_ATOM__with_, JS_ATOM_return, JS_ATOM__default_, JS_ATOM__star_, } from "./quickjs.js";
+import { JSModuleDef, JSReqModuleEntry, JSExportEntry, JSStarExportEntry, JSImportEntry } from "./values.js";
 import { opcode_info, short_opcode_info, OP_DEFINE_METHOD_METHOD, OP_DEFINE_METHOD_GETTER, OP_DEFINE_METHOD_ENUMERABLE, JS_DEFINE_CLASS_HAS_HERITAGE, JS_THROW_VAR_RO, JS_THROW_VAR_REDECL, JS_THROW_ERROR_DELETE_SUPER, JS_THROW_ERROR_ITERATOR_THROW, DEFINE_GLOBAL_LEX_VAR, DEFINE_GLOBAL_FUNC_VAR, get_u8, get_i8, get_u16, get_i16, get_u32, get_i32, put_u8, put_u16, put_u32 } from "./opcodes.js";
 const TOK_FIRST_KEYWORD = -85 /* TOK.NULL */;
 const TOK_LAST_KEYWORD = -40 /* TOK.AWAIT */;
@@ -224,6 +225,13 @@ export class JSParseState {
     is_module = false; /* parsing a module */
     allow_html_comments = false;
     ext_json = false; /* true if accepting JSON superset */
+    /* TypeScript type stripping (JS_EVAL_FLAG_STRIP_TYPES) */
+    ts = false;
+    ts_cond_true = false; /* parsing the true branch of a conditional expression (arrow return type rule) */
+    ts_atoms = null;
+    /* JSX (JS_EVAL_FLAG_JSX) */
+    jsx = false;
+    jsx_runtime = null; /* decided at the first element */
     /* line/col cache */
     line_num = 1;
     /* used for error reporting: position of the last token start */
@@ -1556,62 +1564,2058 @@ function js_parse_skip_parens_token(s, pbits, no_line_terminator) {
                 break;
             case -86 /* TOK.EOF */:
                 break outer;
+            case 60: /* < */
+                if (s.jsx && is_regexp_allowed(last_tok) && jsx_try_skip(s)) {
+                    /* a JSX element */
+                    last_tok = 41;
+                    continue;
+                }
+                break;
             case 59: /* ; */
                 if (level === 2)
                     bits |= SKIP_HAS_SEMI;
                 break;
-            case -91 /* TOK.ELLIPSIS */:
-                if (level === 2)
-                    bits |= SKIP_HAS_ELLIPSIS;
+            case -91 /* TOK.ELLIPSIS */:
+                if (level === 2)
+                    bits |= SKIP_HAS_ELLIPSIS;
+                break;
+            case 61: /* = */
+                bits |= SKIP_HAS_ASSIGNMENT;
+                break;
+            case -122 /* TOK.DIV_ASSIGN */:
+            case 47: /* / */
+                if (is_regexp_allowed(last_tok)) {
+                    s.buf_ptr = s.token.ptr + 1;
+                    if (js_parse_regexp(s)) {
+                        /* clear the exception generated by js_parse_regexp */
+                        JS_GetException(s.ctx);
+                        break outer;
+                    }
+                }
+                break;
+        }
+        /* last_tok is only used to recognize regexps */
+        if (tv(s) === -125 /* TOK.IDENT */ && (token_is_pseudo_keyword(s, JS_ATOM_of) || token_is_pseudo_keyword(s, JS_ATOM_yield))) {
+            last_tok = -39 /* TOK.OF */;
+        }
+        else {
+            last_tok = tv(s);
+        }
+        const last_token_ptr = s.token.ptr;
+        if (next_token(s)) {
+            /* clear the exception generated by next_token() */
+            JS_GetException(s.ctx);
+            break;
+        }
+        if (level <= 1) {
+            tok = tv(s);
+            if (token_is_pseudo_keyword(s, JS_ATOM_of))
+                tok = -39 /* TOK.OF */;
+            if (no_line_terminator && has_lf_in_range(s, last_token_ptr, s.token.ptr))
+                tok = 10;
+            break;
+        }
+    }
+    if (pbits)
+        pbits.bits = bits;
+    /* restore the parser state */
+    Object.assign(s.token, pos.token);
+    s.buf_ptr = saved_ptr;
+    s.got_lf = saved_got_lf;
+    return tok;
+}
+const SKIP_HAS_SEMI = 1 << 0;
+const SKIP_HAS_ELLIPSIS = 1 << 1;
+const SKIP_HAS_ASSIGNMENT = 1 << 2;
+/* ---------------------------------------------------------------------
+   TypeScript type stripping (JS_EVAL_FLAG_STRIP_TYPES)
+
+   Node's strip-only mode: the erasable TypeScript syntax (annotations,
+   type declarations, generics, assertions, modifiers, overload
+   signatures...) is consumed at the token level and never reaches the
+   bytecode emitter, so the program compiles to exactly the bytecode of
+   the JavaScript obtained by replacing the types with spaces, with the
+   same source positions for errors, stacks and line tables. Constructs
+   that need code generation (enum, namespaces with values, parameter
+   properties, import =, export =) are rejected with a SyntaxError.
+
+   The ts_skip_* functions consume tokens and return true, or false on a
+   token they cannot accept (a lexer error leaves an exception pending).
+   They never emit bytecode, so they also run speculatively: ts_save and
+   ts_restore rewind the lexer and drop any pending exception.
+   See docs/TYPESCRIPT.md for the grammar and the ambiguity rules.
+   --------------------------------------------------------------------- */
+class TSAtoms {
+    type;
+    declare;
+    abstract;
+    readonly;
+    namespace;
+    module;
+    keyof;
+    infer;
+    is;
+    asserts;
+    satisfies;
+    override;
+    unique;
+    out;
+    assert;
+    with_;
+    constructor(ctx) {
+        const a = (n) => JS_NewAtom(ctx, n);
+        this.type = a('type');
+        this.declare = a('declare');
+        this.abstract = a('abstract');
+        this.readonly = a('readonly');
+        this.namespace = a('namespace');
+        this.module = a('module');
+        this.keyof = a('keyof');
+        this.infer = a('infer');
+        this.is = a('is');
+        this.asserts = a('asserts');
+        this.satisfies = a('satisfies');
+        this.override = a('override');
+        this.unique = a('unique');
+        this.out = a('out');
+        this.assert = a('assert');
+        this.with_ = a('with');
+    }
+}
+function ts_atoms(s) {
+    return s.ts_atoms ?? (s.ts_atoms = new TSAtoms(s.ctx));
+}
+/* the current token is the identifier or keyword `atom`, written without escapes */
+function ts_word(s, atom) {
+    return s.token.atom === atom && !s.token.has_escape &&
+        (tv(s) === -125 /* TOK.IDENT */ || (tv(s) >= TOK_FIRST_KEYWORD && tv(s) <= TOK_LAST_KEYWORD));
+}
+function ts_is_keyword(t) { return t >= TOK_FIRST_KEYWORD && t <= TOK_LAST_KEYWORD; }
+function ts_next(s) { return next_token(s) === 0; }
+function ts_save(s) {
+    const t = new JSToken();
+    Object.assign(t, s.token);
+    return { token: t, buf_ptr: s.buf_ptr, got_lf: s.got_lf, last_ptr: s.last_ptr };
+}
+function ts_restore(s, p) {
+    Object.assign(s.token, p.token);
+    s.buf_ptr = p.buf_ptr;
+    s.got_lf = p.got_lf;
+    s.last_ptr = p.last_ptr;
+    if (JS_HasException(s.ctx))
+        JS_GetException(s.ctx);
+}
+function ts_peek(s) {
+    const p = ts_save(s);
+    const r = ts_next(s) ? { val: tv(s), atom: s.token.atom, lf: s.got_lf, escape: s.token.has_escape }
+        : { val: -88 /* TOK.ERROR */, atom: JS_ATOM_NULL, lf: false, escape: false };
+    ts_restore(s, p);
+    return r;
+}
+function ts_peek_is_name(s) {
+    const n = ts_peek(s);
+    return !n.lf && (n.val === -125 /* TOK.IDENT */ || ts_is_keyword(n.val));
+}
+/* a skipper failed: report it unless the lexer already did */
+function ts_error(s, msg) {
+    if (JS_HasException(s.ctx))
+        return -1;
+    return js_parse_error(s, msg);
+}
+/* Node's ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX */
+function ts_unsupported(s, what, pos) {
+    return js_parse_error_pos(s, pos, `TypeScript ${what} is not supported in strip-only mode`);
+}
+/* '<' opening a type argument or parameter list ('<<' is split) */
+function ts_eat_lt(s) {
+    if (tv(s) === 60)
+        return ts_next(s);
+    if (tv(s) === -106 /* TOK.SHL */) {
+        s.buf_ptr = s.token.ptr + 1;
+        return ts_next(s);
+    }
+    return false;
+}
+function ts_is_gt(t) {
+    return t === 62 || t === -105 /* TOK.SAR */ || t === -104 /* TOK.SHR */ || t === -100 /* TOK.GTE */ || t === -117 /* TOK.SAR_ASSIGN */ || t === -116 /* TOK.SHR_ASSIGN */;
+}
+/* '>' closing a type list: '>>', '>>>', '>=', ... are split and the rest rescanned */
+function ts_eat_gt(s) {
+    if (tv(s) === 62)
+        return ts_next(s);
+    if (!ts_is_gt(tv(s)))
+        return false;
+    s.buf_ptr = s.token.ptr + 1;
+    return ts_next(s);
+}
+/* skip a balanced (...), [...], {...} or template literal, regexps, nested templates and JSX
+   elements included; the token after it becomes current, or with lex_next false the position is
+   just after its closing character. `info.ellipsis` records a '...' directly inside */
+function ts_skip_balanced(s, lex_next = true, info = null) {
+    const stack = [];
+    let last_tok = 0;
+    for (;;) {
+        const t = tv(s);
+        switch (t) {
+            case 60:
+                if (s.jsx && is_regexp_allowed(last_tok) && jsx_try_skip(s)) {
+                    last_tok = 41; /* an operand */
+                    continue;
+                }
+                break;
+            case -91 /* TOK.ELLIPSIS */:
+                if (info !== null && stack.length === 1)
+                    info.ellipsis = true;
+                break;
+            case 40:
+            case 91:
+            case 123:
+                stack.push(t);
+                break;
+            case 41:
+                if (stack.pop() !== 40)
+                    return false;
+                break;
+            case 93:
+                if (stack.pop() !== 91)
+                    return false;
+                break;
+            case 125: {
+                const c = stack.pop();
+                if (c === 96) {
+                    /* end of a template substitution: continue the template */
+                    s.got_lf = false;
+                    if (js_parse_template_part(s, s.buf_ptr))
+                        return false;
+                    if (s.token.sep !== 96)
+                        stack.push(96);
+                }
+                else if (c !== 123) {
+                    return false;
+                }
+                break;
+            }
+            case -126 /* TOK.TEMPLATE */:
+                if (s.token.sep !== 96)
+                    stack.push(96);
+                break;
+            case -86 /* TOK.EOF */:
+                return false;
+            case -122 /* TOK.DIV_ASSIGN */:
+            case 47:
+                if (is_regexp_allowed(last_tok)) {
+                    s.buf_ptr = s.token.ptr + 1;
+                    if (js_parse_regexp(s))
+                        return false;
+                }
+                break;
+        }
+        last_tok = tv(s);
+        if (stack.length === 0)
+            return lex_next ? ts_next(s) : true;
+        if (!ts_next(s))
+            return false;
+    }
+}
+const TS_NO_COND = 1; /* conditional types are not allowed (the extends clause of a conditional type) */
+/* Type: function type, constructor type, or a union with an optional conditional part */
+function ts_skip_type(s, flags = 0) {
+    const A = ts_atoms(s);
+    if (tv(s) === 60) {
+        /* generic function type: <T>(x: T) => T */
+        return ts_skip_type_params(s) && ts_skip_fn_type_rest(s);
+    }
+    if (ts_word(s, A.abstract) && ts_peek(s).val === -74 /* TOK.NEW */) {
+        if (!ts_next(s))
+            return false;
+    }
+    if (tv(s) === -74 /* TOK.NEW */) {
+        if (!ts_next(s))
+            return false;
+        if (tv(s) === 60 && !ts_skip_type_params(s))
+            return false;
+        return ts_skip_fn_type_rest(s);
+    }
+    if (tv(s) === 40) {
+        /* function type, or a parenthesized type */
+        const p = ts_save(s);
+        if (ts_skip_balanced(s) && tv(s) === -92 /* TOK.ARROW */)
+            return ts_next(s) && ts_skip_return_type(s);
+        ts_restore(s, p);
+    }
+    if (!ts_skip_union(s, flags))
+        return false;
+    if (!(flags & TS_NO_COND) && tv(s) === -52 /* TOK.EXTENDS */ && !s.got_lf) {
+        /* conditional type: C extends E ? T : F */
+        if (!ts_next(s) || !ts_skip_type(s, TS_NO_COND))
+            return false;
+        if (tv(s) !== 63 || !ts_next(s) || !ts_skip_type(s))
+            return false;
+        if (tv(s) !== 58 || !ts_next(s))
+            return false;
+        return ts_skip_type(s);
+    }
+    return true;
+}
+/* '(' parameters ')' '=>' return type */
+function ts_skip_fn_type_rest(s) {
+    if (tv(s) !== 40 || !ts_skip_balanced(s))
+        return false;
+    if (tv(s) !== -92 /* TOK.ARROW */ || !ts_next(s))
+        return false;
+    return ts_skip_return_type(s);
+}
+function ts_skip_union(s, flags) {
+    if (tv(s) === 124 && !ts_next(s))
+        return false;
+    if (!ts_skip_intersection(s, flags))
+        return false;
+    while (tv(s) === 124) {
+        if (!ts_next(s) || !ts_skip_intersection(s, flags))
+            return false;
+    }
+    return true;
+}
+function ts_skip_intersection(s, flags) {
+    if (tv(s) === 38 && !ts_next(s))
+        return false;
+    if (!ts_skip_type_operator(s, flags))
+        return false;
+    while (tv(s) === 38) {
+        if (!ts_next(s) || !ts_skip_type_operator(s, flags))
+            return false;
+    }
+    return true;
+}
+/* the next token can start the operand of a type operator */
+function ts_peek_starts_type(s) {
+    const n = ts_peek(s);
+    switch (n.val) {
+        case 44:
+        case 62:
+        case 41:
+        case 93:
+        case 125:
+        case 59:
+        case 61:
+        case 124:
+        case 38:
+        case 46:
+        case 63:
+        case 58:
+        case -86 /* TOK.EOF */:
+        case -92 /* TOK.ARROW */:
+        case -52 /* TOK.EXTENDS */:
+        case -88 /* TOK.ERROR */:
+        case -105 /* TOK.SAR */:
+        case -104 /* TOK.SHR */:
+        case -100 /* TOK.GTE */:
+            return false;
+    }
+    return true;
+}
+function ts_skip_type_operator(s, flags) {
+    const A = ts_atoms(s);
+    if ((ts_word(s, A.keyof) || ts_word(s, A.unique) || ts_word(s, A.readonly)) && ts_peek_starts_type(s)) {
+        return ts_next(s) && ts_skip_type_operator(s, flags);
+    }
+    if (ts_word(s, A.infer) && ts_peek_is_name(s)) {
+        if (!ts_next(s) || !ts_next(s))
+            return false;
+        if (tv(s) === -52 /* TOK.EXTENDS */ && !s.got_lf) {
+            /* `infer U extends C`: a constraint, unless it reads as a conditional type */
+            const p = ts_save(s);
+            if (!(ts_next(s) && ts_skip_type(s, TS_NO_COND) && ((flags & TS_NO_COND) || tv(s) !== 63)))
+                ts_restore(s, p);
+        }
+        return true;
+    }
+    return ts_skip_postfix_type(s);
+}
+function ts_skip_postfix_type(s) {
+    if (!ts_skip_primary_type(s))
+        return false;
+    while (tv(s) === 91 && !s.got_lf) {
+        /* T[] or T[K] */
+        if (!ts_next(s))
+            return false;
+        if (tv(s) === 93) {
+            if (!ts_next(s))
+                return false;
+            continue;
+        }
+        if (!ts_skip_type(s) || tv(s) !== 93 || !ts_next(s))
+            return false;
+    }
+    return true;
+}
+/* identifiers and the keywords that name types */
+function ts_is_type_name(t) {
+    return t === -125 /* TOK.IDENT */ || t === -76 /* TOK.VOID */ || t === -85 /* TOK.NULL */ || t === -78 /* TOK.THIS */ || t === -83 /* TOK.TRUE */ || t === -84 /* TOK.FALSE */ ||
+        t === -47 /* TOK.LET */ || t === -41 /* TOK.YIELD */ || t === -40 /* TOK.AWAIT */ || t === -42 /* TOK.STATIC */ || t === -49 /* TOK.IMPLEMENTS */ ||
+        t === -48 /* TOK.INTERFACE */ || t === -46 /* TOK.PACKAGE */ || t === -45 /* TOK.PRIVATE */ || t === -44 /* TOK.PROTECTED */ || t === -43 /* TOK.PUBLIC */;
+}
+function ts_skip_primary_type(s) {
+    switch (tv(s)) {
+        case 40: /* ( type ) */
+            if (!ts_next(s) || !ts_skip_type(s))
+                return false;
+            return tv(s) === 41 && ts_next(s);
+        case 91: /* tuple */
+        case 123: /* object type, mapped type */
+        case -126 /* TOK.TEMPLATE */: /* template literal type */
+            return ts_skip_balanced(s);
+        case -127 /* TOK.STRING */:
+        case -128 /* TOK.NUMBER */:
+            return ts_next(s);
+        case 45: /* negative number literal type */
+            return ts_next(s) && tv(s) === -128 /* TOK.NUMBER */ && ts_next(s);
+        case -75 /* TOK.TYPEOF */:
+            if (!ts_next(s))
+                return false;
+            if (tv(s) === -51 /* TOK.IMPORT */)
+                return ts_skip_import_type(s);
+            if (!(ts_is_type_name(tv(s)) || ts_is_keyword(tv(s))) || !ts_skip_entity_name(s))
+                return false;
+            if ((tv(s) === 60 || tv(s) === -106 /* TOK.SHL */) && !s.got_lf)
+                return ts_skip_type_args(s);
+            return true;
+        case -51 /* TOK.IMPORT */:
+            return ts_skip_import_type(s);
+    }
+    if (!ts_is_type_name(tv(s)) || !ts_skip_entity_name(s))
+        return false;
+    if ((tv(s) === 60 || tv(s) === -106 /* TOK.SHL */) && !s.got_lf)
+        return ts_skip_type_args(s);
+    return true;
+}
+/* A.B.C */
+function ts_skip_entity_name(s) {
+    if (!ts_next(s))
+        return false;
+    while (tv(s) === 46) {
+        if (!ts_next(s))
+            return false;
+        if (!token_is_ident_or_keyword(tv(s)) && tv(s) !== -87 /* TOK.PRIVATE_NAME */)
+            return false;
+        if (!ts_next(s))
+            return false;
+    }
+    return true;
+}
+/* import("m").T<A> */
+function ts_skip_import_type(s) {
+    if (!ts_next(s) || tv(s) !== 40 || !ts_skip_balanced(s))
+        return false;
+    while (tv(s) === 46) {
+        if (!ts_next(s) || !token_is_ident_or_keyword(tv(s)) || !ts_next(s))
+            return false;
+    }
+    if ((tv(s) === 60 || tv(s) === -106 /* TOK.SHL */) && !s.got_lf)
+        return ts_skip_type_args(s);
+    return true;
+}
+/* <T, U> after a type name or in an expression */
+function ts_skip_type_args(s) {
+    if (!ts_eat_lt(s))
+        return false;
+    for (;;) {
+        if (!ts_skip_type(s))
+            return false;
+        if (tv(s) !== 44)
+            return ts_eat_gt(s);
+        if (!ts_next(s))
+            return false;
+    }
+}
+/* <const T extends C = D, in out U> */
+function ts_skip_type_params(s) {
+    if (!ts_eat_lt(s))
+        return false;
+    const A = ts_atoms(s);
+    while (!ts_is_gt(tv(s))) {
+        while ((tv(s) === -55 /* TOK.CONST */ || tv(s) === -73 /* TOK.IN */ || ts_word(s, A.out)) && ts_peek_is_name(s)) {
+            if (!ts_next(s))
+                return false;
+        }
+        if (!token_is_ident(tv(s)) || !ts_next(s))
+            return false;
+        if (tv(s) === -52 /* TOK.EXTENDS */ && !(ts_next(s) && ts_skip_type(s)))
+            return false;
+        if (tv(s) === 61 && !(ts_next(s) && ts_skip_type(s)))
+            return false;
+        if (tv(s) !== 44)
+            break;
+        if (!ts_next(s))
+            return false;
+    }
+    return ts_eat_gt(s);
+}
+/* a return type, type predicates included: `x is T`, `asserts x`, `asserts x is T`, `this is T` */
+function ts_skip_return_type(s) {
+    const A = ts_atoms(s);
+    if (ts_word(s, A.asserts)) {
+        const p = ts_save(s);
+        if (ts_next(s) && !s.got_lf && (tv(s) === -125 /* TOK.IDENT */ || tv(s) === -78 /* TOK.THIS */)) {
+            if (!ts_next(s))
+                return false;
+            if (ts_word(s, A.is) && !s.got_lf)
+                return ts_next(s) && ts_skip_type(s);
+            return true;
+        }
+        ts_restore(s, p);
+    }
+    if (tv(s) === -125 /* TOK.IDENT */ || tv(s) === -78 /* TOK.THIS */) {
+        const p = ts_save(s);
+        if (ts_next(s) && ts_word(s, A.is) && !s.got_lf)
+            return ts_next(s) && ts_skip_type(s);
+        ts_restore(s, p);
+    }
+    return ts_skip_type(s);
+}
+/* ': Type' (the current token is ':'), in the parser's convention: 0 or -1 */
+function ts_parse_annotation(s) {
+    if (!ts_next(s) || !ts_skip_type(s))
+        return ts_error(s, 'type expected');
+    return 0;
+}
+/* --- expressions --- */
+function ts_is_binary_operator(s) {
+    switch (tv(s)) {
+        case 42:
+        case 47:
+        case 37:
+        case -93 /* TOK.POW */:
+        case -106 /* TOK.SHL */:
+        case -105 /* TOK.SAR */:
+        case -104 /* TOK.SHR */:
+        case -102 /* TOK.LTE */:
+        case -100 /* TOK.GTE */:
+        case -72 /* TOK.INSTANCEOF */:
+        case -73 /* TOK.IN */:
+        case -99 /* TOK.EQ */:
+        case -97 /* TOK.NEQ */:
+        case -98 /* TOK.STRICT_EQ */:
+        case -96 /* TOK.STRICT_NEQ */:
+        case 38:
+        case 94:
+        case 124:
+        case -95 /* TOK.LAND */:
+        case -94 /* TOK.LOR */:
+        case -90 /* TOK.DOUBLE_QUESTION_MARK */:
+            return true;
+    }
+    return ts_word(s, JS_ATOM_as) || ts_word(s, ts_atoms(s).satisfies);
+}
+function ts_is_start_of_expression(s) {
+    switch (tv(s)) {
+        case -128 /* TOK.NUMBER */:
+        case -127 /* TOK.STRING */:
+        case -126 /* TOK.TEMPLATE */:
+        case -125 /* TOK.IDENT */:
+        case -87 /* TOK.PRIVATE_NAME */:
+        case 40:
+        case 91:
+        case 123:
+        case 47:
+        case -122 /* TOK.DIV_ASSIGN */:
+        case 43:
+        case 45:
+        case 33:
+        case 126:
+        case 60:
+        case 64:
+        case -107 /* TOK.INC */:
+        case -108 /* TOK.DEC */:
+        case -78 /* TOK.THIS */:
+        case -50 /* TOK.SUPER */:
+        case -85 /* TOK.NULL */:
+        case -83 /* TOK.TRUE */:
+        case -84 /* TOK.FALSE */:
+        case -59 /* TOK.FUNCTION */:
+        case -56 /* TOK.CLASS */:
+        case -74 /* TOK.NEW */:
+        case -75 /* TOK.TYPEOF */:
+        case -76 /* TOK.VOID */:
+        case -77 /* TOK.DELETE */:
+        case -40 /* TOK.AWAIT */:
+        case -41 /* TOK.YIELD */:
+        case -51 /* TOK.IMPORT */:
+        case -47 /* TOK.LET */:
+        case -42 /* TOK.STATIC */:
+        case -49 /* TOK.IMPLEMENTS */:
+        case -48 /* TOK.INTERFACE */:
+        case -46 /* TOK.PACKAGE */:
+        case -45 /* TOK.PRIVATE */:
+        case -44 /* TOK.PROTECTED */:
+        case -43 /* TOK.PUBLIC */:
+            return true;
+    }
+    return false;
+}
+/* TypeScript's canFollowTypeArgumentsInExpression */
+function ts_can_follow_type_args(s) {
+    switch (tv(s)) {
+        case 40:
+        case -126 /* TOK.TEMPLATE */:
+            return true;
+        case 60:
+        case 62:
+        case 43:
+        case 45:
+            return false;
+    }
+    return s.got_lf || ts_is_binary_operator(s) || !ts_is_start_of_expression(s);
+}
+/* f<T>(x), new C<T>(), f<T>`t`, f<T>: type arguments in an expression, speculatively. As in
+   TypeScript (reScanGreaterToken), the closing '>' must not be the start of '>=' or '>>':
+   `a < b >= c` and `a < b >> c` are comparisons */
+function ts_try_expr_type_args(s) {
+    const p = ts_save(s);
+    if (ts_eat_lt(s)) {
+        for (;;) {
+            if (!ts_skip_type(s))
+                break;
+            if (tv(s) === 44) {
+                if (!ts_next(s))
+                    break;
+                continue;
+            }
+            if (tv(s) === 62 && ts_next(s) && ts_can_follow_type_args(s))
+                return true;
+            break;
+        }
+    }
+    ts_restore(s, p);
+    return false;
+}
+/* `as T`, `as const`, `satisfies T` after an operand: 1 if one was skipped, 0 if none, -1 on error */
+function ts_parse_as_expr(s) {
+    if (s.got_lf || !(ts_word(s, JS_ATOM_as) || ts_word(s, ts_atoms(s).satisfies)))
+        return 0;
+    if (next_token(s))
+        return -1;
+    if (tv(s) === -55 /* TOK.CONST */)
+        return next_token(s) ? -1 : 1;
+    if (!ts_skip_type(s))
+        return ts_error(s, 'type expected');
+    return 1;
+}
+/* skip an assignment expression approximately: stop before ',' ';' ')' ']' '}' or a ':'
+   that does not close a '?' at depth 0 */
+function ts_skip_expr_tokens(s) {
+    let pending = 0, n = 0, last_tok = 0;
+    for (;;) {
+        const t = tv(s);
+        switch (t) {
+            case 44:
+            case 59:
+            case 41:
+            case 93:
+            case 125:
+            case -86 /* TOK.EOF */:
+                return n > 0;
+            case 58:
+                if (pending === 0)
+                    return n > 0;
+                pending--;
+                break;
+            case 63:
+                pending++;
+                break;
+            case 40:
+            case 91:
+            case 123:
+            case -126 /* TOK.TEMPLATE */:
+                if (!ts_skip_balanced(s))
+                    return false;
+                last_tok = t === 40 ? 41 : t === 91 ? 93 : t === 123 ? 125 : -126 /* TOK.TEMPLATE */;
+                n++;
+                continue;
+            case 47:
+            case -122 /* TOK.DIV_ASSIGN */:
+                if (is_regexp_allowed(last_tok)) {
+                    s.buf_ptr = s.token.ptr + 1;
+                    if (js_parse_regexp(s))
+                        return false;
+                }
+                break;
+        }
+        last_tok = tv(s);
+        n++;
+        if (!ts_next(s))
+            return false;
+    }
+}
+/* after the parameters of an arrow function candidate: ': ReturnType =>' or '=>'. In the true
+   branch of a conditional expression, an arrow function with a return type must be followed by
+   the conditional's ':' (TypeScript's allowReturnTypeInArrowFunction rule) */
+function ts_arrow_rest_ahead(s) {
+    if (tv(s) === -92 /* TOK.ARROW */)
+        return !s.got_lf;
+    if (tv(s) !== 58 || !ts_next(s) || !ts_skip_return_type(s))
+        return false;
+    if (tv(s) !== -92 /* TOK.ARROW */ || s.got_lf)
+        return false;
+    if (!s.ts_cond_true)
+        return true;
+    if (!ts_next(s))
+        return false;
+    if (tv(s) === 123 ? !ts_skip_balanced(s) : !ts_skip_expr_tokens(s))
+        return false;
+    return tv(s) === 58;
+}
+/* '(' starts an arrow function whose parameters are followed by a return type */
+function ts_arrow_with_return_type_ahead(s) {
+    const p = ts_save(s);
+    const ok = ts_skip_balanced(s) && ts_arrow_rest_ahead(s);
+    ts_restore(s, p);
+    return ok;
+}
+/* '<' starts a generic arrow function: <T>(x: T) => x. In a .tsx file, TypeScript decides from the
+   first tokens: `<T,`, `<T =` and `<T extends U` (U not '=', '>' or '/') start a generic arrow
+   function, anything else is JSX */
+function ts_generic_arrow_ahead(s) {
+    if (s.jsx)
+        return tsx_generic_arrow_ahead(s);
+    const p = ts_save(s);
+    const ok = ts_skip_type_params(s) && tv(s) === 40 && ts_skip_balanced(s) && ts_arrow_rest_ahead(s);
+    ts_restore(s, p);
+    return ok;
+}
+function tsx_generic_arrow_ahead(s) {
+    const p = ts_save(s);
+    let ok = false;
+    if (ts_next(s) && (token_is_ident(tv(s)) || tv(s) === -55 /* TOK.CONST */) && (tv(s) !== -55 /* TOK.CONST */ || ts_next(s)) && ts_next(s)) {
+        if (tv(s) === -52 /* TOK.EXTENDS */)
+            ok = ts_next(s) && tv(s) !== 61 && !ts_is_gt(tv(s)) && tv(s) !== 47;
+        else
+            ok = tv(s) === 44 || tv(s) === 61;
+    }
+    ts_restore(s, p);
+    return ok;
+}
+/* '(' starts the parameter list of an arrow function */
+function js_arrow_ahead(s) {
+    const tok = js_parse_skip_parens_token(s, null, true);
+    return tok === -92 /* TOK.ARROW */ || (tok === 58 && s.ts && ts_arrow_with_return_type_ahead(s));
+}
+/* --- declarations and statements --- */
+/* ';' or automatic semicolon insertion, without reporting */
+function ts_skip_semi(s) {
+    if (tv(s) === 59)
+        return ts_next(s);
+    return tv(s) === -86 /* TOK.EOF */ || tv(s) === 125 || s.got_lf;
+}
+/* interface I<T> extends A, B<C> { ... } */
+function ts_skip_interface(s) {
+    if (!ts_next(s) || !token_is_ident(tv(s)) || !ts_next(s))
+        return false;
+    if (tv(s) === 60 && !ts_skip_type_params(s))
+        return false;
+    if (tv(s) === -52 /* TOK.EXTENDS */) {
+        do {
+            if (!ts_next(s) || !ts_skip_type(s))
+                return false;
+        } while (tv(s) === 44);
+    }
+    return tv(s) === 123 && ts_skip_balanced(s);
+}
+/* type A<T> = Type */
+function ts_skip_type_alias(s) {
+    if (!ts_next(s) || !token_is_ident(tv(s)) || !ts_next(s))
+        return false;
+    if (tv(s) === 60 && !ts_skip_type_params(s))
+        return false;
+    return tv(s) === 61 && ts_next(s) && ts_skip_type(s) && ts_skip_semi(s);
+}
+/* the rest of a variable declaration list without code: names, annotations, initializers */
+function ts_skip_var_list(s) {
+    for (;;) {
+        if (tv(s) === 91 || tv(s) === 123) {
+            if (!ts_skip_balanced(s))
+                return false;
+        }
+        else if (!token_is_ident(tv(s)) || !ts_next(s)) {
+            return false;
+        }
+        if (tv(s) === 33 && !ts_next(s))
+            return false;
+        if (tv(s) === 58 && !(ts_next(s) && ts_skip_type(s)))
+            return false;
+        if (tv(s) === 61 && !(ts_next(s) && ts_skip_expr_tokens(s)))
+            return false;
+        if (tv(s) !== 44)
+            return ts_skip_semi(s);
+        if (!ts_next(s))
+            return false;
+    }
+}
+/* function f<T>(params): R  (no body: overload signature or ambient function) */
+function ts_skip_function_signature(s) {
+    if (ts_word(s, JS_ATOM_async) && !ts_next(s))
+        return false;
+    if (tv(s) !== -59 /* TOK.FUNCTION */ || !ts_next(s))
+        return false;
+    if (tv(s) === 42 && !ts_next(s))
+        return false;
+    if ((tv(s) === -125 /* TOK.IDENT */ || ts_is_keyword(tv(s))) && tv(s) !== -52 /* TOK.EXTENDS */ && !ts_next(s))
+        return false;
+    if (tv(s) === 60 && !ts_skip_type_params(s))
+        return false;
+    if (tv(s) !== 40 || !ts_skip_balanced(s))
+        return false;
+    if (tv(s) === 58 && !(ts_next(s) && ts_skip_return_type(s)))
+        return false;
+    return true;
+}
+/* class C<T> extends B<T> implements I { ... } without code (ambient class) */
+function ts_skip_class_decl(s) {
+    if (!ts_next(s))
+        return false;
+    while (tv(s) !== 123) {
+        if (tv(s) === -86 /* TOK.EOF */)
+            return false;
+        if (tv(s) === 60) {
+            if (!ts_skip_type_args(s))
+                return false;
+        }
+        else if (tv(s) === 40 || tv(s) === 91) {
+            if (!ts_skip_balanced(s))
+                return false;
+        }
+        else if (!ts_next(s)) {
+            return false;
+        }
+    }
+    return ts_skip_balanced(s);
+}
+/* namespace A.B { ... }, module "m" { ... }, global { ... }; `module "m";` */
+function ts_skip_ambient_module(s) {
+    if (!ts_next(s))
+        return false;
+    if (tv(s) === -127 /* TOK.STRING */) {
+        if (!ts_next(s))
+            return false;
+    }
+    else if (token_is_ident(tv(s))) {
+        if (!ts_next(s))
+            return false;
+        while (tv(s) === 46) {
+            if (!ts_next(s) || !token_is_ident_or_keyword(tv(s)) || !ts_next(s))
+                return false;
+        }
+    }
+    if (tv(s) === 123)
+        return ts_skip_balanced(s);
+    return ts_skip_semi(s);
+}
+function ts_statement_kind(s) {
+    const A = ts_atoms(s);
+    const t = tv(s);
+    if (t === -54 /* TOK.ENUM */)
+        return 6 /* TSStmt.ENUM */;
+    if (t === -55 /* TOK.CONST */)
+        return ts_peek(s).val === -54 /* TOK.ENUM */ ? 6 /* TSStmt.ENUM */ : 0 /* TSStmt.NONE */;
+    if (t === -59 /* TOK.FUNCTION */)
+        return 10 /* TSStmt.FUNCTION */;
+    if (t === -51 /* TOK.IMPORT */) {
+        const n = ts_peek(s);
+        if (n.val === 40 || n.val === 46)
+            return 0 /* TSStmt.NONE */;
+        if (n.atom === A.type && !n.escape)
+            return 7 /* TSStmt.IMPORT_TYPE */;
+        if (n.val === -125 /* TOK.IDENT */) {
+            /* import x = ... */
+            const p = ts_save(s);
+            const eq = ts_next(s) && ts_next(s) && tv(s) === 61;
+            ts_restore(s, p);
+            if (eq)
+                return 8 /* TSStmt.IMPORT_EQUALS */;
+        }
+        return 0 /* TSStmt.NONE */;
+    }
+    if (t === -53 /* TOK.EXPORT */)
+        return 9 /* TSStmt.EXPORT */;
+    if (t !== -125 /* TOK.IDENT */ && !ts_is_keyword(t))
+        return 0 /* TSStmt.NONE */;
+    if (s.token.has_escape)
+        return 0 /* TSStmt.NONE */;
+    const atom = s.token.atom;
+    if (atom === JS_ATOM_async)
+        return ts_peek(s).val === -59 /* TOK.FUNCTION */ ? 10 /* TSStmt.FUNCTION */ : 0 /* TSStmt.NONE */;
+    if (atom !== JS_ATOM_interface && atom !== A.type && atom !== A.declare && atom !== A.abstract &&
+        atom !== A.namespace && atom !== A.module)
+        return 0 /* TSStmt.NONE */;
+    const n = ts_peek(s);
+    if (n.lf)
+        return 0 /* TSStmt.NONE */;
+    const name_next = n.val === -125 /* TOK.IDENT */ || (ts_is_keyword(n.val) && n.val !== -73 /* TOK.IN */ && n.val !== -72 /* TOK.INSTANCEOF */);
+    if (atom === JS_ATOM_interface)
+        return name_next ? 1 /* TSStmt.INTERFACE */ : 0 /* TSStmt.NONE */;
+    if (atom === A.type)
+        return token_is_ident(n.val) ? 2 /* TSStmt.TYPE */ : 0 /* TSStmt.NONE */;
+    if (atom === A.abstract)
+        return n.val === -56 /* TOK.CLASS */ ? 4 /* TSStmt.ABSTRACT_CLASS */ : 0 /* TSStmt.NONE */;
+    if (atom === A.namespace)
+        return token_is_ident(n.val) ? 5 /* TSStmt.NAMESPACE */ : 0 /* TSStmt.NONE */;
+    if (atom === A.module)
+        return token_is_ident(n.val) || n.val === -127 /* TOK.STRING */ ? 5 /* TSStmt.NAMESPACE */ : 0 /* TSStmt.NONE */;
+    /* declare */
+    switch (n.val) {
+        case -79 /* TOK.VAR */:
+        case -47 /* TOK.LET */:
+        case -55 /* TOK.CONST */:
+        case -59 /* TOK.FUNCTION */:
+        case -56 /* TOK.CLASS */:
+        case -54 /* TOK.ENUM */:
+        case -48 /* TOK.INTERFACE */:
+            return 3 /* TSStmt.DECLARE */;
+        case -125 /* TOK.IDENT */:
+            return (n.atom === JS_ATOM_let || n.atom === A.type || n.atom === A.namespace || n.atom === A.module ||
+                n.atom === JS_ATOM_global || n.atom === A.abstract || n.atom === JS_ATOM_interface || n.atom === JS_ATOM_async) &&
+                !n.escape ? 3 /* TSStmt.DECLARE */ : 0 /* TSStmt.NONE */;
+    }
+    return 0 /* TSStmt.NONE */;
+}
+/* skip a `declare ...` statement (the current token is `declare`) */
+function ts_skip_declare(s) {
+    const A = ts_atoms(s);
+    if (!ts_next(s))
+        return false;
+    switch (tv(s)) {
+        case -79 /* TOK.VAR */:
+        case -47 /* TOK.LET */:
+            return ts_next(s) && ts_skip_var_list(s);
+        case -55 /* TOK.CONST */:
+            if (ts_peek(s).val === -54 /* TOK.ENUM */)
+                return ts_next(s) && ts_skip_enum(s);
+            return ts_next(s) && ts_skip_var_list(s);
+        case -59 /* TOK.FUNCTION */:
+            if (!ts_skip_function_signature(s))
+                return false;
+            return tv(s) === 123 ? ts_skip_balanced(s) : ts_skip_semi(s);
+        case -56 /* TOK.CLASS */:
+            return ts_skip_class_decl(s);
+        case -54 /* TOK.ENUM */:
+            return ts_skip_enum(s);
+    }
+    if (ts_word(s, JS_ATOM_let))
+        return ts_next(s) && ts_skip_var_list(s);
+    if (ts_word(s, JS_ATOM_async)) {
+        if (!ts_skip_function_signature(s))
+            return false;
+        return ts_skip_semi(s);
+    }
+    if (ts_word(s, A.abstract))
+        return ts_next(s) && tv(s) === -56 /* TOK.CLASS */ && ts_skip_class_decl(s);
+    if (ts_word(s, JS_ATOM_interface))
+        return ts_skip_interface(s);
+    if (ts_word(s, A.type))
+        return ts_skip_type_alias(s);
+    if (ts_word(s, A.namespace) || ts_word(s, A.module) || ts_word(s, JS_ATOM_global))
+        return ts_skip_ambient_module(s);
+    return false;
+}
+/* enum E { ... } (ambient only) */
+function ts_skip_enum(s) {
+    return ts_next(s) && token_is_ident(tv(s)) && ts_next(s) && tv(s) === 123 && ts_skip_balanced(s);
+}
+/* a statement allowed in a type-only namespace body; false otherwise */
+function ts_skip_type_only_statement(s) {
+    if (tv(s) === 59)
+        return ts_next(s);
+    if (tv(s) === -53 /* TOK.EXPORT */ && !ts_next(s))
+        return false;
+    switch (ts_statement_kind(s)) {
+        case 1 /* TSStmt.INTERFACE */: return ts_skip_interface(s);
+        case 2 /* TSStmt.TYPE */: return ts_skip_type_alias(s);
+        case 3 /* TSStmt.DECLARE */: return ts_skip_declare(s);
+        case 5 /* TSStmt.NAMESPACE */: return ts_skip_type_only_namespace(s);
+        case 7 /* TSStmt.IMPORT_TYPE */: return ts_skip_import_type_decl(s);
+    }
+    return false;
+}
+/* namespace N { <type-only statements> }: false if the body has values */
+function ts_skip_type_only_namespace(s) {
+    if (!ts_next(s))
+        return false;
+    if (tv(s) === -127 /* TOK.STRING */) {
+        if (!ts_next(s))
+            return false;
+    }
+    else {
+        if (!token_is_ident(tv(s)) || !ts_next(s))
+            return false;
+        while (tv(s) === 46) {
+            if (!ts_next(s) || !token_is_ident_or_keyword(tv(s)) || !ts_next(s))
+                return false;
+        }
+    }
+    if (tv(s) !== 123 || !ts_next(s))
+        return false;
+    while (tv(s) !== 125) {
+        if (tv(s) === -86 /* TOK.EOF */ || !ts_skip_type_only_statement(s))
+            return false;
+    }
+    return ts_next(s);
+}
+/* import type ... from "m" [with { ... }] */
+function ts_skip_import_type_decl(s) {
+    const A = ts_atoms(s);
+    if (!ts_next(s) || !ts_next(s))
+        return false; /* 'import' 'type' */
+    while (tv(s) !== -127 /* TOK.STRING */) {
+        if (tv(s) === 123) {
+            if (!ts_skip_balanced(s))
+                return false;
+        }
+        else if (tv(s) === 61) {
+            return false; /* import type x = require(...) */
+        }
+        else if (tv(s) === -86 /* TOK.EOF */ || tv(s) === 59 || !ts_next(s)) {
+            return false;
+        }
+    }
+    if (!ts_next(s))
+        return false;
+    if ((ts_word(s, A.with_) || tv(s) === -57 /* TOK.WITH */ || ts_word(s, A.assert)) && !s.got_lf) {
+        if (!ts_next(s) || tv(s) !== 123 || !ts_skip_balanced(s))
+            return false;
+    }
+    return ts_skip_semi(s);
+}
+/* TypeScript-only statements: -1 on error, 0 if the current token does not start one (the
+   caller parses it as JavaScript; an `abstract` before `class` has been consumed), 1 if the
+   statement was skipped */
+function ts_parse_statement(s) {
+    const A = ts_atoms(s);
+    const start = s.token.ptr;
+    switch (ts_statement_kind(s)) {
+        case 0 /* TSStmt.NONE */:
+            return 0;
+        case 1 /* TSStmt.INTERFACE */:
+            if (!ts_skip_interface(s))
+                return ts_error(s, 'invalid interface declaration');
+            return 1;
+        case 2 /* TSStmt.TYPE */:
+            if (!ts_skip_type_alias(s))
+                return ts_error(s, 'invalid type alias');
+            return 1;
+        case 3 /* TSStmt.DECLARE */:
+            if (!ts_skip_declare(s))
+                return ts_error(s, 'invalid ambient declaration');
+            return 1;
+        case 4 /* TSStmt.ABSTRACT_CLASS */:
+            /* `abstract` is erased; the class is parsed as JavaScript (its abstract members are erased) */
+            return next_token(s) ? -1 : 0;
+        case 5 /* TSStmt.NAMESPACE */: {
+            const p = ts_save(s);
+            if (ts_skip_type_only_namespace(s))
+                return 1;
+            ts_restore(s, p);
+            return ts_unsupported(s, 'namespace declaration', start);
+        }
+        case 6 /* TSStmt.ENUM */:
+            return ts_unsupported(s, 'enum', start);
+        case 8 /* TSStmt.IMPORT_EQUALS */:
+            return ts_unsupported(s, 'import equals declaration', start);
+        case 7 /* TSStmt.IMPORT_TYPE */: {
+            const p = ts_save(s);
+            if (ts_skip_import_type_decl(s))
+                return 1;
+            ts_restore(s, p);
+            /* import type x = require(...) */
+            return ts_unsupported(s, 'import equals declaration', start);
+        }
+        case 10 /* TSStmt.FUNCTION */: {
+            /* an overload signature: a declaration without a body */
+            const p = ts_save(s);
+            if (ts_skip_function_signature(s) && tv(s) !== 123) {
+                if (js_parse_expect_semi(s))
+                    return -1;
+                return 1;
+            }
+            ts_restore(s, p);
+            return 0;
+        }
+        case 9 /* TSStmt.EXPORT */: {
+            const n = ts_peek(s);
+            if (n.val === 61)
+                return ts_unsupported(s, 'export assignment', start);
+            const p = ts_save(s);
+            if (!ts_next(s))
+                return -1;
+            if (ts_word(s, JS_ATOM_as)) {
+                /* export as namespace N; */
+                if (!(ts_next(s) && ts_word(s, A.namespace) && ts_next(s) && token_is_ident(tv(s)) && ts_next(s)))
+                    return ts_error(s, 'invalid export declaration');
+                return js_parse_expect_semi(s) ? -1 : 1;
+            }
+            if (tv(s) === -51 /* TOK.IMPORT */ && ts_peek(s).val === -125 /* TOK.IDENT */)
+                return ts_unsupported(s, 'import equals declaration', start);
+            if (ts_word(s, A.type)) {
+                const n2 = ts_peek(s);
+                if (n2.val === 123 || n2.val === 42) {
+                    /* export type { A } [from "m"]; */
+                    if (!(ts_next(s) && (tv(s) === 42 ? ts_next(s) : ts_skip_balanced(s))))
+                        return ts_error(s, 'invalid export declaration');
+                    if (ts_word(s, JS_ATOM_from) && !(ts_next(s) && tv(s) === -127 /* TOK.STRING */ && ts_next(s)))
+                        return ts_error(s, 'invalid export declaration');
+                    return js_parse_expect_semi(s) ? -1 : 1;
+                }
+            }
+            const kind = ts_statement_kind(s);
+            switch (kind) {
+                case 1 /* TSStmt.INTERFACE */:
+                case 2 /* TSStmt.TYPE */:
+                case 3 /* TSStmt.DECLARE */:
+                case 5 /* TSStmt.NAMESPACE */:
+                case 6 /* TSStmt.ENUM */:
+                case 10 /* TSStmt.FUNCTION */: {
+                    const r = ts_parse_statement(s);
+                    if (r !== 0)
+                        return r;
+                    break;
+                }
+            }
+            /* an export of a value: JavaScript's error */
+            ts_restore(s, p);
+            return 0;
+        }
+    }
+    return 0;
+}
+/* --- classes --- */
+/* public/private/protected/readonly/override/declare/abstract before a class member:
+   -1 on error, else 1 if the member is erased (declare, abstract), 0 otherwise */
+function ts_parse_class_modifiers(s) {
+    const A = ts_atoms(s);
+    let erase = 0;
+    for (;;) {
+        if (!(ts_word(s, JS_ATOM_public) || ts_word(s, JS_ATOM_private) || ts_word(s, JS_ATOM_protected) ||
+            ts_word(s, A.readonly) || ts_word(s, A.override) || ts_word(s, A.declare) || ts_word(s, A.abstract)))
+            return erase;
+        /* TypeScript's nextTokenIsOnSameLineAndCanFollowModifier */
+        const n = ts_peek(s);
+        if (n.lf)
+            return erase;
+        switch (n.val) {
+            case 91:
+            case 123:
+            case 42:
+            case -91 /* TOK.ELLIPSIS */:
+            case -127 /* TOK.STRING */:
+            case -128 /* TOK.NUMBER */:
+            case -87 /* TOK.PRIVATE_NAME */:
+            case -125 /* TOK.IDENT */:
+                break;
+            default:
+                if (!ts_is_keyword(n.val))
+                    return erase;
+        }
+        if (ts_word(s, A.declare) || ts_word(s, A.abstract))
+            erase = 1;
+        if (next_token(s))
+            return -1;
+    }
+}
+/* a class member name, with its get/set/async/'*' prefix */
+function ts_skip_member_name(s) {
+    if (ts_word(s, JS_ATOM_get) || ts_word(s, JS_ATOM_set) || ts_word(s, JS_ATOM_async)) {
+        const n = ts_peek(s);
+        if (!(n.val === 40 || n.val === 61 || n.val === 59 || n.val === 58 || n.val === 63 || n.val === 33 ||
+            n.val === 60 || n.val === 125 || n.lf) && !ts_next(s))
+            return false;
+    }
+    if (tv(s) === 42 && !ts_next(s))
+        return false;
+    switch (tv(s)) {
+        case 91: return ts_skip_balanced(s);
+        case -127 /* TOK.STRING */:
+        case -128 /* TOK.NUMBER */:
+        case -87 /* TOK.PRIVATE_NAME */: return ts_next(s);
+    }
+    return token_is_ident_or_keyword(tv(s)) && ts_next(s);
+}
+/* the member is a method without a body (overload signature) */
+function ts_class_member_is_signature(s) {
+    const p = ts_save(s);
+    let sig = false;
+    if (ts_skip_member_name(s) && (tv(s) !== 63 || ts_next(s)) && (tv(s) === 60 || tv(s) === 40)) {
+        sig = (tv(s) !== 60 || ts_skip_type_params(s)) && tv(s) === 40 && ts_skip_balanced(s) &&
+            (tv(s) !== 58 || (ts_next(s) && ts_skip_return_type(s))) && tv(s) !== 123;
+    }
+    ts_restore(s, p);
+    return sig;
+}
+/* [key: string]: T */
+function ts_is_index_signature(s) {
+    if (tv(s) !== 91)
+        return false;
+    const p = ts_save(s);
+    const ok = ts_next(s) && token_is_ident_or_keyword(tv(s)) && ts_next(s) && tv(s) === 58;
+    ts_restore(s, p);
+    return ok;
+}
+/* erase a class member: signature, index signature, declare field, abstract member */
+function ts_skip_class_member(s) {
+    if (!ts_skip_member_name(s))
+        return ts_error(s, 'invalid class member');
+    if ((tv(s) === 63 || tv(s) === 33) && next_token(s))
+        return -1;
+    if (tv(s) === 60 && !ts_skip_type_params(s))
+        return ts_error(s, 'invalid type parameters');
+    if (tv(s) === 40) {
+        if (!ts_skip_balanced(s))
+            return ts_error(s, 'invalid parameters');
+        if (tv(s) === 58 && ts_parse_annotation(s))
+            return -1;
+        if (tv(s) === 123)
+            return ts_skip_balanced(s) ? 0 : ts_error(s, 'invalid method body');
+        return js_parse_expect_semi(s);
+    }
+    if (tv(s) === 58 && ts_parse_annotation(s))
+        return -1;
+    if (tv(s) === 61) {
+        if (next_token(s))
+            return -1;
+        if (!ts_skip_expr_tokens(s))
+            return ts_error(s, 'invalid initializer');
+    }
+    return js_parse_expect_semi(s);
+}
+/* public/private/protected/readonly/override before a parameter (a parameter property) */
+function ts_is_param_modifier(s) {
+    const A = ts_atoms(s);
+    if (!(ts_word(s, JS_ATOM_public) || ts_word(s, JS_ATOM_private) || ts_word(s, JS_ATOM_protected) ||
+        ts_word(s, A.readonly) || ts_word(s, A.override)))
+        return false;
+    const n = ts_peek(s);
+    return n.val === -125 /* TOK.IDENT */ || n.val === 123 || n.val === 91 || n.val === -91 /* TOK.ELLIPSIS */ || ts_is_keyword(n.val);
+}
+/* ---------------------------------------------------------------------
+   JSX (JS_EVAL_FLAG_JSX)
+
+   JSX is compiled by the parser, like the type stripping above: an
+   element is read where a unary expression starts and emitted directly
+   as the calls TypeScript makes for it. Modules use the automatic
+   runtime (`jsx: "react-jsx"`): jsx, jsxs and Fragment are imported from
+   `<importSource>/jsx-runtime`, and createElement from `<importSource>`
+   for a key after a spread, under names no program can write (`*jsx*`,
+   ...), and each import is added to the module record only when it is
+   used. Scripts, and files with a `@jsxRuntime classic` pragma, use the
+   classic runtime (`jsx: "react"`): React.createElement and
+   React.Fragment, or the `@jsx` and `@jsxFrag` pragmas.
+
+   Tags, attributes and text are scanned from the source by the jsx_*
+   functions; expressions in braces go through the ordinary tokenizer
+   and parser. Every position is a source position, so errors, stacks
+   and the line table are those of the JSX source. jsx_skip_element
+   skips an element without emitting anything, for the lookaheads that
+   scan expressions token by token (arrow functions, destructuring,
+   TypeScript). See docs/JSX.md.
+   --------------------------------------------------------------------- */
+/* the named entities TypeScript decodes in JSX text and attribute strings (the HTML 4 list):
+   name, then code point in hex */
+const JSX_ENTITY_TABLE = 'quot 22 amp 26 apos 27 lt 3c gt 3e nbsp a0 iexcl a1 cent a2 pound a3 curren a4 yen a5 brvbar a6 ' +
+    'sect a7 uml a8 copy a9 ordf aa laquo ab not ac shy ad reg ae macr af deg b0 plusmn b1 sup2 b2 ' +
+    'sup3 b3 acute b4 micro b5 para b6 middot b7 cedil b8 sup1 b9 ordm ba raquo bb frac14 bc frac12 bd ' +
+    'frac34 be iquest bf Agrave c0 Aacute c1 Acirc c2 Atilde c3 Auml c4 Aring c5 AElig c6 Ccedil c7 ' +
+    'Egrave c8 Eacute c9 Ecirc ca Euml cb Igrave cc Iacute cd Icirc ce Iuml cf ETH d0 Ntilde d1 ' +
+    'Ograve d2 Oacute d3 Ocirc d4 Otilde d5 Ouml d6 times d7 Oslash d8 Ugrave d9 Uacute da Ucirc db ' +
+    'Uuml dc Yacute dd THORN de szlig df agrave e0 aacute e1 acirc e2 atilde e3 auml e4 aring e5 ' +
+    'aelig e6 ccedil e7 egrave e8 eacute e9 ecirc ea euml eb igrave ec iacute ed icirc ee iuml ef eth f0 ' +
+    'ntilde f1 ograve f2 oacute f3 ocirc f4 otilde f5 ouml f6 divide f7 oslash f8 ugrave f9 uacute fa ' +
+    'ucirc fb uuml fc yacute fd thorn fe yuml ff OElig 152 oelig 153 Scaron 160 scaron 161 Yuml 178 ' +
+    'fnof 192 circ 2c6 tilde 2dc Alpha 391 Beta 392 Gamma 393 Delta 394 Epsilon 395 Zeta 396 Eta 397 ' +
+    'Theta 398 Iota 399 Kappa 39a Lambda 39b Mu 39c Nu 39d Xi 39e Omicron 39f Pi 3a0 Rho 3a1 Sigma 3a3 ' +
+    'Tau 3a4 Upsilon 3a5 Phi 3a6 Chi 3a7 Psi 3a8 Omega 3a9 alpha 3b1 beta 3b2 gamma 3b3 delta 3b4 ' +
+    'epsilon 3b5 zeta 3b6 eta 3b7 theta 3b8 iota 3b9 kappa 3ba lambda 3bb mu 3bc nu 3bd xi 3be ' +
+    'omicron 3bf pi 3c0 rho 3c1 sigmaf 3c2 sigma 3c3 tau 3c4 upsilon 3c5 phi 3c6 chi 3c7 psi 3c8 ' +
+    'omega 3c9 thetasym 3d1 upsih 3d2 piv 3d6 ensp 2002 emsp 2003 thinsp 2009 zwnj 200c zwj 200d ' +
+    'lrm 200e rlm 200f ndash 2013 mdash 2014 lsquo 2018 rsquo 2019 sbquo 201a ldquo 201c rdquo 201d ' +
+    'bdquo 201e dagger 2020 Dagger 2021 bull 2022 hellip 2026 permil 2030 prime 2032 Prime 2033 ' +
+    'lsaquo 2039 rsaquo 203a oline 203e frasl 2044 euro 20ac image 2111 weierp 2118 real 211c trade 2122 ' +
+    'alefsym 2135 larr 2190 uarr 2191 rarr 2192 darr 2193 harr 2194 crarr 21b5 lArr 21d0 uArr 21d1 ' +
+    'rArr 21d2 dArr 21d3 hArr 21d4 forall 2200 part 2202 exist 2203 empty 2205 nabla 2207 isin 2208 ' +
+    'notin 2209 ni 220b prod 220f sum 2211 minus 2212 lowast 2217 radic 221a prop 221d infin 221e ' +
+    'ang 2220 and 2227 or 2228 cap 2229 cup 222a int 222b there4 2234 sim 223c cong 2245 asymp 2248 ' +
+    'ne 2260 equiv 2261 le 2264 ge 2265 sub 2282 sup 2283 nsub 2284 sube 2286 supe 2287 oplus 2295 ' +
+    'otimes 2297 perp 22a5 sdot 22c5 lceil 2308 rceil 2309 lfloor 230a rfloor 230b lang 2329 rang 232a ' +
+    'loz 25ca spades 2660 clubs 2663 hearts 2665 diams 2666';
+let jsx_entities = null;
+/* TypeScript's decodeEntities: named, decimal (&#38;) and hex (&#x26;) entities; unknown ones are kept */
+function jsx_decode_entities(text) {
+    if (text.indexOf('&') < 0)
+        return text;
+    if (jsx_entities === null) {
+        const t = JSX_ENTITY_TABLE.split(' ');
+        jsx_entities = new Map();
+        for (let i = 0; i + 1 < t.length; i += 2)
+            jsx_entities.set(t[i], parseInt(t[i + 1], 16));
+    }
+    const names = jsx_entities;
+    return text.replace(/&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, (match, _all, _number, _digits, decimal, hex, word) => {
+        const cp = decimal !== undefined ? parseInt(decimal, 10) : hex !== undefined ? parseInt(hex, 16) : names.get(word);
+        return cp !== undefined && cp <= 0x10ffff ? String.fromCodePoint(cp) : match;
+    });
+}
+function jsx_is_line_break(c) {
+    return c === 10 || c === 13 || c === CP_LS || c === CP_PS;
+}
+/* TypeScript's isWhiteSpaceSingleLine */
+function jsx_is_space(c) {
+    return c === 32 || c === 9 || c === 11 || c === 12 || c === 0xa0 || c === 0x85 || c === 0x1680 ||
+        (c >= 0x2000 && c <= 0x200b) || c === 0x202f || c === 0x205f || c === 0x3000 || c === 0xfeff;
+}
+/* the string a JSX text child stands for (TypeScript's fixupWhitespaceAndDecodeEntities), or null
+   if it produces no child: each line is trimmed, lines left empty are dropped, and the remaining
+   lines are joined with a space. The first line keeps its leading white space and the last its
+   trailing white space unless they hold a line break, so text on a single line is kept as is */
+function jsx_text_value(text) {
+    let acc = null;
+    let first = 0, last = -1;
+    const add = (line) => {
+        const decoded = jsx_decode_entities(line);
+        acc = acc === null ? decoded : acc + ' ' + decoded;
+    };
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        if (jsx_is_line_break(c)) {
+            if (first !== -1 && last !== -1)
+                add(text.substring(first, last + 1));
+            first = -1;
+        }
+        else if (!jsx_is_space(c)) {
+            last = i;
+            if (first === -1)
+                first = i;
+        }
+    }
+    if (first !== -1)
+        add(text.substring(first));
+    return acc;
+}
+/* --- the runtime --- */
+/* what JSX compiles to in a file */
+class JSXRuntime {
+    automatic = true;
+    /* automatic: the import source (jsx, jsxs and Fragment come from `${source}/jsx-runtime`) */
+    source = 'react';
+    /* classic: the factory and fragment, as property paths */
+    factory = ['React', 'createElement'];
+    fragment = ['React', 'Fragment'];
+    /* the module requests of the implicit imports, in order of first use */
+    requests = [];
+}
+/* TypeScript's jsx pragmas: the multi-line comments before the first token are matched with
+   TypeScript's regular expression (so one pragma per line), and each pragma takes the first word
+   after it; @jsx and @jsxFrag take their first occurrence, @jsxImportSource and @jsxRuntime their
+   last. An empty argument is '' */
+function jsx_pragmas(buf) {
+    const pragmas = new Map();
+    let p = 0;
+    const skip_line = () => { while (p < buf.length && !jsx_is_line_break(buf.charCodeAt(p)))
+        p++; };
+    if (buf.startsWith('#!'))
+        skip_line();
+    for (;;) {
+        while (p < buf.length && (jsx_is_line_break(buf.charCodeAt(p)) || lre_is_space(buf.charCodeAt(p))))
+            p++;
+        if (buf.startsWith('//', p)) {
+            skip_line();
+        }
+        else if (buf.startsWith('/*', p)) {
+            const end = buf.indexOf('*/', p + 2);
+            if (end < 0)
+                break;
+            const text = buf.substring(p, end + 2);
+            for (const m of text.matchAll(/@(\S+)(\s+(?:\S.*)?)?$/gm)) {
+                const name = m[1].toLowerCase();
+                if (name !== 'jsx' && name !== 'jsxfrag' && name !== 'jsximportsource' && name !== 'jsxruntime')
+                    continue;
+                const arg = m[2] === undefined ? '' : m[2].trim().split(/\s+/)[0];
+                let list = pragmas.get(name);
+                if (list === undefined)
+                    pragmas.set(name, list = []);
+                list.push(arg);
+            }
+            p = end + 2;
+        }
+        else {
+            break;
+        }
+    }
+    return pragmas;
+}
+/* `a.b.c` as a property path, or null if it is not one (TypeScript's parseIsolatedEntityName) */
+function jsx_entity_path(name) {
+    if (!name)
+        return null;
+    const parts = name.split('.');
+    return parts.every(p => /^[A-Za-z_$][\w$]*$/.test(p)) ? parts : null;
+}
+/* the runtime of the file being parsed, decided at its first JSX element as TypeScript does with
+   `jsx: "react-jsx"` for a module and `jsx: "react"` for a script: `@jsxRuntime classic` selects
+   the classic runtime, `@jsxRuntime automatic` or `@jsxImportSource` the automatic one (a
+   SyntaxError in a script, which cannot import) */
+function jsx_runtime(s) {
+    if (s.jsx_runtime !== null)
+        return s.jsx_runtime;
+    const rt = new JSXRuntime();
+    const pragmas = jsx_pragmas(s.buf);
+    const last = (name) => pragmas.get(name)?.at(-1);
+    const kind = last('jsxruntime');
+    const source = last('jsximportsource');
+    rt.automatic = kind === 'classic' ? false : s.is_module || kind === 'automatic' || source !== undefined;
+    if (rt.automatic && !s.is_module) {
+        js_parse_error(s, 'the automatic JSX runtime needs a module: use @jsxRuntime classic in a script');
+        return null;
+    }
+    if (source)
+        rt.source = source;
+    rt.factory = jsx_entity_path(pragmas.get('jsx')?.[0]) ?? rt.factory;
+    rt.fragment = jsx_entity_path(pragmas.get('jsxfrag')?.[0]) ?? rt.fragment;
+    return s.jsx_runtime = rt;
+}
+/* the variable of an implicit import of the automatic runtime (`jsx`, `jsxs`, `Fragment` or
+   `createElement`), added to the module record on first use */
+function jsx_import(s, name) {
+    const ctx = s.ctx;
+    const local = JS_NewAtom(ctx, `*${name}*`);
+    let fd = s.cur_func;
+    while (fd.parent !== null)
+        fd = fd.parent;
+    if (fd.closure_var.some(cv => cv.var_name === local))
+        return local;
+    const m = fd.module;
+    const rt = s.jsx_runtime;
+    const req = add_req_module_entry(m, JS_NewAtom(ctx, name === 'createElement' ? rt.source : `${rt.source}/jsx-runtime`), null);
+    if (!rt.requests.includes(req))
+        rt.requests.push(req);
+    const var_idx = add_closure_var(ctx, fd, false, false, m.import_entries.length, local, true, true, 0 /* JSVarKind.NORMAL */);
+    const mi = new JSImportEntry(var_idx, false, JS_NewAtom(ctx, name));
+    mi.req_module_idx = req;
+    m.import_entries.push(mi);
+    return local;
+}
+/* TypeScript puts the implicit imports first (each import statement before the previous one), so
+   the runtime modules are requested, and evaluated, before the file's own imports */
+function jsx_hoist_requests(m, requests) {
+    const order = [...requests].reverse();
+    for (let i = 0; i < m.req_module_entries.length; i++)
+        if (!order.includes(i))
+            order.push(i);
+    const index = new Map(order.map((old, i) => [old, i]));
+    m.req_module_entries = order.map(i => m.req_module_entries[i]);
+    for (const mi of m.import_entries)
+        mi.req_module_idx = index.get(mi.req_module_idx);
+    for (const me of m.export_entries)
+        if (me.export_type === 1 /* JSExportType.INDIRECT */)
+            me.req_module_idx = index.get(me.req_module_idx);
+    for (const se of m.star_export_entries)
+        se.req_module_idx = index.get(se.req_module_idx);
+}
+/* --- scanning --- */
+/* skip white space, line terminators and comments in a JSX tag: the new position, or -1 after
+   reporting an unterminated comment */
+function jsx_skip_space(s, p) {
+    const buf = s.buf;
+    while (p < s.buf_end) {
+        const c = buf.charCodeAt(p);
+        if (c === 47 && buf.charCodeAt(p + 1) === 42) {
+            const end = buf.indexOf('*/', p + 2);
+            if (end < 0)
+                return js_parse_error_pos(s, p, 'unexpected end of comment');
+            p = end + 2;
+        }
+        else if (c === 47 && buf.charCodeAt(p + 1) === 47) {
+            p += 2;
+            while (p < s.buf_end && !jsx_is_line_break(buf.charCodeAt(p)))
+                p++;
+        }
+        else if (jsx_is_line_break(c) || lre_is_space(c)) {
+            p++;
+        }
+        else {
+            break;
+        }
+    }
+    return p;
+}
+/* the next token of a JSX tag, from s.buf_ptr: a JSX name (identifier characters and '-', in
+   s.token.str and s.token.atom), a string (its raw text, newlines included, with the entities
+   decoded), EOF, or a single punctuation character ('>' is never part of '>=' or '>>') */
+function jsx_tag_token(s) {
+    const buf = s.buf;
+    const p = jsx_skip_space(s, s.buf_ptr);
+    if (p < 0)
+        return -1;
+    const t = s.token;
+    t.ptr = p;
+    t.atom = JS_ATOM_NULL;
+    t.has_escape = false;
+    t.is_reserved = false;
+    if (p >= s.buf_end) {
+        t.val = -86 /* TOK.EOF */;
+        s.buf_ptr = p;
+        return 0;
+    }
+    const c = cp_at(buf, p);
+    if (lre_js_is_ident_first(c)) {
+        let q = p + cp_len(c);
+        while (q < s.buf_end) {
+            const d = cp_at(buf, q);
+            if (d !== 45 && !lre_js_is_ident_next(d))
+                break;
+            q += cp_len(d);
+        }
+        t.val = -125 /* TOK.IDENT */;
+        t.str = buf.substring(p, q);
+        t.atom = JS_NewAtom(s.ctx, t.str);
+        s.buf_ptr = q;
+        return 0;
+    }
+    if (c === 34 || c === 39) {
+        const end = buf.indexOf(c === 34 ? '"' : "'", p + 1);
+        if (end < 0)
+            return js_parse_error_pos(s, p, 'unexpected end of string');
+        t.val = -127 /* TOK.STRING */;
+        t.str = jsx_decode_entities(buf.substring(p + 1, end));
+        s.buf_ptr = end + 1;
+        return 0;
+    }
+    if (c >= 33 && c < 127) {
+        t.val = c;
+        s.buf_ptr = p + 1;
+        return 0;
+    }
+    return js_parse_error_pos(s, p, 'unexpected character');
+}
+/* a tag name: `div`, `a-b` and `a:b` are strings, `Foo`, `a.b.c` and `this.x` expressions */
+class JSXTag {
+    text = ''; /* as written, without spaces: compared with the closing tag */
+    ptr = 0;
+    is_string = false;
+    parts = [];
+}
+/* the tag name at the current token; the token after it becomes current. In TypeScript, type
+   arguments may follow the name of an opening tag (`<List<T> items={x} />`) */
+function jsx_parse_tag_name(s, tag, type_args) {
+    tag.ptr = s.token.ptr;
+    if (tv(s) !== -125 /* TOK.IDENT */)
+        return js_parse_error(s, 'JSX element name expected');
+    tag.text = s.token.str;
+    tag.parts = [s.token.atom];
+    if (jsx_tag_token(s))
+        return -1;
+    if (tv(s) === 58) {
+        /* namespaced name */
+        if (jsx_tag_token(s))
+            return -1;
+        if (tv(s) !== -125 /* TOK.IDENT */)
+            return js_parse_error(s, 'identifier expected');
+        tag.text += ':' + s.token.str;
+        tag.is_string = true;
+        if (jsx_tag_token(s))
+            return -1;
+    }
+    else {
+        while (tv(s) === 46) {
+            if (jsx_tag_token(s))
+                return -1;
+            if (tv(s) !== -125 /* TOK.IDENT */)
+                return js_parse_error(s, 'identifier expected');
+            tag.text += '.' + s.token.str;
+            tag.parts.push(s.token.atom);
+            if (jsx_tag_token(s))
+                return -1;
+        }
+        /* TypeScript's isIntrinsicJsxName; `this` is an expression */
+        const c = tag.text.charCodeAt(0);
+        tag.is_string = tag.parts.length === 1 && tag.text !== 'this' && ((c >= 97 && c <= 122) || tag.text.includes('-'));
+    }
+    if (type_args && s.ts && tv(s) === 60) {
+        s.buf_ptr = s.token.ptr;
+        if (next_token(s))
+            return -1;
+        if (!ts_skip_type_args(s))
+            return ts_error(s, 'invalid type arguments');
+        /* rescan the token after the type arguments as a tag token */
+        s.buf_ptr = s.token.ptr;
+        if (jsx_tag_token(s))
+            return -1;
+    }
+    return 0;
+}
+/* the current token is the '{' of a JSX tag: skip to just after its '}', JSX included */
+function jsx_skip_braces(s) {
+    s.buf_ptr = s.token.ptr;
+    return ts_next(s) && ts_skip_balanced(s, false);
+}
+/* the current token starts an attribute value: skip it (to just after it) */
+function jsx_skip_attr_value(s) {
+    if (tv(s) === -127 /* TOK.STRING */)
+        return true;
+    if (tv(s) === 123)
+        return jsx_skip_braces(s);
+    if (tv(s) === 60)
+        return jsx_skip_element(s);
+    return false;
+}
+/* the current token is the '<' of a JSX element: skip the element without emitting anything, to
+   just after its last '>'. False if it is not one (an exception may be pending) */
+function jsx_skip_element(s) {
+    s.buf_ptr = s.token.ptr + 1;
+    if (jsx_tag_token(s))
+        return false;
+    const tag = new JSXTag();
+    if (tv(s) !== 62) {
+        if (jsx_parse_tag_name(s, tag, true))
+            return false;
+        while (tv(s) !== 47 && tv(s) !== 62) {
+            if (tv(s) === -125 /* TOK.IDENT */) {
+                if (jsx_tag_token(s))
+                    return false;
+                if (tv(s) === 58 && (jsx_tag_token(s) || tv(s) !== -125 /* TOK.IDENT */ || jsx_tag_token(s)))
+                    return false;
+                if (tv(s) === 61 && (jsx_tag_token(s) || !jsx_skip_attr_value(s) || jsx_tag_token(s)))
+                    return false;
+            }
+            else if (tv(s) === 123) {
+                if (!jsx_skip_braces(s) || jsx_tag_token(s))
+                    return false;
+            }
+            else {
+                return false;
+            }
+        }
+        if (tv(s) === 47)
+            return !jsx_tag_token(s) && tv(s) === 62;
+    }
+    /* children */
+    const buf = s.buf;
+    let p = s.buf_ptr;
+    for (;;) {
+        while (p < s.buf_end) {
+            const c = buf.charCodeAt(p);
+            if (c === 123 || c === 60)
+                break;
+            if (c === 62 || c === 125)
+                return false;
+            p++;
+        }
+        if (p >= s.buf_end)
+            return false;
+        s.buf_ptr = p;
+        if (buf.charCodeAt(p) === 123) {
+            if (!ts_next(s) || !ts_skip_balanced(s, false))
+                return false;
+        }
+        else if (buf.charCodeAt(p + 1) === 47) {
+            s.buf_ptr = p + 2;
+            if (jsx_tag_token(s))
+                return false;
+            const close = new JSXTag();
+            if (tv(s) !== 62 && jsx_parse_tag_name(s, close, false))
+                return false;
+            return tv(s) === 62 && close.text === tag.text;
+        }
+        else {
+            s.token.ptr = p;
+            if (!jsx_skip_element(s))
+                return false;
+        }
+        p = s.buf_ptr;
+    }
+}
+/* the current token is '<' at the start of an expression: true if it starts a JSX element, which
+   is then skipped (with the token after it current) */
+function jsx_try_skip(s) {
+    const p = ts_save(s);
+    if (jsx_skip_element(s) && ts_next(s))
+        return true;
+    ts_restore(s, p);
+    return false;
+}
+/* TypeScript's hasKeyAfterPropsSpread, scanned ahead from the token after the tag name: a `key`
+   attribute after a spread (of anything but an object literal without spreads) makes the element
+   a createElement call, which keeps the key in the props */
+function jsx_key_after_spread(s) {
+    const pos = ts_save(s);
+    let spread = false, found = false;
+    for (;;) {
+        if (tv(s) === -125 /* TOK.IDENT */) {
+            let is_key = s.token.str === 'key';
+            if (jsx_tag_token(s))
+                break;
+            if (tv(s) === 58) {
+                is_key = false;
+                if (jsx_tag_token(s) || jsx_tag_token(s))
+                    break;
+            }
+            if (is_key && spread) {
+                found = true;
                 break;
-            case 61: /* = */
-                bits |= SKIP_HAS_ASSIGNMENT;
+            }
+            if (tv(s) === 61 && (jsx_tag_token(s) || !jsx_skip_attr_value(s) || jsx_tag_token(s)))
                 break;
-            case -122 /* TOK.DIV_ASSIGN */:
-            case 47: /* / */
-                if (is_regexp_allowed(last_tok)) {
-                    s.buf_ptr = s.token.ptr + 1;
-                    if (js_parse_regexp(s)) {
-                        /* clear the exception generated by js_parse_regexp */
-                        JS_GetException(s.ctx);
-                        break outer;
-                    }
-                }
+        }
+        else if (tv(s) === 123) {
+            const start = s.token.ptr;
+            if (!spread) {
+                const literal = { ellipsis: false };
+                s.buf_ptr = start + 1;
+                if (!ts_next(s) || tv(s) !== -91 /* TOK.ELLIPSIS */ || !ts_next(s))
+                    break;
+                spread = !(tv(s) === 123 && ts_skip_balanced(s, true, literal) && tv(s) === 125 && !literal.ellipsis);
+            }
+            s.token.ptr = start;
+            if (!jsx_skip_braces(s) || jsx_tag_token(s))
                 break;
         }
-        /* last_tok is only used to recognize regexps */
-        if (tv(s) === -125 /* TOK.IDENT */ && (token_is_pseudo_keyword(s, JS_ATOM_of) || token_is_pseudo_keyword(s, JS_ATOM_yield))) {
-            last_tok = -39 /* TOK.OF */;
+        else {
+            break;
+        }
+    }
+    ts_restore(s, pos);
+    return found;
+}
+function jsx_child_start(s, ch, spread) {
+    if (spread)
+        ch.spread = true;
+    if (!ch.array && (spread || ch.base + ch.n >= 65535)) {
+        emit_op(s, 38 /* OP.array_from */);
+        emit_u16(s, ch.base + ch.n);
+        emit_op(s, 1 /* OP.push_i32 */);
+        emit_u32(s, ch.base + ch.n);
+        ch.array = true;
+    }
+}
+function jsx_child_end(s, ch, spread) {
+    if (ch.array) {
+        if (spread) {
+            emit_op(s, 83 /* OP.append */);
         }
         else {
-            last_tok = tv(s);
+            emit_op(s, 82 /* OP.define_array_el */);
+            emit_op(s, 145 /* OP.inc */);
         }
-        const last_token_ptr = s.token.ptr;
-        if (next_token(s)) {
-            /* clear the exception generated by next_token() */
-            JS_GetException(s.ctx);
-            break;
+    }
+    ch.n++;
+}
+/* emit a property path (the classic factory or fragment); with `method`, keep the object of the
+   last property for a method call. True if it is one */
+function jsx_emit_path(s, path, method) {
+    emit_ident_ref(s, JS_NewAtom(s.ctx, path[0]));
+    for (let i = 1; i < path.length; i++) {
+        emit_op(s, method && i === path.length - 1 ? 67 /* OP.get_field2 */ : 66 /* OP.get_field */);
+        emit_atom(s, JS_NewAtom(s.ctx, path[i]));
+    }
+    return method && path.length > 1;
+}
+/* emit the type of an element: a string, or the value of the tag expression */
+function jsx_emit_tag(s, tag) {
+    if (tag.is_string)
+        return emit_push_const(s, tag.text, true);
+    emit_source_pos(s, tag.ptr);
+    if (tag.parts[0] === JS_ATOM_this) {
+        emit_op(s, 186 /* OP.scope_get_var */);
+        emit_atom(s, JS_ATOM_this);
+        emit_u16(s, 0);
+    }
+    else {
+        emit_ident_ref(s, tag.parts[0]);
+    }
+    for (let i = 1; i < tag.parts.length; i++) {
+        emit_op(s, 66 /* OP.get_field */);
+        emit_atom(s, tag.parts[i]);
+    }
+    return 0;
+}
+/* the current token starts an attribute value: emit it (s.buf_ptr ends just after it) */
+function jsx_parse_attr_value(s) {
+    if (tv(s) === -127 /* TOK.STRING */)
+        return emit_push_const(s, s.token.str, true);
+    if (tv(s) === 60)
+        return jsx_parse_element(s);
+    if (tv(s) !== 123)
+        return js_parse_error(s, "'{' or JSX element expected");
+    if (next_token(s))
+        return -1;
+    if (tv(s) === 125)
+        return js_parse_error(s, 'JSX attributes must only be assigned a non-empty expression');
+    if (js_parse_expr(s))
+        return -1;
+    if (tv(s) !== 125)
+        return js_parse_error(s, "expecting '}'");
+    return 0;
+}
+/* the children of an element, up to and including its closing tag */
+function jsx_parse_children(s, ch, tag, start) {
+    const buf = s.buf;
+    let p = s.buf_ptr;
+    for (;;) {
+        /* text */
+        let q = p;
+        while (q < s.buf_end) {
+            const c = buf.charCodeAt(q);
+            if (c === 123 || c === 60)
+                break;
+            if (c === 62)
+                return js_parse_error_pos(s, q, "Unexpected token. Did you mean `{'>'}` or `&gt;`?");
+            if (c === 125)
+                return js_parse_error_pos(s, q, "Unexpected token. Did you mean `{'}'}` or `&rbrace;`?");
+            q++;
+        }
+        if (q > p) {
+            const text = jsx_text_value(buf.substring(p, q));
+            if (text !== null) {
+                jsx_child_start(s, ch, false);
+                if (emit_push_const(s, text, true))
+                    return -1;
+                jsx_child_end(s, ch, false);
+            }
         }
-        if (level <= 1) {
-            tok = tv(s);
-            if (token_is_pseudo_keyword(s, JS_ATOM_of))
-                tok = -39 /* TOK.OF */;
-            if (no_line_terminator && has_lf_in_range(s, last_token_ptr, s.token.ptr))
-                tok = 10;
-            break;
+        if (q >= s.buf_end) {
+            return js_parse_error_pos(s, start, tag ? `JSX element '${tag.text}' has no corresponding closing tag`
+                : 'JSX fragment has no corresponding closing tag');
+        }
+        if (buf.charCodeAt(q) === 123) {
+            /* {expression}, {...spread}, or only comments */
+            const r = jsx_skip_space(s, q + 1);
+            if (r < 0)
+                return -1;
+            if (buf.charCodeAt(r) === 125) {
+                p = r + 1;
+                continue;
+            }
+            s.buf_ptr = q + 1;
+            if (next_token(s))
+                return -1;
+            const spread = tv(s) === -91 /* TOK.ELLIPSIS */;
+            if (spread && next_token(s))
+                return -1;
+            jsx_child_start(s, ch, spread);
+            if (js_parse_expr(s))
+                return -1;
+            if (tv(s) !== 125)
+                return js_parse_error(s, "expecting '}'");
+            jsx_child_end(s, ch, spread);
+        }
+        else if (buf.charCodeAt(q + 1) === 47) {
+            /* the closing tag */
+            s.buf_ptr = q + 2;
+            if (jsx_tag_token(s))
+                return -1;
+            const close = new JSXTag();
+            close.ptr = s.token.ptr;
+            if (tv(s) !== 62 && jsx_parse_tag_name(s, close, false))
+                return -1;
+            if (tv(s) !== 62)
+                return js_parse_error(s, "expecting '>'");
+            const name = tag ? tag.text : '';
+            if (close.text !== name) {
+                const found = close.text ? `</${close.text}>` : '</>';
+                return js_parse_error_pos(s, close.ptr, tag ? `expected corresponding JSX closing tag for <${name}>, found ${found}`
+                    : `expected corresponding closing tag for JSX fragment, found ${found}`);
+            }
+            return 0;
+        }
+        else {
+            s.token.ptr = q;
+            s.token.val = 60;
+            jsx_child_start(s, ch, false);
+            if (jsx_parse_element(s))
+                return -1;
+            jsx_child_end(s, ch, false);
         }
+        p = s.buf_ptr;
     }
-    if (pbits)
-        pbits.bits = bits;
-    /* restore the parser state */
-    Object.assign(s.token, pos.token);
-    s.buf_ptr = saved_ptr;
-    s.got_lf = saved_got_lf;
-    return tok;
 }
-const SKIP_HAS_SEMI = 1 << 0;
-const SKIP_HAS_ELLIPSIS = 1 << 1;
-const SKIP_HAS_ASSIGNMENT = 1 << 2;
+/* the current token is the '<' of a JSX element or fragment: emit its value, as TypeScript
+   compiles it. On return s.buf_ptr is just after the element's last '>' (the current token is
+   not meaningful). In the jsx/jsxs form the key is evaluated after the other props and the
+   children, as the third argument: its value is skipped and parsed again at the end */
+function jsx_parse_element(s) {
+    const rt = jsx_runtime(s);
+    if (rt === null)
+        return -1;
+    const fd = s.cur_func;
+    const start = s.token.ptr;
+    s.buf_ptr = start + 1;
+    if (jsx_tag_token(s))
+        return -1;
+    let tag = null;
+    if (tv(s) !== 62) {
+        tag = new JSXTag();
+        if (jsx_parse_tag_name(s, tag, true))
+            return -1;
+    }
+    const form = !rt.automatic ? 2 /* JSXForm.CLASSIC */ : tag && jsx_key_after_spread(s) ? 1 /* JSXForm.CREATE_ELEMENT */ : 0 /* JSXForm.JSX */;
+    /* the function: `*jsx*` is patched to `*jsxs*` once the children are known */
+    let method = false;
+    const callee_pos = fd.byte_code.size;
+    if (form === 2 /* JSXForm.CLASSIC */)
+        method = jsx_emit_path(s, rt.factory, true);
+    else
+        emit_ident_ref(s, form === 0 /* JSXForm.JSX */ ? JS_ATOM_NULL : jsx_import(s, 'createElement'));
+    /* the type */
+    if (tag !== null) {
+        if (jsx_emit_tag(s, tag))
+            return -1;
+    }
+    else if (form === 2 /* JSXForm.CLASSIC */) {
+        jsx_emit_path(s, rt.fragment, false);
+    }
+    else {
+        emit_ident_ref(s, jsx_import(s, 'Fragment'));
+    }
+    /* the props: null without attributes, except in the jsx form */
+    let key_ptr = -2; /* jsx form: -1 for `key` without a value, else the position of its value */
+    if (form !== 0 /* JSXForm.JSX */ && (tv(s) === 47 || tv(s) === 62)) {
+        emit_op(s, 7 /* OP.null */);
+    }
+    else {
+        emit_op(s, 11 /* OP.object */);
+        while (tv(s) !== 47 && tv(s) !== 62) {
+            if (tv(s) === 123) {
+                /* {...props} */
+                if (next_token(s))
+                    return -1;
+                if (tv(s) !== -91 /* TOK.ELLIPSIS */)
+                    return js_parse_error(s, "expecting '...'");
+                if (next_token(s) || js_parse_expr(s))
+                    return -1;
+                if (tv(s) !== 125)
+                    return js_parse_error(s, "expecting '}'");
+                emit_op(s, 7 /* OP.null */); /* dummy excludeList */
+                emit_op(s, 84 /* OP.copy_data_properties */);
+                emit_u8(s, 2 | (1 << 2) | (0 << 5));
+                emit_op(s, 14 /* OP.drop */); /* pop excludeList */
+                emit_op(s, 14 /* OP.drop */); /* pop src object */
+            }
+            else if (tv(s) === -125 /* TOK.IDENT */) {
+                let name = s.token.atom;
+                const is_key = s.token.str === 'key';
+                if (jsx_tag_token(s))
+                    return -1;
+                if (tv(s) === 58) {
+                    /* namespaced attribute: a:b */
+                    const ns = JS_AtomGetStr(s.ctx, name);
+                    if (jsx_tag_token(s))
+                        return -1;
+                    if (tv(s) !== -125 /* TOK.IDENT */)
+                        return js_parse_error(s, 'identifier expected');
+                    name = JS_NewAtom(s.ctx, ns + ':' + s.token.str);
+                    if (jsx_tag_token(s))
+                        return -1;
+                }
+                else if (is_key && form === 0 /* JSXForm.JSX */ && key_ptr === -2) {
+                    /* TypeScript passes the first `key` as the third argument */
+                    if (tv(s) !== 61) {
+                        key_ptr = -1;
+                        continue;
+                    }
+                    if (jsx_tag_token(s))
+                        return -1;
+                    key_ptr = s.token.ptr;
+                    if (!jsx_skip_attr_value(s))
+                        return ts_error(s, "'{' or JSX element expected");
+                    if (jsx_tag_token(s))
+                        return -1;
+                    continue;
+                }
+                if (tv(s) === 61) {
+                    if (jsx_tag_token(s) || jsx_parse_attr_value(s))
+                        return -1;
+                    set_object_name(s, name);
+                }
+                else {
+                    /* boolean shorthand */
+                    emit_op(s, 10 /* OP.push_true */);
+                    emit_op(s, 77 /* OP.define_field */);
+                    emit_atom(s, name);
+                    continue;
+                }
+                emit_op(s, 77 /* OP.define_field */);
+                emit_atom(s, name);
+            }
+            else {
+                return js_parse_error(s, tv(s) === -86 /* TOK.EOF */ ? 'unexpected end of input in a JSX tag' : 'unexpected token in a JSX tag');
+            }
+            if (jsx_tag_token(s))
+                return -1;
+        }
+    }
+    /* the children */
+    const ch = { n: 0, spread: false, array: false, base: form === 0 /* JSXForm.JSX */ ? 0 : 2 };
+    if (tv(s) === 47) {
+        if (jsx_tag_token(s))
+            return -1;
+        if (tv(s) !== 62)
+            return js_parse_error(s, "expecting '>'");
+    }
+    else if (jsx_parse_children(s, ch, tag, start)) {
+        return -1;
+    }
+    /* the call */
+    if (form === 0 /* JSXForm.JSX */) {
+        const children = JS_NewAtom(s.ctx, 'children');
+        if (ch.array) {
+            emit_op(s, 14 /* OP.drop */); /* the index */
+        }
+        else if (ch.n > 1) {
+            emit_op(s, 38 /* OP.array_from */);
+            emit_u16(s, ch.n);
+        }
+        else if (ch.n === 1) {
+            set_object_name(s, children);
+        }
+        if (ch.n > 0) {
+            emit_op(s, 77 /* OP.define_field */);
+            emit_atom(s, children);
+        }
+        put_u32(fd.byte_code.buf, callee_pos + 1, jsx_import(s, ch.n > 1 || ch.spread ? 'jsxs' : 'jsx'));
+        let argc = 2;
+        if (key_ptr !== -2) {
+            if (key_ptr === -1) {
+                emit_op(s, 10 /* OP.push_true */);
+            }
+            else {
+                const end = s.buf_ptr;
+                s.buf_ptr = key_ptr;
+                if (jsx_tag_token(s) || jsx_parse_attr_value(s))
+                    return -1;
+                s.buf_ptr = end;
+            }
+            argc = 3;
+        }
+        emit_source_pos(s, start);
+        emit_op(s, 34 /* OP.call */);
+        emit_u16(s, argc);
+    }
+    else if (ch.array) {
+        emit_op(s, 14 /* OP.drop */); /* the index */
+        emit_source_pos(s, start);
+        if (method) {
+            emit_op(s, 24 /* OP.perm3 */); /* obj func array -> func obj array */
+        }
+        else {
+            emit_op(s, 6 /* OP.undefined */); /* func array -> func undefined array */
+            emit_op(s, 27 /* OP.swap */);
+        }
+        emit_op(s, 39 /* OP.apply */);
+        emit_u16(s, 0);
+    }
+    else {
+        emit_source_pos(s, start);
+        emit_op(s, method ? 36 /* OP.call_method */ : 34 /* OP.call */);
+        emit_u16(s, 2 + ch.n);
+    }
+    return 0;
+}
 /* ---------------------------------------------------------------------
    Bytecode emission helpers
    --------------------------------------------------------------------- */
@@ -2414,7 +4418,7 @@ function js_parse_property_name(s, out, allow_method, allow_var, allow_private)
             if (next_token(s))
                 return -1;
             if (tv(s) === 58 || tv(s) === 44 || tv(s) === 125 || tv(s) === 40 || tv(s) === 61 ||
-                (tv(s) === 59 && allow_private)) {
+                (tv(s) === 59 && allow_private) || (s.ts && (tv(s) === 60 || tv(s) === 63 || tv(s) === 33))) {
                 is_non_reserved_ident = true;
                 ident_found = true;
             }
@@ -2431,7 +4435,8 @@ function js_parse_property_name(s, out, allow_method, allow_var, allow_private)
             name = s.token.atom;
             if (next_token(s))
                 return -1;
-            if (tv(s) === 58 || tv(s) === 44 || tv(s) === 125 || tv(s) === 40 || tv(s) === 61) {
+            if (tv(s) === 58 || tv(s) === 44 || tv(s) === 125 || tv(s) === 40 || tv(s) === 61 ||
+                (s.ts && (tv(s) === 60 || tv(s) === 63 || tv(s) === 33))) {
                 is_non_reserved_ident = true;
                 ident_found = true;
             }
@@ -2486,6 +4491,11 @@ function js_parse_property_name(s, out, allow_method, allow_var, allow_private)
             return -1;
         }
     }
+    if (s.ts && allow_method && tv(s) === 60) {
+        /* method type parameters: m<T>(x: T) {} */
+        if (!ts_skip_type_params(s))
+            return ts_error(s, 'invalid type parameters');
+    }
     if (ident_found) {
         if (is_non_reserved_ident && prop_type === PROP_TYPE_IDENT && allow_var) {
             if (!(tv(s) === 58 || (tv(s) === 40 && allow_method)))
@@ -3107,6 +5117,8 @@ function js_parse_destructuring_element(s, tok, is_arg, hasval, has_ellipsis, al
             if (tok) {
                 if (js_define_var(s, var_name, tok))
                     return -1;
+                if (export_flag && add_local_export(s, var_name))
+                    return -1;
                 scope = fd.scope_level; /* XXX: check */
             }
             if (tv(s) === 61 /* = */) { /* handle optional default value */
@@ -3189,6 +5201,8 @@ function js_parse_destructuring_element(s, tok, is_arg, hasval, has_ellipsis, al
                         return -1;
                     if (js_define_var(s, var_name, tok))
                         return -1;
+                    if (export_flag && add_local_export(s, var_name))
+                        return -1;
                     if (need_var_reference(s, tok)) {
                         /* Must make a reference for proper `with` semantics */
                         emit_op(s, 186 /* OP.scope_get_var */);
@@ -3254,6 +5268,13 @@ function js_parse_destructuring_element(s, tok, is_arg, hasval, has_ellipsis, al
     else {
         return js_parse_error(s, 'invalid assignment syntax');
     }
+    if (s.ts && (tv(s) === 63 || tv(s) === 58)) {
+        /* {a, b}?: T */
+        if (tv(s) === 63 && next_token(s))
+            return -1;
+        if (tv(s) === 58 && ts_parse_annotation(s))
+            return -1;
+    }
     if (tv(s) === 61 && allow_initializer) {
         label_done = emit_goto(s, 109 /* OP.goto */, -1);
         if (next_token(s))
@@ -3502,6 +5523,21 @@ function js_parse_postfix_expr(s, parse_flags) {
                     return js_parse_error(s, "invalid use of 'import()'");
                 if (js_parse_assign_expr(s))
                     return -1;
+                /* optional options argument, and trailing comma */
+                let has_options = false;
+                if (tv(s) === 44) {
+                    if (next_token(s))
+                        return -1;
+                    if (tv(s) !== 41) {
+                        if (js_parse_assign_expr(s))
+                            return -1;
+                        has_options = true;
+                        if (tv(s) === 44 && next_token(s))
+                            return -1;
+                    }
+                }
+                if (!has_options)
+                    emit_op(s, 6 /* OP.undefined */);
                 if (js_parse_expect(s, 41))
                     return -1;
                 emit_op(s, 54 /* OP.import */);
@@ -3521,6 +5557,9 @@ function js_parse_postfix_expr(s, parse_flags) {
             if (next_token(s))
                 return -1;
             has_optional_chain = true;
+            /* a?.<T>(x) */
+            if (s.ts && (tv(s) === 60 || tv(s) === -106 /* TOK.SHL */) && !ts_try_expr_type_args(s) && JS_HasException(s.ctx))
+                return -1;
             if (tv(s) === 40 && accept_lparen)
                 action = 'call';
             else if (tv(s) === 91)
@@ -3549,6 +5588,19 @@ function js_parse_postfix_expr(s, parse_flags) {
             action = 'array';
         }
         else {
+            if (s.ts) {
+                /* non-null assertion x! (not after a line break) */
+                if (tv(s) === 33 && !s.got_lf) {
+                    if (next_token(s))
+                        return -1;
+                    continue;
+                }
+                /* type arguments: f<T>(x), new C<T>(), f<T>`t`, f<T> */
+                if ((tv(s) === 60 || tv(s) === -106 /* TOK.SHL */) && ts_try_expr_type_args(s))
+                    continue;
+                if (JS_HasException(s.ctx))
+                    return -1;
+            }
             break;
         }
         if (action === 'call') {
@@ -4069,6 +6121,26 @@ function js_parse_unary(s, parse_flags) {
             parse_flags = 0;
             break;
         default:
+            if (s.jsx && tv(s) === 60) {
+                /* a JSX element (in TypeScript, `<T>expr` is JSX too) */
+                if (jsx_parse_element(s) || next_token(s))
+                    return -1;
+                /* TypeScript reads a '<' after an element as a second element: <a/><b/> */
+                if (tv(s) === 60)
+                    return js_parse_error(s, 'JSX expressions must have one parent element');
+                break;
+            }
+            if (s.ts && tv(s) === 60) {
+                /* type assertion <T>expr */
+                if (next_token(s))
+                    return -1;
+                if (!ts_skip_type(s) || !ts_eat_gt(s))
+                    return ts_error(s, 'invalid type assertion');
+                if (js_parse_unary(s, PF_POW_FORBIDDEN))
+                    return -1;
+                parse_flags = 0;
+                break;
+            }
             if (js_parse_postfix_expr(s, PF_POSTFIX_CALL))
                 return -1;
             if (!s.got_lf && (tv(s) === -108 /* TOK.DEC */ || tv(s) === -107 /* TOK.INC */)) {
@@ -4193,7 +6265,14 @@ function js_parse_expr_binary(s, level, parse_flags) {
                         else
                             return 0;
                         break;
-                    default: return 0;
+                    default: {
+                        if (!s.ts)
+                            return 0;
+                        const r = ts_parse_as_expr(s);
+                        if (r <= 0)
+                            return r;
+                        continue;
+                    }
                 }
                 break;
             case 5:
@@ -4307,8 +6386,19 @@ function js_parse_cond_expr(s, parse_flags) {
         if (next_token(s))
             return -1;
         const label1 = emit_goto(s, 107 /* OP.if_false */, -1);
-        if (js_parse_assign_expr(s))
+        if (s.ts) {
+            /* TypeScript: an arrow function with a return type in the true branch must be
+               followed by the ':' of the conditional */
+            const saved = s.ts_cond_true;
+            s.ts_cond_true = true;
+            const r = js_parse_assign_expr2(s, PF_IN_ACCEPTED);
+            s.ts_cond_true = saved;
+            if (r)
+                return -1;
+        }
+        else if (js_parse_assign_expr(s)) {
             return -1;
+        }
         if (js_parse_expect(s, 58))
             return -1;
         const label2 = emit_goto(s, 109 /* OP.goto */, -1);
@@ -4441,7 +6531,10 @@ function js_parse_assign_expr2(s, parse_flags) {
         }
         return 0;
     }
-    else if (tv(s) === 40 && js_parse_skip_parens_token(s, null, true) === -92 /* TOK.ARROW */) {
+    else if (tv(s) === 40 && js_arrow_ahead(s)) {
+        return js_parse_function_decl(s, 3 /* JSParseFunctionEnum.ARROW */, 0 /* JSFunctionKind.NORMAL */, JS_ATOM_NULL, s.token.ptr);
+    }
+    else if (s.ts && tv(s) === 60 && ts_generic_arrow_ahead(s)) {
         return js_parse_function_decl(s, 3 /* JSParseFunctionEnum.ARROW */, 0 /* JSFunctionKind.NORMAL */, JS_ATOM_NULL, s.token.ptr);
     }
     else if (token_is_pseudo_keyword(s, JS_ATOM_async)) {
@@ -4452,7 +6545,7 @@ function js_parse_assign_expr2(s, parse_flags) {
             const pos = js_parse_get_pos(s);
             if (next_token(s))
                 return -1;
-            if ((tv(s) === 40 && js_parse_skip_parens_token(s, null, true) === -92 /* TOK.ARROW */) ||
+            if ((tv(s) === 40 && js_arrow_ahead(s)) || (s.ts && tv(s) === 60 && ts_generic_arrow_ahead(s)) ||
                 (tv(s) === -125 /* TOK.IDENT */ && !s.token.is_reserved && peek_token(s, true) === -92 /* TOK.ARROW */)) {
                 return js_parse_function_decl(s, 3 /* JSParseFunctionEnum.ARROW */, 2 /* JSFunctionKind.ASYNC */, JS_ATOM_NULL, source_ptr);
             }
@@ -4705,8 +6798,17 @@ function js_parse_var(s, parse_flags, tok, export_flag) {
                 return js_parse_error(s, "'let' is not a valid lexical identifier");
             if (next_token(s))
                 return -1;
+            if (s.ts && (tv(s) === 33 || tv(s) === 58)) {
+                /* let x!: T */
+                if (tv(s) === 33 && next_token(s))
+                    return -1;
+                if (tv(s) === 58 && ts_parse_annotation(s))
+                    return -1;
+            }
             if (js_define_var(s, name, tok))
                 return -1;
+            if (export_flag && add_local_export(s, name))
+                return -1;
             if (tv(s) === 61 /* = */) {
                 if (next_token(s))
                     return -1;
@@ -4746,7 +6848,9 @@ function js_parse_var(s, parse_flags, tok, export_flag) {
         }
         else {
             const bits = { bits: 0 };
-            if ((tv(s) === 91 || tv(s) === 123) && js_parse_skip_parens_token(s, bits, false) === 61) {
+            let next_tok;
+            if ((tv(s) === 91 || tv(s) === 123) &&
+                ((next_tok = js_parse_skip_parens_token(s, bits, false)) === 61 || (next_tok === 58 && s.ts))) {
                 emit_op(s, 6 /* OP.undefined */);
                 if (js_parse_destructuring_element(s, tok, 0, true, bits.bits & SKIP_HAS_ELLIPSIS, true, export_flag) < 0)
                     return -1;
@@ -5040,6 +7144,14 @@ function js_parse_statement_or_decl(s, decl_mask) {
             return 0;
         }
     }
+    if (s.ts) {
+        /* TypeScript-only statements are skipped; `abstract class` continues as a class */
+        const r = ts_parse_statement(s);
+        if (r < 0)
+            return -1;
+        if (r > 0)
+            return 0;
+    }
     let tok = tv(s);
     switch (tok) {
         case 123: /* { */
@@ -5440,7 +7552,11 @@ function js_parse_statement_or_decl(s, decl_mask) {
                     }
                     else {
                         const name = s.token.atom;
-                        if (next_token(s) || js_define_var(s, name, -61 /* TOK.CATCH */) < 0)
+                        if (next_token(s))
+                            return -1;
+                        if (s.ts && tv(s) === 58 && ts_parse_annotation(s))
+                            return -1;
+                        if (js_define_var(s, name, -61 /* TOK.CATCH */) < 0)
                             return -1;
                         /* store the exception value in the catch variable */
                         emit_op(s, 187 /* OP.scope_put_var */);
@@ -5624,10 +7740,22 @@ function js_parse_expr_statement(s) {
     return 0;
 }
 function js_parse_assign_expr(s) {
+    if (s.ts_cond_true) {
+        s.ts_cond_true = false;
+        const r = js_parse_assign_expr2(s, PF_IN_ACCEPTED);
+        s.ts_cond_true = true;
+        return r;
+    }
     return js_parse_assign_expr2(s, PF_IN_ACCEPTED);
 }
 /* allowed parse_flags: PF_IN_ACCEPTED */
 function js_parse_expr2(s, parse_flags) {
+    if (s.ts_cond_true) {
+        s.ts_cond_true = false;
+        const r = js_parse_expr2(s, parse_flags);
+        s.ts_cond_true = true;
+        return r;
+    }
     let comma = false;
     for (;;) {
         if (js_parse_assign_expr2(s, parse_flags))
@@ -5799,6 +7927,10 @@ function js_parse_class(s, is_class_expr, export_flag) {
         else
             class_var_name = class_name;
     }
+    if (s.ts && tv(s) === 60 && !ts_skip_type_params(s)) {
+        ts_error(s, 'invalid type parameters');
+        return fail();
+    }
     push_scope(s);
     if (tv(s) === -52 /* TOK.EXTENDS */) {
         class_flags = JS_DEFINE_CLASS_HAS_HERITAGE;
@@ -5806,10 +7938,24 @@ function js_parse_class(s, is_class_expr, export_flag) {
             return fail();
         if (js_parse_left_hand_side_expr(s))
             return fail();
+        /* class C extends B<T> */
+        if (s.ts && (tv(s) === 60 || tv(s) === -106 /* TOK.SHL */) && !ts_skip_type_args(s)) {
+            ts_error(s, 'invalid type arguments');
+            return fail();
+        }
     }
     else {
         emit_op(s, 6 /* OP.undefined */);
     }
+    if (s.ts && ts_word(s, JS_ATOM_implements)) {
+        /* implements I, J<T> */
+        do {
+            if (!ts_next(s) || !ts_skip_type(s)) {
+                ts_error(s, 'type expected');
+                return fail();
+            }
+        } while (tv(s) === 44);
+    }
     /* add a 'const' definition for the class name */
     if (class_name !== JS_ATOM_NULL) {
         if (define_var(s, fd, class_name, 2 /* JSVarDefEnum.CONST */) < 0)
@@ -5841,17 +7987,21 @@ function js_parse_class(s, is_class_expr, export_flag) {
                 return fail();
             continue;
         }
+        /* TypeScript modifiers; declare and abstract members are erased */
+        let ts_erase = 0;
+        if (s.ts && (ts_erase = ts_parse_class_modifiers(s)) < 0)
+            return fail();
         let is_static = false;
         if (tv(s) === -42 /* TOK.STATIC */) {
             const next = peek_token(s, true);
-            if (!(next === 59 || next === 125 || next === 40 || next === 61))
+            if (!(next === 59 || next === 125 || next === 40 || next === 61 || (s.ts && (next === 58 || next === 63 || next === 33 || next === 60))))
                 is_static = true;
         }
         let prop_type = -1;
         if (is_static) {
             if (next_token(s))
                 return fail();
-            if (tv(s) === 123) {
+            if (tv(s) === 123 && !ts_erase) {
                 const cf = class_fields[1];
                 if (!cf.fields_init_fd) {
                     if (emit_class_init_start(s, cf))
@@ -5880,6 +8030,13 @@ function js_parse_class(s, is_class_expr, export_flag) {
                 s.cur_func = s.cur_func.parent;
                 continue;
             }
+            if (s.ts) {
+                const r = ts_parse_class_modifiers(s);
+                if (r < 0)
+                    return fail();
+                if (r > 0)
+                    ts_erase = 1;
+            }
             /* allow "static" field name */
             if (tv(s) === 59 || tv(s) === 61) {
                 is_static = false;
@@ -5887,6 +8044,12 @@ function js_parse_class(s, is_class_expr, export_flag) {
                 prop_type = PROP_TYPE_IDENT;
             }
         }
+        if (s.ts && prop_type < 0 && (ts_erase || ts_is_index_signature(s) || ts_class_member_is_signature(s))) {
+            /* erased: declare field, abstract member, index signature, overload signature */
+            if (ts_skip_class_member(s))
+                return fail();
+            continue;
+        }
         if (is_static)
             emit_op(s, 27 /* OP.swap */);
         const start_ptr = s.token.ptr;
@@ -5897,6 +8060,13 @@ function js_parse_class(s, is_class_expr, export_flag) {
                 return fail();
             name = out.name;
         }
+        if (s.ts) {
+            /* x?: T, x!: T, m?() {} */
+            if ((tv(s) === 63 || tv(s) === 33) && next_token(s))
+                return fail();
+            if (tv(s) === 58 && (prop_type & ~PROP_TYPE_PRIVATE) === PROP_TYPE_IDENT && ts_parse_annotation(s))
+                return fail();
+        }
         const is_private = prop_type & PROP_TYPE_PRIVATE;
         prop_type &= ~PROP_TYPE_PRIVATE;
         if ((name === JS_ATOM_constructor && !is_static && prop_type !== PROP_TYPE_IDENT) ||
@@ -6453,6 +8623,13 @@ function js_parse_function_decl2(s, func_type, func_kind, func_name, ptr, export
     if (func_type === 8 /* JSParseFunctionEnum.CLASS_CONSTRUCTOR */) {
         emit_class_field_init(s);
     }
+    if (s.ts && tv(s) === 60) {
+        /* function f<T>(...), m<T>(...), <T>(...) => ... */
+        if (!ts_skip_type_params(s)) {
+            ts_error(s, 'invalid type parameters');
+            return fail();
+        }
+    }
     /* parse arguments */
     fd.has_simple_parameter_list = true;
     fd.has_parameter_expressions = false;
@@ -6487,6 +8664,22 @@ function js_parse_function_decl2(s, func_type, func_kind, func_name, ptr, export
         }
         while (tv(s) !== 41) {
             let rest = false;
+            if (s.ts) {
+                if (tv(s) === -78 /* TOK.THIS */ && ts_peek(s).val === 58) {
+                    /* this parameter: f(this: T, ...) */
+                    if (next_token(s) || ts_parse_annotation(s))
+                        return fail();
+                    if (tv(s) === 41)
+                        break;
+                    if (js_parse_expect(s, 44))
+                        return fail();
+                    continue;
+                }
+                if (ts_is_param_modifier(s)) {
+                    ts_unsupported(s, 'parameter property', s.token.ptr);
+                    return fail();
+                }
+            }
             if (tv(s) === -91 /* TOK.ELLIPSIS */) {
                 if (func_type === 5 /* JSParseFunctionEnum.SETTER */) {
                     js_parse_error(s, 'invalid number of arguments for getter or setter');
@@ -6539,6 +8732,13 @@ function js_parse_function_decl2(s, func_type, func_kind, func_name, ptr, export
                     return fail();
                 if (next_token(s))
                     return fail();
+                if (s.ts && (tv(s) === 63 || tv(s) === 58)) {
+                    /* x?: T */
+                    if (tv(s) === 63 && next_token(s))
+                        return fail();
+                    if (tv(s) === 58 && ts_parse_annotation(s))
+                        return fail();
+                }
                 if (rest) {
                     emit_op(s, 13 /* OP.rest */);
                     emit_u16(s, idx);
@@ -6639,6 +8839,13 @@ function js_parse_function_decl2(s, func_type, func_kind, func_name, ptr, export
     }
     if (next_token(s))
         return fail();
+    if (s.ts && tv(s) === 58) {
+        /* return type */
+        if (!ts_next(s) || !ts_skip_return_type(s)) {
+            ts_error(s, 'type expected');
+            return fail();
+        }
+    }
     /* generator function: yield after the parameters are evaluated */
     if (func_kind === 1 /* JSFunctionKind.GENERATOR */ || func_kind === 3 /* JSFunctionKind.ASYNC_GENERATOR */)
         emit_op(s, 137 /* OP.initial_yield */);
@@ -6795,16 +9002,572 @@ function js_parse_function_decl2(s, func_type, func_kind, func_name, ptr, export
 function js_parse_function_decl(s, func_type, func_kind, func_name, ptr) {
     return js_parse_function_decl2(s, func_type, func_kind, func_name, ptr, 0 /* JSParseExportEnum.NONE */, null);
 }
+/* ---------------------------------------------------------------------
+   Modules: import and export declarations (quickjs.c js_parse_import,
+   js_parse_export and their helpers)
+   --------------------------------------------------------------------- */
+/* a canonical key for import attributes, so that equal requests share an entry */
+function attributes_key(attrs) {
+    if (attrs === null)
+        return '';
+    const keys = Object.keys(attrs).sort();
+    return JSON.stringify(keys.map(k => [k, attrs[k]]));
+}
+function add_req_module_entry(m, module_name, attributes) {
+    /* no need to add the module request if it is already present */
+    const key = attributes_key(attributes);
+    for (let i = 0; i < m.req_module_entries.length; i++) {
+        const rme = m.req_module_entries[i];
+        if (rme.module_name === module_name && attributes_key(rme.attributes) === key)
+            return i;
+    }
+    m.req_module_entries.push(new JSReqModuleEntry(module_name, attributes));
+    return m.req_module_entries.length - 1;
+}
+function find_export_entry(m, export_name) {
+    for (const me of m.export_entries)
+        if (me.export_name === export_name)
+            return me;
+    return null;
+}
+function add_export_entry(s, m, local_name, export_name, export_type) {
+    if (find_export_entry(m, export_name)) {
+        js_parse_error(s, `duplicate exported name '${JS_AtomGetStr(s.ctx, export_name)}'`);
+        return null;
+    }
+    const me = new JSExportEntry(local_name, export_name, export_type);
+    m.export_entries.push(me);
+    return me;
+}
+function add_star_export_entry(m, req_module_idx) {
+    m.star_export_entries.push(new JSStarExportEntry(req_module_idx));
+}
+/* export entries of a declaration being parsed (`export let`, `export function`, ...) */
+function add_local_export(s, name) {
+    const m = s.cur_func.module;
+    if (!m)
+        return js_parse_error(s, 'export outside of a module');
+    return add_export_entry(s, m, name, name, 0 /* JSExportType.LOCAL */) ? 0 : -1;
+}
+function add_import(s, m, local_name, import_name, is_star) {
+    const fd = s.cur_func;
+    if (local_name === JS_ATOM_arguments || local_name === JS_ATOM_eval)
+        return js_parse_error(s, 'invalid import binding');
+    for (const cv of fd.closure_var) {
+        if (cv.var_name === local_name)
+            return js_parse_error(s, 'duplicate import binding');
+    }
+    /* a namespace import gets its own variable, set when the module is linked */
+    const is_local = is_star;
+    const var_idx = add_closure_var(s.ctx, fd, is_local, false, m.import_entries.length, local_name, true, true, 0 /* JSVarKind.NORMAL */);
+    if (var_idx < 0)
+        return -1;
+    m.import_entries.push(new JSImportEntry(var_idx, is_star, import_name));
+    return 0;
+}
+/* a string used as a module export name must be well formed (no lone surrogates) */
+function is_well_formed_string(str) {
+    for (let i = 0; i < str.length; i++) {
+        const c = str.charCodeAt(i);
+        if (c >= 0xd800 && c <= 0xdbff) {
+            const d = str.charCodeAt(i + 1);
+            if (!(d >= 0xdc00 && d <= 0xdfff))
+                return false;
+            i++;
+        }
+        else if (c >= 0xdc00 && c <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+/* ModuleExportName: an IdentifierName or a string. Returns the atom (JS_ATOM_NULL on error);
+   out.kind: 0 identifier, 1 reserved word, 2 string */
+function js_parse_module_export_name(s, out) {
+    let atom;
+    if (tv(s) === -127 /* TOK.STRING */) {
+        if (!is_well_formed_string(s.token.str)) {
+            js_parse_error(s, 'invalid module export name');
+            return JS_ATOM_NULL;
+        }
+        atom = JS_NewAtom(s.ctx, s.token.str);
+        out.kind = 2;
+    }
+    else if (token_is_ident_or_keyword(tv(s)) || token_is_ident(tv(s))) {
+        atom = s.token.atom;
+        out.kind = token_is_ident(tv(s)) && !s.token.is_reserved ? 0 : 1;
+    }
+    else {
+        js_parse_error(s, 'identifier expected');
+        return JS_ATOM_NULL;
+    }
+    if (next_token(s))
+        return JS_ATOM_NULL;
+    return atom;
+}
+/* the binding identifier of an import (after `as`, or a shorthand name) */
+function js_parse_import_binding(s) {
+    if (!token_is_ident(tv(s))) {
+        js_parse_error(s, 'identifier expected');
+        return JS_ATOM_NULL;
+    }
+    if (s.token.is_reserved) {
+        js_parse_error_reserved_identifier(s);
+        return JS_ATOM_NULL;
+    }
+    const atom = s.token.atom;
+    if (next_token(s))
+        return JS_ATOM_NULL;
+    return atom;
+}
+/* `with { type: "json" }` after a module specifier: the attributes, or null. Returns -1 on error */
+function js_parse_with_clause(s, out) {
+    out.attributes = null;
+    if (tv(s) !== -57 /* TOK.WITH */)
+        return 0;
+    if (next_token(s))
+        return -1;
+    if (js_parse_expect(s, 123))
+        return -1;
+    const attrs = Object.create(null);
+    while (tv(s) !== 125) {
+        let key;
+        if (tv(s) === -127 /* TOK.STRING */)
+            key = s.token.str;
+        else if (token_is_ident_or_keyword(tv(s)) || token_is_ident(tv(s)))
+            key = JS_AtomGetStr(s.ctx, s.token.atom);
+        else
+            return js_parse_error(s, 'identifier or string expected');
+        if (Object.prototype.hasOwnProperty.call(attrs, key))
+            return js_parse_error(s, `duplicate import attribute '${key}'`);
+        if (next_token(s))
+            return -1;
+        if (js_parse_expect(s, 58))
+            return -1;
+        if (tv(s) !== -127 /* TOK.STRING */)
+            return js_parse_error(s, 'string expected');
+        attrs[key] = s.token.str;
+        if (next_token(s))
+            return -1;
+        if (tv(s) !== 44)
+            break;
+        if (next_token(s))
+            return -1;
+    }
+    if (js_parse_expect(s, 125))
+        return -1;
+    out.attributes = attrs;
+    return 0;
+}
+/* `from "specifier" [with { ... }]`: the request index, or -1 */
+function js_parse_from_clause(s, m) {
+    if (!token_is_pseudo_keyword(s, JS_ATOM_from))
+        return js_parse_error(s, 'from clause expected');
+    if (next_token(s))
+        return -1;
+    return js_parse_module_specifier(s, m);
+}
+function js_parse_module_specifier(s, m) {
+    if (tv(s) !== -127 /* TOK.STRING */)
+        return js_parse_error(s, 'string expected');
+    const module_name = JS_NewAtom(s.ctx, s.token.str);
+    if (next_token(s))
+        return -1;
+    const w = { attributes: null };
+    if (js_parse_with_clause(s, w))
+        return -1;
+    return add_req_module_entry(m, module_name, w.attributes);
+}
+/* a TypeScript `type` modifier on an import or export specifier (`{ type A }`): true if the
+   specifier is type only and was skipped. TypeScript's rules:
+     { type }          name `type`            { type as }       type-only `as`
+     { type as as }    `type` aliased `as`    { type as as as } type-only `as` aliased `as` */
+function ts_skip_type_specifier(s) {
+    if (!s.ts || !token_is_pseudo_keyword(s, ts_atoms(s).type))
+        return false;
+    const p = ts_save(s);
+    const ok = () => { return true; };
+    if (!ts_next(s)) {
+        ts_restore(s, p);
+        return false;
+    }
+    const end = () => tv(s) === 44 || tv(s) === 125;
+    if (end()) {
+        ts_restore(s, p);
+        return false;
+    } /* { type } */
+    if (token_is_pseudo_keyword(s, JS_ATOM_as)) {
+        if (!ts_next(s)) {
+            ts_restore(s, p);
+            return false;
+        }
+        if (end())
+            return ok(); /* { type as }: type-only import of `as` */
+        if (token_is_pseudo_keyword(s, JS_ATOM_as)) {
+            if (!ts_next(s)) {
+                ts_restore(s, p);
+                return false;
+            }
+            if (end()) {
+                ts_restore(s, p);
+                return false;
+            } /* { type as as }: `type` aliased `as` */
+            /* { type as as x }: type-only `as` aliased `x` */
+            if (!ts_next(s)) {
+                ts_restore(s, p);
+                return false;
+            }
+            return ok();
+        }
+        /* { type as x }: `type` aliased `x` */
+        ts_restore(s, p);
+        return false;
+    }
+    /* { type A [as B] } */
+    if (!ts_next(s)) {
+        ts_restore(s, p);
+        return false;
+    }
+    if (token_is_pseudo_keyword(s, JS_ATOM_as)) {
+        if (!ts_next(s) || !ts_next(s)) {
+            ts_restore(s, p);
+            return false;
+        }
+    }
+    return ok();
+}
+function js_parse_import(s) {
+    const m = s.cur_func.module;
+    if (next_token(s))
+        return -1;
+    const first_import = m.import_entries.length;
+    let idx;
+    if (tv(s) === -127 /* TOK.STRING */) {
+        /* import "m" */
+        idx = js_parse_module_specifier(s, m);
+        if (idx < 0)
+            return -1;
+    }
+    else {
+        let need_from = true;
+        if (token_is_ident(tv(s))) {
+            /* default import */
+            const local_name = js_parse_import_binding(s);
+            if (local_name === JS_ATOM_NULL)
+                return -1;
+            if (add_import(s, m, local_name, JS_ATOM_default, false))
+                return -1;
+            if (tv(s) !== 44)
+                need_from = false;
+            else if (next_token(s))
+                return -1;
+        }
+        if (need_from || tv(s) === 42 || tv(s) === 123) {
+            if (tv(s) === 42) {
+                /* namespace import */
+                if (next_token(s))
+                    return -1;
+                if (!token_is_pseudo_keyword(s, JS_ATOM_as))
+                    return js_parse_error(s, "expecting 'as'");
+                if (next_token(s))
+                    return -1;
+                const local_name = js_parse_import_binding(s);
+                if (local_name === JS_ATOM_NULL)
+                    return -1;
+                if (add_import(s, m, local_name, JS_ATOM__star_, true))
+                    return -1;
+            }
+            else if (tv(s) === 123) {
+                if (next_token(s))
+                    return -1;
+                while (tv(s) !== 125) {
+                    if (ts_skip_type_specifier(s)) {
+                        if (tv(s) !== 44)
+                            break;
+                        if (next_token(s))
+                            return -1;
+                        continue;
+                    }
+                    const k = { kind: 0 };
+                    const start = s.token.ptr;
+                    const import_name = js_parse_module_export_name(s, k);
+                    if (import_name === JS_ATOM_NULL)
+                        return -1;
+                    let local_name;
+                    if (token_is_pseudo_keyword(s, JS_ATOM_as)) {
+                        if (next_token(s))
+                            return -1;
+                        local_name = js_parse_import_binding(s);
+                        if (local_name === JS_ATOM_NULL)
+                            return -1;
+                    }
+                    else {
+                        if (k.kind !== 0)
+                            return js_parse_error_pos(s, start, k.kind === 2 ? "expecting 'as'" : 'identifier expected');
+                        local_name = import_name;
+                    }
+                    if (add_import(s, m, local_name, import_name, false))
+                        return -1;
+                    if (tv(s) !== 44)
+                        break;
+                    if (next_token(s))
+                        return -1;
+                }
+                if (js_parse_expect(s, 125))
+                    return -1;
+            }
+            else {
+                return js_parse_error(s, 'identifier expected');
+            }
+        }
+        idx = js_parse_from_clause(s, m);
+        if (idx < 0)
+            return -1;
+    }
+    for (let i = first_import; i < m.import_entries.length; i++)
+        m.import_entries[i].req_module_idx = idx;
+    return js_parse_expect_semi(s);
+}
+/* the name of the declaration after `function` / `async function` / `class`, if any */
+function export_decl_name(s) {
+    const p = ts_save(s);
+    let name = JS_ATOM_NULL;
+    if (token_is_pseudo_keyword(s, JS_ATOM_async) && !ts_next(s)) {
+        ts_restore(s, p);
+        return name;
+    }
+    if (tv(s) === -59 /* TOK.FUNCTION */ || tv(s) === -56 /* TOK.CLASS */) {
+        if (ts_next(s) && (tv(s) !== 42 || ts_next(s)) && (token_is_ident(tv(s)) && !s.token.is_reserved))
+            name = s.token.atom;
+    }
+    ts_restore(s, p);
+    return name;
+}
+/* skip a TypeScript `abstract` before `class`: -1 on error */
+function ts_skip_abstract(s) {
+    if (s.ts && token_is_pseudo_keyword(s, ts_atoms(s).abstract) && peek_token(s, true) === -56 /* TOK.CLASS */)
+        return next_token(s);
+    return 0;
+}
+function js_parse_export(s) {
+    const fd = s.cur_func;
+    const m = fd.module;
+    if (next_token(s))
+        return -1;
+    /* TypeScript: `export abstract class` is a class */
+    if (ts_skip_abstract(s))
+        return -1;
+    const tok = tv(s);
+    const is_async_function = token_is_pseudo_keyword(s, JS_ATOM_async) && peek_token(s, true) === -59 /* TOK.FUNCTION */;
+    if (tok === -56 /* TOK.CLASS */) {
+        const name = export_decl_name(s);
+        if (js_parse_class(s, false, 1 /* JSParseExportEnum.NAMED */))
+            return -1;
+        return add_local_export(s, name);
+    }
+    if (tok === -59 /* TOK.FUNCTION */ || is_async_function) {
+        const name = export_decl_name(s);
+        if (js_parse_function_decl2(s, 0 /* JSParseFunctionEnum.STATEMENT */, 0 /* JSFunctionKind.NORMAL */, JS_ATOM_NULL, s.token.ptr, 1 /* JSParseExportEnum.NAMED */, null))
+            return -1;
+        return add_local_export(s, name);
+    }
+    switch (tok) {
+        case 123: { /* { */
+            const first_export = m.export_entries.length;
+            let invalid_local = -1; /* position of a local name that is not an identifier reference */
+            if (next_token(s))
+                return -1;
+            while (tv(s) !== 125) {
+                if (ts_skip_type_specifier(s)) {
+                    if (tv(s) !== 44)
+                        break;
+                    if (next_token(s))
+                        return -1;
+                    continue;
+                }
+                const k = { kind: 0 };
+                const start = s.token.ptr;
+                const local_name = js_parse_module_export_name(s, k);
+                if (local_name === JS_ATOM_NULL)
+                    return -1;
+                if (k.kind !== 0 && invalid_local < 0)
+                    invalid_local = start;
+                let export_name = local_name;
+                if (token_is_pseudo_keyword(s, JS_ATOM_as)) {
+                    if (next_token(s))
+                        return -1;
+                    export_name = js_parse_module_export_name(s, { kind: 0 });
+                    if (export_name === JS_ATOM_NULL)
+                        return -1;
+                }
+                if (!add_export_entry(s, m, local_name, export_name, 0 /* JSExportType.LOCAL */))
+                    return -1;
+                if (tv(s) !== 44)
+                    break;
+                if (next_token(s))
+                    return -1;
+            }
+            if (js_parse_expect(s, 125))
+                return -1;
+            if (token_is_pseudo_keyword(s, JS_ATOM_from)) {
+                const idx = js_parse_from_clause(s, m);
+                if (idx < 0)
+                    return -1;
+                for (let i = first_export; i < m.export_entries.length; i++) {
+                    const me = m.export_entries[i];
+                    me.export_type = 1 /* JSExportType.INDIRECT */;
+                    me.req_module_idx = idx;
+                }
+            }
+            else if (invalid_local >= 0) {
+                return js_parse_error_pos(s, invalid_local, 'identifier expected');
+            }
+            break;
+        }
+        case 42: { /* * */
+            if (next_token(s))
+                return -1;
+            if (token_is_pseudo_keyword(s, JS_ATOM_as)) {
+                /* export * as ns from "m" */
+                if (next_token(s))
+                    return -1;
+                const export_name = js_parse_module_export_name(s, { kind: 0 });
+                if (export_name === JS_ATOM_NULL)
+                    return -1;
+                const idx = js_parse_from_clause(s, m);
+                if (idx < 0)
+                    return -1;
+                const me = add_export_entry(s, m, JS_ATOM__star_, export_name, 1 /* JSExportType.INDIRECT */);
+                if (!me)
+                    return -1;
+                me.req_module_idx = idx;
+            }
+            else {
+                const idx = js_parse_from_clause(s, m);
+                if (idx < 0)
+                    return -1;
+                add_star_export_entry(m, idx);
+            }
+            break;
+        }
+        case -64 /* TOK.DEFAULT */: {
+            if (next_token(s))
+                return -1;
+            if (ts_skip_abstract(s))
+                return -1;
+            if (tv(s) === -56 /* TOK.CLASS */) {
+                let name = export_decl_name(s);
+                if (js_parse_class(s, false, 2 /* JSParseExportEnum.DEFAULT */))
+                    return -1;
+                if (name === JS_ATOM_NULL)
+                    name = JS_ATOM__default_;
+                return add_export_entry(s, m, name, JS_ATOM_default, 0 /* JSExportType.LOCAL */) ? 0 : -1;
+            }
+            if (tv(s) === -59 /* TOK.FUNCTION */ || (token_is_pseudo_keyword(s, JS_ATOM_async) && peek_token(s, true) === -59 /* TOK.FUNCTION */)) {
+                let name = export_decl_name(s);
+                if (js_parse_function_decl2(s, 0 /* JSParseFunctionEnum.STATEMENT */, 0 /* JSFunctionKind.NORMAL */, JS_ATOM_NULL, s.token.ptr, 2 /* JSParseExportEnum.DEFAULT */, null))
+                    return -1;
+                if (name === JS_ATOM_NULL)
+                    name = JS_ATOM__default_;
+                return add_export_entry(s, m, name, JS_ATOM_default, 0 /* JSExportType.LOCAL */) ? 0 : -1;
+            }
+            if (js_parse_assign_expr(s))
+                return -1;
+            /* set the name of anonymous functions */
+            set_object_name(s, JS_ATOM_default);
+            /* store the value in the _default_ variable and export it */
+            const local_name = JS_ATOM__default_;
+            if (define_var(s, fd, local_name, 1 /* JSVarDefEnum.LET */) < 0)
+                return -1;
+            emit_op(s, 191 /* OP.scope_put_var_init */);
+            emit_atom(s, local_name);
+            emit_u16(s, 0);
+            if (!add_export_entry(s, m, local_name, JS_ATOM_default, 0 /* JSExportType.LOCAL */))
+                return -1;
+            break;
+        }
+        case -79 /* TOK.VAR */:
+        case -47 /* TOK.LET */:
+        case -55 /* TOK.CONST */:
+            if (next_token(s))
+                return -1;
+            if (js_parse_var(s, PF_IN_ACCEPTED, tok, true))
+                return -1;
+            break;
+        default:
+            return js_parse_error(s, 'invalid export syntax');
+    }
+    return js_parse_expect_semi(s);
+}
+/* Add the module global variables as closure variables of the module function, turn the
+   exports of imported bindings into indirect exports, and resolve the local exports
+   (quickjs.c add_module_variables) */
+function add_module_variables(ctx, fd) {
+    const m = fd.module;
+    /* the imported variables were added as closure variables in js_parse_import(); add the
+       module global variables */
+    for (let i = 0; i < fd.global_vars.length; i++) {
+        const hf = fd.global_vars[i];
+        for (const cv of fd.closure_var) {
+            if (cv.var_name === hf.var_name) {
+                JS_ThrowSyntaxError(ctx, `invalid redefinition of imported binding '${JS_AtomGetStr(ctx, hf.var_name)}'`);
+                return -1;
+            }
+        }
+    }
+    for (let i = 0; i < fd.global_vars.length; i++) {
+        const hf = fd.global_vars[i];
+        if (add_closure_var(ctx, fd, true, false, i, hf.var_name, hf.is_const, hf.is_lexical, 0 /* JSVarKind.NORMAL */) < 0)
+            return -1;
+    }
+    /* an export of an imported binding is an indirect export (ParseModule) */
+    for (const me of m.export_entries) {
+        if (me.export_type !== 0 /* JSExportType.LOCAL */)
+            continue;
+        const mi = m.import_entries.find(e => fd.closure_var[e.var_idx].var_name === me.local_name);
+        if (mi && !mi.is_star) {
+            me.export_type = 1 /* JSExportType.INDIRECT */;
+            me.req_module_idx = mi.req_module_idx;
+            me.local_name = mi.import_name;
+        }
+    }
+    /* resolve the variable names of the local exports */
+    for (const me of m.export_entries) {
+        if (me.export_type !== 0 /* JSExportType.LOCAL */)
+            continue;
+        const idx = fd.closure_var.findIndex(cv => cv.var_name === me.local_name);
+        if (idx < 0) {
+            JS_ThrowSyntaxError(ctx, `exported variable '${JS_AtomGetStr(ctx, me.local_name)}' does not exist`);
+            return -1;
+        }
+        me.var_idx = idx;
+    }
+    return 0;
+}
 function js_parse_source_element(s) {
+    if (s.ts && (tv(s) === -59 /* TOK.FUNCTION */ || token_is_pseudo_keyword(s, JS_ATOM_async))) {
+        /* overload signature */
+        const r = ts_parse_statement(s);
+        if (r < 0)
+            return -1;
+        if (r > 0)
+            return 0;
+    }
     if (tv(s) === -59 /* TOK.FUNCTION */ || (token_is_pseudo_keyword(s, JS_ATOM_async) && peek_token(s, true) === -59 /* TOK.FUNCTION */)) {
         if (js_parse_function_decl(s, 0 /* JSParseFunctionEnum.STATEMENT */, 0 /* JSFunctionKind.NORMAL */, JS_ATOM_NULL, s.token.ptr))
             return -1;
     }
-    else if (tv(s) === -53 /* TOK.EXPORT */ && s.cur_func.module) {
-        return js_parse_error(s, 'modules are not supported');
-    }
-    else if (tv(s) === -51 /* TOK.IMPORT */ && s.cur_func.module) {
-        return js_parse_error(s, 'modules are not supported');
+    else if ((tv(s) === -53 /* TOK.EXPORT */ || (tv(s) === -51 /* TOK.IMPORT */ && peek_token(s, false) !== 40 && peek_token(s, false) !== 46)) &&
+        s.cur_func.module) {
+        if (s.ts) {
+            /* type-only imports and exports, and the rejected forms */
+            const r = ts_parse_statement(s);
+            if (r < 0)
+                return -1;
+            if (r > 0)
+                return 0;
+        }
+        return tv(s) === -53 /* TOK.EXPORT */ ? js_parse_export(s) : js_parse_import(s);
     }
     else {
         if (js_parse_statement_or_decl(s, DECL_MASK_ALL))
@@ -7916,6 +10679,17 @@ function instantiate_hoisted_definitions(ctx, s, bc) {
             bc.put_u16(i);
         }
     }
+    /* the module global variables must be initialized before evaluating the module so that
+       the exported functions are visible if there are cyclic module references */
+    let label_next = -1;
+    if (s.module) {
+        label_next = new_label_fd(s);
+        /* if 'this' is true, initialize the global variables and return */
+        bc.putc(8 /* OP.push_this */);
+        bc.putc(107 /* OP.if_false */);
+        bc.put_u32(label_next);
+        update_label(s, label_next, 1);
+    }
     /* add the global variables (only happens if s->is_global_var is true) */
     for (let i = 0; i < s.global_vars.length; i++) {
         const hf = s.global_vars[i];
@@ -7993,6 +10767,12 @@ function instantiate_hoisted_definitions(ctx, s, bc) {
             }
         }
     }
+    if (s.module) {
+        bc.putc(41 /* OP.return_undef */);
+        bc.putc(184 /* OP.label */);
+        bc.put_u32(label_next);
+        s.label_slots[label_next].pos2 = bc.size;
+    }
     s.global_vars = [];
 }
 function skip_dead_code(s, bc_buf, bc_len, pos, linep) {
@@ -9607,6 +12387,10 @@ export function js_create_function(ctx, fd, ps) {
        lookup is done. */
     if (fd.has_eval_call)
         add_eval_variables(ctx, fd);
+    if (fd.module) {
+        if (add_module_variables(ctx, fd))
+            return null;
+    }
     /* first create all the child functions */
     for (const fd1 of fd.child_list) {
         const cpool_idx = fd1.parent_cpool_idx;
@@ -9684,9 +12468,12 @@ export function __JS_EvalInternal(ctx, this_obj, input, filename, flags, scope_i
     else {
         if (flags & JS_EVAL_FLAG_STRICT)
             js_mode |= JS_MODE_STRICT;
-        if (eval_type === JS_EVAL_TYPE_MODULE) {
-            return JS_ThrowSyntaxError(ctx, 'modules are not supported');
-        }
+    }
+    let m = null;
+    if (eval_type === JS_EVAL_TYPE_MODULE) {
+        m = new JSModuleDef(JS_NewAtom(ctx, filename));
+        m.realm = ctx;
+        js_mode |= JS_MODE_STRICT;
     }
     const fd = js_new_function_def(ctx, null, true, false, filename, s.buf_start);
     s.cur_func = fd;
@@ -9710,20 +12497,33 @@ export function __JS_EvalInternal(ctx, this_obj, input, filename, flags, scope_i
         if (add_closure_variables(ctx, fd, b, scope_idx))
             return JS_EXCEPTION;
     }
-    if (flags & JS_EVAL_FLAG_ASYNC) {
+    fd.module = m;
+    if (m !== null || (flags & JS_EVAL_FLAG_ASYNC)) {
         fd.in_function_body = true;
         fd.func_kind = 2 /* JSFunctionKind.ASYNC */;
     }
-    s.is_module = false;
+    s.is_module = (m !== null);
     s.allow_html_comments = !s.is_module;
+    s.ts = (flags & JS_EVAL_FLAG_STRIP_TYPES) !== 0;
+    s.jsx = (flags & JS_EVAL_FLAG_JSX) !== 0;
     push_scope(s); /* body scope */
     fd.body_scope = fd.scope_level;
     if (js_parse_program(s))
         return JS_EXCEPTION;
+    if (m !== null)
+        m.has_tla = fd.has_await;
+    if (m !== null && s.jsx_runtime !== null && s.jsx_runtime.requests.length)
+        jsx_hoist_requests(m, s.jsx_runtime.requests);
     /* create the function object and all the enclosed functions */
     const fb = js_create_function(ctx, fd, s);
     if (!fb)
         return JS_EXCEPTION;
+    if (m !== null) {
+        /* the module record stands for the compiled module (JS_TAG_MODULE in C) */
+        if (hooks.js_module_compiled === null)
+            return JS_ThrowSyntaxError(ctx, 'modules are not supported in this build');
+        return hooks.js_module_compiled(ctx, m, fb, flags);
+    }
     if (flags & JS_EVAL_FLAG_COMPILE_ONLY) {
         return hooks.js_closure(ctx, fb, var_refs, sf);
     }