diff --git a/.gitignore b/.gitignore
index ee8198e9..3797d201 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,5 @@ custom_code.json
 last_commit.txt
 __pycache__/
 .vscode/settings.json
+bin/
+lib/abi
diff --git a/addon.xml b/addon.xml
index 148ecf1b..d1bda1d5 100644
--- a/addon.xml
+++ b/addon.xml
@@ -1,4 +1,4 @@
-<addon id="plugin.video.kod" name="Kodi on Demand" version="1.7.2" provider-name="KoD Team">
+<addon id="plugin.video.kod" name="Kodi on Demand" version="1.7.3" provider-name="KoD Team">
   <requires>
     <!-- <import addon="script.module.libtorrent" optional="true"/> -->
     <import addon="metadata.themoviedb.org"/>
@@ -27,9 +27,7 @@
       <screenshot>resources/media/screenshot-2.png</screenshot>
       <screenshot>resources/media/screenshot-3.png</screenshot>
     </assets>
-      <news>- corretto il playback in tutti i casi (torrent, autoplay, videoteca, libreria ecc..)
-            - piccole migliorie prestazionali nella ricerca globale
-            - fix trailer
+      <news>- fix vari
 </news>
     <description lang="it">Naviga velocemente sul web e guarda i contenuti presenti</description>
     <disclaimer>[COLOR red]The owners and submitters to this addon do not host or distribute any of the content displayed by these addons nor do they have any affiliation with the content providers.[/COLOR]
diff --git a/channels.json b/channels.json
index d0b15016..2b878514 100644
--- a/channels.json
+++ b/channels.json
@@ -22,7 +22,7 @@
         "filmigratis": "https://filmigratis.org",
         "guardaseriecam": "https://guardaserie.cam",
         "guardaserieclick": "https://www.guardaserie.builders",
-        "guardaserieicu": "https://www.youtube.com/watch?v=hV3rZZfkH9Q",
+        "guardaserieicu": "https://guardaserie.cheap",
         "hd4me": "https://hd4me.net",
         "ilcorsaronero": "https://ilcorsaronero.link",
         "ilgeniodellostreaming": "https://ilgeniodellostreaming.re",
@@ -39,6 +39,7 @@
         "serietvsubita": "http://serietvsubita.xyz",
         "serietvu": "https://www.serietvu.live",
         "streamingcommunity": "https://streamingcommunity.art",
+        "streamingita": "https://www.streamingita.pro",
         "streamtime": "https://t.me/s/StreamTime",
         "tantifilm": "https://www.tantifilm.sbs",
         "tapmovie": "https://it.tapmovie.net",
diff --git a/channels/altadefinizionecommunity.py b/channels/altadefinizionecommunity.py
index 944febbf..c74c9067 100644
--- a/channels/altadefinizionecommunity.py
+++ b/channels/altadefinizionecommunity.py
@@ -140,6 +140,7 @@ def peliculas(item):
 
 @support.scrape
 def episodios(item):
+    registerOrLogin()
     logger.debug(item)
     # debug = True
     data = item.data
diff --git a/channels/streamingita.json b/channels/streamingita.json
new file mode 100644
index 00000000..940536e8
--- /dev/null
+++ b/channels/streamingita.json
@@ -0,0 +1,11 @@
+{
+	"id": "streamingita",
+	"name": "StreamingITA",
+	"language": ["ita"],
+	"active": true,
+	"thumbnail": "streamingita.png",
+	"banner": "streamingita.png",
+	"categories": ["tvshow", "movie"],
+	"not_active": ["include_in_newest_peliculas", "include_in_newest_anime", "include_in_newest_series"],
+	"settings": []
+}
diff --git a/channels/streamingita.py b/channels/streamingita.py
new file mode 100644
index 00000000..6a2f8ebf
--- /dev/null
+++ b/channels/streamingita.py
@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------
+# Canale per streamingITA
+# ------------------------------------------------------------
+
+from core import support
+from platformcode import logger, config
+
+host = config.get_channel_url()
+
+
+@support.menu
+def mainlist(item):
+
+    film = ['/film']
+    top = [('Generi', ['/film', 'menu', 'genres']),
+            ('Anno', ['/film', 'menu', 'releases'])]
+    tvshow = ['/tv']
+    search = ''
+    return locals()
+
+
+def search(item, text):
+    logger.info('search', text)
+    item.url = item.url + "/?s=" + text
+    try:
+        return support.dooplay_search(item)
+    except:
+        import sys
+        for line in sys.exc_info():
+            logger.error("%s" % line)
+        return []
+
+
+def peliculas(item):
+    return support.dooplay_peliculas(item, False)
+
+
+def episodios(item):
+    itemlist = support.dooplay_get_episodes(item)
+    return itemlist
+
+
+def findvideos(item):
+    itemlist = []
+    for link in support.dooplay_get_links(item, host):
+        itemlist.append(
+            item.clone(action="play", url=link['url']))
+    # if item.contentType == 'episode':
+    #     linkHead = support.httptools.downloadpage(item.url, only_headers=True).headers['link']
+    #     epId = support.scrapertools.find_single_match(linkHead, r'\?p=([0-9]+)>')
+    #     for link in support.dooplay_get_links(item, host, paramList=[['tv', epId, 1, 'title', 'server']]):
+    #         itemlist.append(
+    #             item.clone(action="play", url=link['url']))
+    # else:
+    #     for link, quality in support.match(item.url, patron="(" + host + """links/[^"]+).*?class="quality">([^<]+)""").matches:
+    #         srv = support.servertools.find_video_items(data=support.httptools.downloadpage(link).data)
+    #         for s in srv:
+    #             s.quality = quality
+    #         itemlist.extend(srv)
+    return support.server(item, itemlist=itemlist)
+
+
+@support.scrape
+def menu(item):
+    action = 'peliculas'
+    # debug = True
+    if item.args in ['genres', 'releases']:
+        patronBlock = r'<nav class="' + item.args + r'">(?P<block>.*?)</nav'
+        patronMenu= r'<a href="(?P<url>[^"]+)"[^>]*>(?P<title>[^<]+)<'
+    else:
+        patronBlock = r'class="main-header">(?P<block>.*?)headitems'
+        patronMenu = r'(?P<url>' + host + r'quality/[^/]+/\?post_type=movies)">(?P<title>[^<]+)'
+    return locals()
diff --git a/channelselector.py b/channelselector.py
index cb72988c..c281eb80 100644
--- a/channelselector.py
+++ b/channelselector.py
@@ -253,7 +253,7 @@ def set_channel_info(parameters):
 def auto_filter(auto_lang=False):
     list_lang = ['ita', 'vos', 'sub-ita']
     if config.get_setting("channel_language") == 'auto' or auto_lang == True:
-        lang = config.get_localized_string(20001)
+        lang = config.get_language()
 
     else:
         lang = config.get_setting("channel_language", default="all")
diff --git a/core/item.py b/core/item.py
index ec8716d8..73f0f928 100644
--- a/core/item.py
+++ b/core/item.py
@@ -284,7 +284,10 @@ class Item(object):
         return '\r\t' + self.tostring('\r\t')
 
     def __eq__(self, other):
-        return self.__dict__ == other.__dict__
+        if type(other) == Item:
+            return self.__dict__ == other.__dict__
+        else:
+            return False
 
     def set_parent_content(self, parentContent):
         """
diff --git a/lib/esprima/__init__.py b/lib/esprima/__init__.py
new file mode 100644
index 00000000..0dcdf99e
--- /dev/null
+++ b/lib/esprima/__init__.py
@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import
+
+version = '4.0.1'
+__version__ = (4, 0, 1)
+
+from .esprima import *  # NOQA
diff --git a/lib/esprima/__main__.py b/lib/esprima/__main__.py
new file mode 100644
index 00000000..ddbe5297
--- /dev/null
+++ b/lib/esprima/__main__.py
@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals, print_function, division
+
+import sys
+
+from .esprima import parse, tokenize, Error, toDict
+from . import version
+
+
+def main():
+    import json
+    import time
+    import optparse
+
+    usage = "usage: %prog [options] [file.js]"
+    parser = optparse.OptionParser(usage=usage, version=version)
+    parser.add_option("--comment", dest="comment",
+                      action="store_true", default=False,
+                      help="Gather all line and block comments in an array")
+    parser.add_option("--attachComment", dest="attachComment",
+                      action="store_true", default=False,
+                      help="Attach comments to nodes")
+    parser.add_option("--loc", dest="loc", default=False,
+                      action="store_true",
+                      help="Include line-column location info for each syntax node")
+    parser.add_option("--range", dest="range", default=False,
+                      action="store_true",
+                      help="Include index-based range for each syntax node")
+    parser.add_option("--raw", dest="raw", default=False,
+                      action="store_true",
+                      help="Display the raw value of literals")
+    parser.add_option("--tokens", dest="tokens", default=False,
+                      action="store_true",
+                      help="List all tokens in an array")
+    parser.add_option("--tolerant", dest="tolerant", default=False,
+                      action="store_true",
+                      help="Tolerate errors on a best-effort basis (experimental)")
+    parser.add_option("--tokenize", dest="tokenize", default=False,
+                      action="store_true",
+                      help="Only tokenize, do not parse.")
+    parser.add_option("--module", dest="sourceType", default='string',
+                      action="store_const", const='module',
+                      help="Tolerate errors on a best-effort basis (experimental)")
+    parser.set_defaults(jsx=True, classProperties=True)
+    opts, args = parser.parse_args()
+
+    if len(args) == 1:
+        with open(args[0], 'rb') as f:
+            code = f.read().decode('utf-8')
+    elif sys.stdin.isatty():
+        parser.print_help()
+        return 64
+    else:
+        code = sys.stdin.read().decode('utf-8')
+
+    options = opts.__dict__
+    do_tokenize = options.pop('tokenize')
+
+    t = time.time()
+    try:
+        if do_tokenize:
+            del options['sourceType']
+            del options['tokens']
+            del options['raw']
+            del options['jsx']
+            res = toDict(tokenize(code, options=options))
+        else:
+            res = toDict(parse(code, options=options))
+    except Error as e:
+        res = e.toDict()
+    dt = time.time() - t + 0.000000001
+
+    print(json.dumps(res, indent=4))
+    print()
+    print('Parsed everything in', round(dt, 5), 'seconds.')
+    print('Thats %d characters per second' % (len(code) // dt))
+
+    return 0
+
+
+if __name__ == '__main__':
+    retval = main()
+    sys.exit(retval)
diff --git a/lib/esprima/character.py b/lib/esprima/character.py
new file mode 100644
index 00000000..07a7b4d0
--- /dev/null
+++ b/lib/esprima/character.py
@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+import sys
+
+import unicodedata
+from collections import defaultdict
+
+from .compat import uchr, xrange
+
+# https://stackoverflow.com/questions/14245893/efficiently-list-all-characters-in-a-given-unicode-category
+U_CATEGORIES = defaultdict(list)
+for c in map(uchr, xrange(sys.maxunicode + 1)):
+    U_CATEGORIES[unicodedata.category(c)].append(c)
+UNICODE_LETTER = set(
+    U_CATEGORIES['Lu'] + U_CATEGORIES['Ll'] +
+    U_CATEGORIES['Lt'] + U_CATEGORIES['Lm'] +
+    U_CATEGORIES['Lo'] + U_CATEGORIES['Nl']
+)
+UNICODE_OTHER_ID_START = set((
+    # Other_ID_Start
+    '\u1885', '\u1886', '\u2118', '\u212E', '\u309B', '\u309C',
+    # New in Unicode 8.0
+    '\u08B3', '\u0AF9', '\u13F8', '\u9FCD', '\uAB60', '\U00010CC0', '\U000108E0', '\U0002B820',
+    # New in Unicode 9.0
+    '\u1C80', '\U000104DB', '\U0001E922',
+    '\U0001EE00', '\U0001EE06', '\U0001EE0A',
+))
+UNICODE_OTHER_ID_CONTINUE = set((
+    # Other_ID_Continue
+    '\xB7', '\u0387', '\u1369', '\u136A', '\u136B', '\u136C',
+    '\u136D', '\u136E', '\u136F', '\u1370', '\u1371', '\u19DA',
+    # New in Unicode 8.0
+    '\u08E3', '\uA69E', '\U00011730',
+    # New in Unicode 9.0
+    '\u08D4', '\u1DFB', '\uA8C5', '\U00011450',
+    '\U0001EE03', '\U0001EE0B',
+))
+UNICODE_COMBINING_MARK = set(U_CATEGORIES['Mn'] + U_CATEGORIES['Mc'])
+UNICODE_DIGIT = set(U_CATEGORIES['Nd'])
+UNICODE_CONNECTOR_PUNCTUATION = set(U_CATEGORIES['Pc'])
+IDENTIFIER_START = UNICODE_LETTER.union(UNICODE_OTHER_ID_START).union(set(('$', '_', '\\')))
+IDENTIFIER_PART = IDENTIFIER_START.union(UNICODE_COMBINING_MARK).union(UNICODE_DIGIT).union(UNICODE_CONNECTOR_PUNCTUATION).union(set(('\u200D', '\u200C'))).union(UNICODE_OTHER_ID_CONTINUE)
+
+WHITE_SPACE = set((
+    '\x09', '\x0B', '\x0C', '\x20', '\xA0',
+    '\u1680', '\u180E', '\u2000', '\u2001', '\u2002',
+    '\u2003', '\u2004', '\u2005', '\u2006', '\u2007',
+    '\u2008', '\u2009', '\u200A', '\u202F', '\u205F',
+    '\u3000', '\uFEFF',
+))
+LINE_TERMINATOR = set(('\x0A', '\x0D', '\u2028', '\u2029'))
+
+DECIMAL_CONV = dict((c, n) for n, c in enumerate('0123456789'))
+OCTAL_CONV = dict((c, n) for n, c in enumerate('01234567'))
+HEX_CONV = dict((c, n) for n, c in enumerate('0123456789abcdef'))
+for n, c in enumerate('ABCDEF', 10):
+    HEX_CONV[c] = n
+DECIMAL_DIGIT = set(DECIMAL_CONV.keys())
+OCTAL_DIGIT = set(OCTAL_CONV.keys())
+HEX_DIGIT = set(HEX_CONV.keys())
+
+
+class Character:
+    @staticmethod
+    def fromCodePoint(code):
+        return uchr(code)
+
+    # https://tc39.github.io/ecma262/#sec-white-space
+
+    @staticmethod
+    def isWhiteSpace(ch):
+        return ch in WHITE_SPACE
+
+    # https://tc39.github.io/ecma262/#sec-line-terminators
+
+    @staticmethod
+    def isLineTerminator(ch):
+        return ch in LINE_TERMINATOR
+
+    # https://tc39.github.io/ecma262/#sec-names-and-keywords
+
+    @staticmethod
+    def isIdentifierStart(ch):
+        return ch in IDENTIFIER_START
+
+    @staticmethod
+    def isIdentifierPart(ch):
+        return ch in IDENTIFIER_PART
+
+    # https://tc39.github.io/ecma262/#sec-literals-numeric-literals
+
+    @staticmethod
+    def isDecimalDigit(ch):
+        return ch in DECIMAL_DIGIT
+
+    @staticmethod
+    def isHexDigit(ch):
+        return ch in HEX_DIGIT
+
+    @staticmethod
+    def isOctalDigit(ch):
+        return ch in OCTAL_DIGIT
diff --git a/lib/esprima/comment_handler.py b/lib/esprima/comment_handler.py
new file mode 100644
index 00000000..15079069
--- /dev/null
+++ b/lib/esprima/comment_handler.py
@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+from .objects import Object
+from .nodes import Node
+from .syntax import Syntax
+
+
+class Comment(Node):
+    def __init__(self, type, value, range=None, loc=None):
+        self.type = type
+        self.value = value
+        self.range = range
+        self.loc = loc
+
+
+class Entry(Object):
+    def __init__(self, comment, start):
+        self.comment = comment
+        self.start = start
+
+
+class NodeInfo(Object):
+    def __init__(self, node, start):
+        self.node = node
+        self.start = start
+
+
+class CommentHandler(object):
+    def __init__(self):
+        self.attach = False
+        self.comments = []
+        self.stack = []
+        self.leading = []
+        self.trailing = []
+
+    def insertInnerComments(self, node, metadata):
+        #  innnerComments for properties empty block
+        #  `function a(:/** comments **\/}`
+        if node.type is Syntax.BlockStatement and not node.body:
+            innerComments = []
+            for i, entry in enumerate(self.leading):
+                if metadata.end.offset >= entry.start:
+                    innerComments.append(entry.comment)
+                    self.leading[i] = None
+                    self.trailing[i] = None
+            if innerComments:
+                node.innerComments = innerComments
+                self.leading = [v for v in self.leading if v is not None]
+                self.trailing = [v for v in self.trailing if v is not None]
+
+    def findTrailingComments(self, metadata):
+        trailingComments = []
+
+        if self.trailing:
+            for i, entry in enumerate(self.trailing):
+                if entry.start >= metadata.end.offset:
+                    trailingComments.append(entry.comment)
+            if trailingComments:
+                self.trailing = []
+            return trailingComments
+
+        last = self.stack and self.stack[-1]
+        if last and last.node.trailingComments:
+            firstComment = last.node.trailingComments[0]
+            if firstComment and firstComment.range[0] >= metadata.end.offset:
+                trailingComments = last.node.trailingComments
+                del last.node.trailingComments
+        return trailingComments
+
+    def findLeadingComments(self, metadata):
+        leadingComments = []
+
+        target = None
+        while self.stack:
+            entry = self.stack and self.stack[-1]
+            if entry and entry.start >= metadata.start.offset:
+                target = entry.node
+                self.stack.pop()
+            else:
+                break
+
+        if target:
+            if target.leadingComments:
+                for i, comment in enumerate(target.leadingComments):
+                    if comment.range[1] <= metadata.start.offset:
+                        leadingComments.append(comment)
+                        target.leadingComments[i] = None
+            if leadingComments:
+                target.leadingComments = [v for v in target.leadingComments if v is not None]
+                if not target.leadingComments:
+                    del target.leadingComments
+            return leadingComments
+
+        for i, entry in enumerate(self.leading):
+            if entry.start <= metadata.start.offset:
+                leadingComments.append(entry.comment)
+                self.leading[i] = None
+        if leadingComments:
+            self.leading = [v for v in self.leading if v is not None]
+
+        return leadingComments
+
+    def visitNode(self, node, metadata):
+        if node.type is Syntax.Program and node.body:
+            return
+
+        self.insertInnerComments(node, metadata)
+        trailingComments = self.findTrailingComments(metadata)
+        leadingComments = self.findLeadingComments(metadata)
+        if leadingComments:
+            node.leadingComments = leadingComments
+        if trailingComments:
+            node.trailingComments = trailingComments
+
+        self.stack.append(NodeInfo(
+            node=node,
+            start=metadata.start.offset
+        ))
+
+    def visitComment(self, node, metadata):
+        type = 'Line' if node.type[0] == 'L' else 'Block'
+        comment = Comment(
+            type=type,
+            value=node.value
+        )
+        if node.range:
+            comment.range = node.range
+        if node.loc:
+            comment.loc = node.loc
+        self.comments.append(comment)
+
+        if self.attach:
+            entry = Entry(
+                comment=Comment(
+                    type=type,
+                    value=node.value,
+                    range=[metadata.start.offset, metadata.end.offset]
+                ),
+                start=metadata.start.offset
+            )
+            if node.loc:
+                entry.comment.loc = node.loc
+            node.type = type
+            self.leading.append(entry)
+            self.trailing.append(entry)
+
+    def visit(self, node, metadata):
+        if node.type == 'LineComment':
+            self.visitComment(node, metadata)
+        elif node.type == 'BlockComment':
+            self.visitComment(node, metadata)
+        elif self.attach:
+            self.visitNode(node, metadata)
diff --git a/lib/esprima/compat.py b/lib/esprima/compat.py
new file mode 100644
index 00000000..79543255
--- /dev/null
+++ b/lib/esprima/compat.py
@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+import sys
+
+PY3 = sys.version_info >= (3, 0)
+
+if PY3:
+    # Python 3:
+    basestring = str
+    long = int
+    xrange = range
+    unicode = str
+    uchr = chr
+
+    def uord(ch):
+        return ord(ch[0])
+
+else:
+    basestring = basestring
+    long = long
+    xrange = xrange
+    unicode = unicode
+
+    try:
+        # Python 2 UCS4:
+        unichr(0x10000)
+        uchr = unichr
+
+        def uord(ch):
+            return ord(ch[0])
+
+    except ValueError:
+        # Python 2 UCS2:
+        def uchr(code):
+            # UTF-16 Encoding
+            if code <= 0xFFFF:
+                return unichr(code)
+            cu1 = ((code - 0x10000) >> 10) + 0xD800
+            cu2 = ((code - 0x10000) & 1023) + 0xDC00
+            return unichr(cu1) + unichr(cu2)
+
+        def uord(ch):
+            cp = ord(ch[0])
+            if cp >= 0xD800 and cp <= 0xDBFF:
+                second = ord(ch[1])
+                if second >= 0xDC00 and second <= 0xDFFF:
+                    first = cp
+                    cp = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000
+            return cp
diff --git a/lib/esprima/error_handler.py b/lib/esprima/error_handler.py
new file mode 100644
index 00000000..9b0f5cb8
--- /dev/null
+++ b/lib/esprima/error_handler.py
@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import unicode_literals
+
+from .compat import unicode
+
+
+class Error(Exception):
+    def __init__(self, message, name=None, index=None, lineNumber=None, column=None, description=None):
+        super(Error, self).__init__(message)
+        self.message = message
+        self.name = name
+        self.index = index
+        self.lineNumber = lineNumber
+        self.column = column
+        # self.description = description
+
+    def toString(self):
+        return '%s: %s' % (self.__class__.__name__, self)
+
+    def toDict(self):
+        d = dict((unicode(k), v) for k, v in self.__dict__.items() if v is not None)
+        d['message'] = self.toString()
+        return d
+
+
+class ErrorHandler:
+    def __init__(self):
+        self.errors = []
+        self.tolerant = False
+
+    def recordError(self, error):
+        self.errors.append(error.toDict())
+
+    def tolerate(self, error):
+        if self.tolerant:
+            self.recordError(error)
+        else:
+            raise error
+
+    def createError(self, index, line, col, description):
+        msg = 'Line %s: %s' % (line, description)
+        return Error(msg, index=index, lineNumber=line, column=col, description=description)
+
+    def throwError(self, index, line, col, description):
+        raise self.createError(index, line, col, description)
+
+    def tolerateError(self, index, line, col, description):
+        error = self.createError(index, line, col, description)
+        if self.tolerant:
+            self.recordError(error)
+        else:
+            raise error
diff --git a/lib/esprima/esprima.py b/lib/esprima/esprima.py
new file mode 100644
index 00000000..faea0c2d
--- /dev/null
+++ b/lib/esprima/esprima.py
@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+from .comment_handler import CommentHandler
+from .error_handler import Error
+from .jsx_parser import JSXParser
+from .jsx_syntax import JSXSyntax
+from .objects import Array, toDict
+from .parser import Parser
+from .syntax import Syntax
+from .tokenizer import Tokenizer
+from .visitor import NodeVisitor
+from . import nodes
+from . import jsx_nodes
+
+
+__all__ = ['Syntax', 'JSXSyntax', 'Error', 'NodeVisitor', 'nodes', 'jsx_nodes',
+           'parse', 'parseModule', 'parseScript', 'tokenize', 'toDict']
+
+
+def parse(code, options=None, delegate=None, **kwargs):
+    options = {} if options is None else options.copy()
+    options.update(kwargs)
+
+    # ESNext presset:
+    if options.get('esnext', False):
+        options['jsx'] = True
+        options['classProperties'] = True
+
+    commentHandler = None
+
+    def proxyDelegate(node, metadata):
+        if delegate:
+            new_node = delegate(node, metadata)
+            if new_node is not None:
+                node = new_node
+        if commentHandler:
+            commentHandler.visit(node, metadata)
+        return node
+
+    parserDelegate = None if delegate is None else proxyDelegate
+    collectComment = options.get('comment', False)
+    attachComment = options.get('attachComment', False)
+    if collectComment or attachComment:
+        commentHandler = CommentHandler()
+        commentHandler.attach = attachComment
+        options['comment'] = True
+        parserDelegate = proxyDelegate
+
+    isModule = options.get('sourceType', 'script') == 'module'
+
+    if options.get('jsx', False):
+        parser = JSXParser(code, options=options, delegate=parserDelegate)
+    else:
+        parser = Parser(code, options=options, delegate=parserDelegate)
+
+    ast = parser.parseModule() if isModule else parser.parseScript()
+
+    if collectComment and commentHandler:
+        ast.comments = commentHandler.comments
+
+    if parser.config.tokens:
+        ast.tokens = parser.tokens
+
+    if parser.config.tolerant:
+        ast.errors = parser.errorHandler.errors
+
+    return ast
+
+
+def parseModule(code, options=None, delegate=None, **kwargs):
+    kwargs['sourceType'] = 'module'
+    return parse(code, options, delegate, **kwargs)
+
+
+def parseScript(code, options=None, delegate=None, **kwargs):
+    kwargs['sourceType'] = 'script'
+    return parse(code, options, delegate, **kwargs)
+
+
+def tokenize(code, options=None, delegate=None, **kwargs):
+    options = {} if options is None else options.copy()
+    options.update(kwargs)
+
+    tokenizer = Tokenizer(code, options)
+
+    tokens = Array()
+
+    try:
+        while True:
+            token = tokenizer.getNextToken()
+            if not token:
+                break
+            if delegate:
+                token = delegate(token)
+            tokens.append(token)
+    except Error as e:
+        tokenizer.errorHandler.tolerate(e)
+
+    if tokenizer.errorHandler.tolerant:
+        tokens.errors = tokenizer.errors()
+
+    return tokens
diff --git a/lib/esprima/jsx_nodes.py b/lib/esprima/jsx_nodes.py
new file mode 100644
index 00000000..f195653a
--- /dev/null
+++ b/lib/esprima/jsx_nodes.py
@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+from .nodes import Node
+from .jsx_syntax import JSXSyntax
+
+
+class JSXClosingElement(Node):
+    def __init__(self, name):
+        self.type = JSXSyntax.JSXClosingElement
+        self.name = name
+
+
+class JSXElement(Node):
+    def __init__(self, openingElement, children, closingElement):
+        self.type = JSXSyntax.JSXElement
+        self.openingElement = openingElement
+        self.children = children
+        self.closingElement = closingElement
+
+
+class JSXEmptyExpression(Node):
+    def __init__(self):
+        self.type = JSXSyntax.JSXEmptyExpression
+
+
+class JSXExpressionContainer(Node):
+    def __init__(self, expression):
+        self.type = JSXSyntax.JSXExpressionContainer
+        self.expression = expression
+
+
+class JSXIdentifier(Node):
+    def __init__(self, name):
+        self.type = JSXSyntax.JSXIdentifier
+        self.name = name
+
+
+class JSXMemberExpression(Node):
+    def __init__(self, object, property):
+        self.type = JSXSyntax.JSXMemberExpression
+        self.object = object
+        self.property = property
+
+
+class JSXAttribute(Node):
+    def __init__(self, name, value):
+        self.type = JSXSyntax.JSXAttribute
+        self.name = name
+        self.value = value
+
+
+class JSXNamespacedName(Node):
+    def __init__(self, namespace, name):
+        self.type = JSXSyntax.JSXNamespacedName
+        self.namespace = namespace
+        self.name = name
+
+
+class JSXOpeningElement(Node):
+    def __init__(self, name, selfClosing, attributes):
+        self.type = JSXSyntax.JSXOpeningElement
+        self.name = name
+        self.selfClosing = selfClosing
+        self.attributes = attributes
+
+
+class JSXSpreadAttribute(Node):
+    def __init__(self, argument):
+        self.type = JSXSyntax.JSXSpreadAttribute
+        self.argument = argument
+
+
+class JSXText(Node):
+    def __init__(self, value, raw):
+        self.type = JSXSyntax.JSXText
+        self.value = value
+        self.raw = raw
diff --git a/lib/esprima/jsx_parser.py b/lib/esprima/jsx_parser.py
new file mode 100644
index 00000000..a4c0fa9c
--- /dev/null
+++ b/lib/esprima/jsx_parser.py
@@ -0,0 +1,584 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+from .compat import uchr
+from .character import Character
+from . import jsx_nodes as JSXNode
+from .jsx_syntax import JSXSyntax
+from . import nodes as Node
+from .parser import Marker, Parser
+from .token import Token, TokenName
+from .xhtml_entities import XHTMLEntities
+
+
+class MetaJSXElement(object):
+    def __init__(self, node=None, opening=None, closing=None, children=None):
+        self.node = node
+        self.opening = opening
+        self.closing = closing
+        self.children = children
+
+
+class JSXToken(object):
+    Identifier = 100
+    Text = 101
+
+
+class RawJSXToken(object):
+    def __init__(self, type=None, value=None, lineNumber=None, lineStart=None, start=None, end=None):
+        self.type = type
+        self.value = value
+        self.lineNumber = lineNumber
+        self.lineStart = lineStart
+        self.start = start
+        self.end = end
+
+
+TokenName[JSXToken.Identifier] = "JSXIdentifier"
+TokenName[JSXToken.Text] = "JSXText"
+
+
+# Fully qualified element name, e.g. <svg:path> returns "svg:path"
+def getQualifiedElementName(elementName):
+    typ = elementName.type
+    if typ is JSXSyntax.JSXIdentifier:
+        id = elementName
+        qualifiedName = id.name
+    elif typ is JSXSyntax.JSXNamespacedName:
+        ns = elementName
+        qualifiedName = getQualifiedElementName(ns.namespace) + ':' + getQualifiedElementName(ns.name)
+    elif typ is JSXSyntax.JSXMemberExpression:
+        expr = elementName
+        qualifiedName = getQualifiedElementName(expr.object) + '.' + getQualifiedElementName(expr.property)
+
+    return qualifiedName
+
+
+class JSXParser(Parser):
+    def __init__(self, code, options, delegate):
+        super(JSXParser, self).__init__(code, options, delegate)
+
+    def parsePrimaryExpression(self):
+        return self.parseJSXRoot() if self.match('<') else super(JSXParser, self).parsePrimaryExpression()
+
+    def startJSX(self):
+        # Unwind the scanner before the lookahead token.
+        self.scanner.index = self.startMarker.index
+        self.scanner.lineNumber = self.startMarker.line
+        self.scanner.lineStart = self.startMarker.index - self.startMarker.column
+
+    def finishJSX(self):
+        # Prime the next lookahead.
+        self.nextToken()
+
+    def reenterJSX(self):
+        self.startJSX()
+        self.expectJSX('}')
+
+        # Pop the closing '}' added from the lookahead.
+        if self.config.tokens:
+            self.tokens.pop()
+
+    def createJSXNode(self):
+        self.collectComments()
+        return Marker(
+            index=self.scanner.index,
+            line=self.scanner.lineNumber,
+            column=self.scanner.index - self.scanner.lineStart
+        )
+
+    def createJSXChildNode(self):
+        return Marker(
+            index=self.scanner.index,
+            line=self.scanner.lineNumber,
+            column=self.scanner.index - self.scanner.lineStart
+        )
+
+    def scanXHTMLEntity(self, quote):
+        result = '&'
+
+        valid = True
+        terminated = False
+        numeric = False
+        hex = False
+
+        while not self.scanner.eof() and valid and not terminated:
+            ch = self.scanner.source[self.scanner.index]
+            if ch == quote:
+                break
+
+            terminated = (ch == ';')
+            result += ch
+            self.scanner.index += 1
+            if not terminated:
+                length = len(result)
+                if length == 2:
+                    # e.g. '&#123;'
+                    numeric = (ch == '#')
+                elif length == 3:
+                    if numeric:
+                        # e.g. '&#x41;'
+                        hex = ch == 'x'
+                        valid = hex or Character.isDecimalDigit(ch)
+                        numeric = numeric and not hex
+                else:
+                    valid = valid and not (numeric and not Character.isDecimalDigit(ch))
+                    valid = valid and not (hex and not Character.isHexDigit(ch))
+
+        if valid and terminated and len(result) > 2:
+            # e.g. '&#x41;' becomes just '#x41'
+            st = result[1:-1]
+            if numeric and len(st) > 1:
+                result = uchr(int(st[1:], 10))
+            elif hex and len(st) > 2:
+                result = uchr(int(st[2:], 16))
+            elif not numeric and not hex and st in XHTMLEntities:
+                result = XHTMLEntities[st]
+
+        return result
+
+    # Scan the next JSX token. This replaces Scanner#lex when in JSX mode.
+
+    def lexJSX(self):
+        ch = self.scanner.source[self.scanner.index]
+
+        # < > / : = { }
+        if ch in ('<', '>', '/', ':', '=', '{', '}'):
+            value = self.scanner.source[self.scanner.index]
+            self.scanner.index += 1
+            return RawJSXToken(
+                type=Token.Punctuator,
+                value=value,
+                lineNumber=self.scanner.lineNumber,
+                lineStart=self.scanner.lineStart,
+                start=self.scanner.index - 1,
+                end=self.scanner.index
+            )
+
+        # " '
+        if ch in ('\'', '"'):
+            start = self.scanner.index
+            quote = self.scanner.source[self.scanner.index]
+            self.scanner.index += 1
+            str = ''
+            while not self.scanner.eof():
+                ch = self.scanner.source[self.scanner.index]
+                self.scanner.index += 1
+                if ch == quote:
+                    break
+                elif ch == '&':
+                    str += self.scanXHTMLEntity(quote)
+                else:
+                    str += ch
+
+            return RawJSXToken(
+                type=Token.StringLiteral,
+                value=str,
+                lineNumber=self.scanner.lineNumber,
+                lineStart=self.scanner.lineStart,
+                start=start,
+                end=self.scanner.index
+            )
+
+        # ... or .
+        if ch == '.':
+            start = self.scanner.index
+            if self.scanner.source[start + 1:start + 3] == '..':
+                value = '...'
+                self.scanner.index += 3
+            else:
+                value = '.'
+                self.scanner.index += 1
+            return RawJSXToken(
+                type=Token.Punctuator,
+                value=value,
+                lineNumber=self.scanner.lineNumber,
+                lineStart=self.scanner.lineStart,
+                start=start,
+                end=self.scanner.index
+            )
+
+        # `
+        if ch == '`':
+            # Only placeholder, since it will be rescanned as a real assignment expression.
+            return RawJSXToken(
+                type=Token.Template,
+                value='',
+                lineNumber=self.scanner.lineNumber,
+                lineStart=self.scanner.lineStart,
+                start=self.scanner.index,
+                end=self.scanner.index
+            )
+
+        # Identifier can not contain backslash (char code 92).
+        if Character.isIdentifierStart(ch) and ch != '\\':
+            start = self.scanner.index
+            self.scanner.index += 1
+            while not self.scanner.eof():
+                ch = self.scanner.source[self.scanner.index]
+                if Character.isIdentifierPart(ch) and ch != '\\':
+                    self.scanner.index += 1
+                elif ch == '-':
+                    # Hyphen (char code 45) can be part of an identifier.
+                    self.scanner.index += 1
+                else:
+                    break
+
+            id = self.scanner.source[start:self.scanner.index]
+            return RawJSXToken(
+                type=JSXToken.Identifier,
+                value=id,
+                lineNumber=self.scanner.lineNumber,
+                lineStart=self.scanner.lineStart,
+                start=start,
+                end=self.scanner.index
+            )
+
+        return self.scanner.lex()
+
+    def nextJSXToken(self):
+        self.collectComments()
+
+        self.startMarker.index = self.scanner.index
+        self.startMarker.line = self.scanner.lineNumber
+        self.startMarker.column = self.scanner.index - self.scanner.lineStart
+        token = self.lexJSX()
+        self.lastMarker.index = self.scanner.index
+        self.lastMarker.line = self.scanner.lineNumber
+        self.lastMarker.column = self.scanner.index - self.scanner.lineStart
+
+        if self.config.tokens:
+            self.tokens.append(self.convertToken(token))
+
+        return token
+
+    def nextJSXText(self):
+        self.startMarker.index = self.scanner.index
+        self.startMarker.line = self.scanner.lineNumber
+        self.startMarker.column = self.scanner.index - self.scanner.lineStart
+
+        start = self.scanner.index
+
+        text = ''
+        while not self.scanner.eof():
+            ch = self.scanner.source[self.scanner.index]
+            if ch in ('{', '<'):
+                break
+
+            self.scanner.index += 1
+            text += ch
+            if Character.isLineTerminator(ch):
+                self.scanner.lineNumber += 1
+                if ch == '\r' and self.scanner.source[self.scanner.index] == '\n':
+                    self.scanner.index += 1
+
+                self.scanner.lineStart = self.scanner.index
+
+        self.lastMarker.index = self.scanner.index
+        self.lastMarker.line = self.scanner.lineNumber
+        self.lastMarker.column = self.scanner.index - self.scanner.lineStart
+
+        token = RawJSXToken(
+            type=JSXToken.Text,
+            value=text,
+            lineNumber=self.scanner.lineNumber,
+            lineStart=self.scanner.lineStart,
+            start=start,
+            end=self.scanner.index
+        )
+
+        if text and self.config.tokens:
+            self.tokens.append(self.convertToken(token))
+
+        return token
+
+    def peekJSXToken(self):
+        state = self.scanner.saveState()
+        self.scanner.scanComments()
+        next = self.lexJSX()
+        self.scanner.restoreState(state)
+
+        return next
+
+    # Expect the next JSX token to match the specified punctuator.
+    # If not, an exception will be thrown.
+
+    def expectJSX(self, value):
+        token = self.nextJSXToken()
+        if token.type is not Token.Punctuator or token.value != value:
+            self.throwUnexpectedToken(token)
+
+    # Return True if the next JSX token matches the specified punctuator.
+
+    def matchJSX(self, *value):
+        next = self.peekJSXToken()
+        return next.type is Token.Punctuator and next.value in value
+
+    def parseJSXIdentifier(self):
+        node = self.createJSXNode()
+        token = self.nextJSXToken()
+        if token.type is not JSXToken.Identifier:
+            self.throwUnexpectedToken(token)
+
+        return self.finalize(node, JSXNode.JSXIdentifier(token.value))
+
+    def parseJSXElementName(self):
+        node = self.createJSXNode()
+        elementName = self.parseJSXIdentifier()
+
+        if self.matchJSX(':'):
+            namespace = elementName
+            self.expectJSX(':')
+            name = self.parseJSXIdentifier()
+            elementName = self.finalize(node, JSXNode.JSXNamespacedName(namespace, name))
+        elif self.matchJSX('.'):
+            while self.matchJSX('.'):
+                object = elementName
+                self.expectJSX('.')
+                property = self.parseJSXIdentifier()
+                elementName = self.finalize(node, JSXNode.JSXMemberExpression(object, property))
+
+        return elementName
+
+    def parseJSXAttributeName(self):
+        node = self.createJSXNode()
+
+        identifier = self.parseJSXIdentifier()
+        if self.matchJSX(':'):
+            namespace = identifier
+            self.expectJSX(':')
+            name = self.parseJSXIdentifier()
+            attributeName = self.finalize(node, JSXNode.JSXNamespacedName(namespace, name))
+        else:
+            attributeName = identifier
+
+        return attributeName
+
+    def parseJSXStringLiteralAttribute(self):
+        node = self.createJSXNode()
+        token = self.nextJSXToken()
+        if token.type is not Token.StringLiteral:
+            self.throwUnexpectedToken(token)
+
+        raw = self.getTokenRaw(token)
+        return self.finalize(node, Node.Literal(token.value, raw))
+
+    def parseJSXExpressionAttribute(self):
+        node = self.createJSXNode()
+
+        self.expectJSX('{')
+        self.finishJSX()
+
+        if self.match('}'):
+            self.tolerateError('JSX attributes must only be assigned a non-empty expression')
+
+        expression = self.parseAssignmentExpression()
+        self.reenterJSX()
+
+        return self.finalize(node, JSXNode.JSXExpressionContainer(expression))
+
+    def parseJSXAttributeValue(self):
+        if self.matchJSX('{'):
+            return self.parseJSXExpressionAttribute()
+        if self.matchJSX('<'):
+            return self.parseJSXElement()
+
+        return self.parseJSXStringLiteralAttribute()
+
+    def parseJSXNameValueAttribute(self):
+        node = self.createJSXNode()
+        name = self.parseJSXAttributeName()
+        value = None
+        if self.matchJSX('='):
+            self.expectJSX('=')
+            value = self.parseJSXAttributeValue()
+
+        return self.finalize(node, JSXNode.JSXAttribute(name, value))
+
+    def parseJSXSpreadAttribute(self):
+        node = self.createJSXNode()
+        self.expectJSX('{')
+        self.expectJSX('...')
+
+        self.finishJSX()
+        argument = self.parseAssignmentExpression()
+        self.reenterJSX()
+
+        return self.finalize(node, JSXNode.JSXSpreadAttribute(argument))
+
+    def parseJSXAttributes(self):
+        attributes = []
+
+        while not self.matchJSX('/', '>'):
+            attribute = self.parseJSXSpreadAttribute() if self.matchJSX('{') else self.parseJSXNameValueAttribute()
+            attributes.append(attribute)
+
+        return attributes
+
+    def parseJSXOpeningElement(self):
+        node = self.createJSXNode()
+
+        self.expectJSX('<')
+        name = self.parseJSXElementName()
+        attributes = self.parseJSXAttributes()
+        selfClosing = self.matchJSX('/')
+        if selfClosing:
+            self.expectJSX('/')
+
+        self.expectJSX('>')
+
+        return self.finalize(node, JSXNode.JSXOpeningElement(name, selfClosing, attributes))
+
+    def parseJSXBoundaryElement(self):
+        node = self.createJSXNode()
+
+        self.expectJSX('<')
+        if self.matchJSX('/'):
+            self.expectJSX('/')
+            elementName = self.parseJSXElementName()
+            self.expectJSX('>')
+            return self.finalize(node, JSXNode.JSXClosingElement(elementName))
+
+        name = self.parseJSXElementName()
+        attributes = self.parseJSXAttributes()
+        selfClosing = self.matchJSX('/')
+        if selfClosing:
+            self.expectJSX('/')
+
+        self.expectJSX('>')
+
+        return self.finalize(node, JSXNode.JSXOpeningElement(name, selfClosing, attributes))
+
+    def parseJSXEmptyExpression(self):
+        node = self.createJSXChildNode()
+        self.collectComments()
+        self.lastMarker.index = self.scanner.index
+        self.lastMarker.line = self.scanner.lineNumber
+        self.lastMarker.column = self.scanner.index - self.scanner.lineStart
+        return self.finalize(node, JSXNode.JSXEmptyExpression())
+
+    def parseJSXExpressionContainer(self):
+        node = self.createJSXNode()
+        self.expectJSX('{')
+
+        if self.matchJSX('}'):
+            expression = self.parseJSXEmptyExpression()
+            self.expectJSX('}')
+        else:
+            self.finishJSX()
+            expression = self.parseAssignmentExpression()
+            self.reenterJSX()
+
+        return self.finalize(node, JSXNode.JSXExpressionContainer(expression))
+
+    def parseJSXChildren(self):
+        children = []
+
+        while not self.scanner.eof():
+            node = self.createJSXChildNode()
+            token = self.nextJSXText()
+            if token.start < token.end:
+                raw = self.getTokenRaw(token)
+                child = self.finalize(node, JSXNode.JSXText(token.value, raw))
+                children.append(child)
+
+            if self.scanner.source[self.scanner.index] == '{':
+                container = self.parseJSXExpressionContainer()
+                children.append(container)
+            else:
+                break
+
+        return children
+
+    def parseComplexJSXElement(self, el):
+        stack = []
+
+        while not self.scanner.eof():
+            el.children.extend(self.parseJSXChildren())
+            node = self.createJSXChildNode()
+            element = self.parseJSXBoundaryElement()
+            if element.type is JSXSyntax.JSXOpeningElement:
+                opening = element
+                if opening.selfClosing:
+                    child = self.finalize(node, JSXNode.JSXElement(opening, [], None))
+                    el.children.append(child)
+                else:
+                    stack.append(el)
+                    el = MetaJSXElement(
+                        node=node,
+                        opening=opening,
+                        closing=None,
+                        children=[],
+                    )
+
+            if element.type is JSXSyntax.JSXClosingElement:
+                el.closing = element
+                open = getQualifiedElementName(el.opening.name)
+                close = getQualifiedElementName(el.closing.name)
+                if open != close:
+                    self.tolerateError('Expected corresponding JSX closing tag for %0', open)
+
+                if stack:
+                    child = self.finalize(el.node, JSXNode.JSXElement(el.opening, el.children, el.closing))
+                    el = stack[-1]
+                    el.children.append(child)
+                    stack.pop()
+                else:
+                    break
+
+        return el
+
+    def parseJSXElement(self):
+        node = self.createJSXNode()
+
+        opening = self.parseJSXOpeningElement()
+        children = []
+        closing = None
+
+        if not opening.selfClosing:
+            el = self.parseComplexJSXElement(MetaJSXElement(
+                node=node,
+                opening=opening,
+                closing=closing,
+                children=children
+            ))
+            children = el.children
+            closing = el.closing
+
+        return self.finalize(node, JSXNode.JSXElement(opening, children, closing))
+
+    def parseJSXRoot(self):
+        # Pop the opening '<' added from the lookahead.
+        if self.config.tokens:
+            self.tokens.pop()
+
+        self.startJSX()
+        element = self.parseJSXElement()
+        self.finishJSX()
+
+        return element
+
+    def isStartOfExpression(self):
+        return super(JSXParser, self).isStartOfExpression() or self.match('<')
diff --git a/lib/esprima/jsx_syntax.py b/lib/esprima/jsx_syntax.py
new file mode 100644
index 00000000..808cc8b0
--- /dev/null
+++ b/lib/esprima/jsx_syntax.py
@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import unicode_literals
+
+
+class JSXSyntax:
+    JSXAttribute = "JSXAttribute"
+    JSXClosingElement = "JSXClosingElement"
+    JSXElement = "JSXElement"
+    JSXEmptyExpression = "JSXEmptyExpression"
+    JSXExpressionContainer = "JSXExpressionContainer"
+    JSXIdentifier = "JSXIdentifier"
+    JSXMemberExpression = "JSXMemberExpression"
+    JSXNamespacedName = "JSXNamespacedName"
+    JSXOpeningElement = "JSXOpeningElement"
+    JSXSpreadAttribute = "JSXSpreadAttribute"
+    JSXText = "JSXText"
diff --git a/lib/esprima/messages.py b/lib/esprima/messages.py
new file mode 100644
index 00000000..bb6314e1
--- /dev/null
+++ b/lib/esprima/messages.py
@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import unicode_literals
+
+
+# Error messages should be identical to V8.
+class Messages:
+    ObjectPatternAsRestParameter = "Unexpected token {"
+    BadImportCallArity = "Unexpected token"
+    BadGetterArity = "Getter must not have any formal parameters"
+    BadSetterArity = "Setter must have exactly one formal parameter"
+    BadSetterRestParameter = "Setter function argument must not be a rest parameter"
+    ConstructorIsAsync = "Class constructor may not be an async method"
+    ConstructorSpecialMethod = "Class constructor may not be an accessor"
+    DeclarationMissingInitializer = "Missing initializer in %0 declaration"
+    DefaultRestParameter = "Unexpected token ="
+    DefaultRestProperty = "Unexpected token ="
+    DuplicateBinding = "Duplicate binding %0"
+    DuplicateConstructor = "A class may only have one constructor"
+    DuplicateProtoProperty = "Duplicate __proto__ fields are not allowed in object literals"
+    ForInOfLoopInitializer = "%0 loop variable declaration may not have an initializer"
+    GeneratorInLegacyContext = "Generator declarations are not allowed in legacy contexts"
+    IllegalBreak = "Illegal break statement"
+    IllegalContinue = "Illegal continue statement"
+    IllegalExportDeclaration = "Unexpected token"
+    IllegalImportDeclaration = "Unexpected token"
+    IllegalLanguageModeDirective = "Illegal 'use strict' directive in function with non-simple parameter list"
+    IllegalReturn = "Illegal return statement"
+    InvalidEscapedReservedWord = "Keyword must not contain escaped characters"
+    InvalidHexEscapeSequence = "Invalid hexadecimal escape sequence"
+    InvalidLHSInAssignment = "Invalid left-hand side in assignment"
+    InvalidLHSInForIn = "Invalid left-hand side in for-in"
+    InvalidLHSInForLoop = "Invalid left-hand side in for-loop"
+    InvalidModuleSpecifier = "Unexpected token"
+    InvalidRegExp = "Invalid regular expression"
+    LetInLexicalBinding = "let is disallowed as a lexically bound name"
+    MissingFromClause = "Unexpected token"
+    MultipleDefaultsInSwitch = "More than one default clause in switch statement"
+    NewlineAfterThrow = "Illegal newline after throw"
+    NoAsAfterImportNamespace = "Unexpected token"
+    NoCatchOrFinally = "Missing catch or finally after try"
+    ParameterAfterRestParameter = "Rest parameter must be last formal parameter"
+    PropertyAfterRestProperty = "Unexpected token"
+    Redeclaration = "%0 '%1' has already been declared"
+    StaticPrototype = "Classes may not have static property named prototype"
+    StrictCatchVariable = "Catch variable may not be eval or arguments in strict mode"
+    StrictDelete = "Delete of an unqualified identifier in strict mode."
+    StrictFunction = "In strict mode code, functions can only be declared at top level or inside a block"
+    StrictFunctionName = "Function name may not be eval or arguments in strict mode"
+    StrictLHSAssignment = "Assignment to eval or arguments is not allowed in strict mode"
+    StrictLHSPostfix = "Postfix increment/decrement may not have eval or arguments operand in strict mode"
+    StrictLHSPrefix = "Prefix increment/decrement may not have eval or arguments operand in strict mode"
+    StrictModeWith = "Strict mode code may not include a with statement"
+    StrictOctalLiteral = "Octal literals are not allowed in strict mode."
+    StrictParamDupe = "Strict mode function may not have duplicate parameter names"
+    StrictParamName = "Parameter name eval or arguments is not allowed in strict mode"
+    StrictReservedWord = "Use of future reserved word in strict mode"
+    StrictVarName = "Variable name may not be eval or arguments in strict mode"
+    TemplateOctalLiteral = "Octal literals are not allowed in template strings."
+    UnexpectedEOS = "Unexpected end of input"
+    UnexpectedIdentifier = "Unexpected identifier"
+    UnexpectedNumber = "Unexpected number"
+    UnexpectedReserved = "Unexpected reserved word"
+    UnexpectedString = "Unexpected string"
+    UnexpectedTemplate = "Unexpected quasi %0"
+    UnexpectedToken = "Unexpected token %0"
+    UnexpectedTokenIllegal = "Unexpected token ILLEGAL"
+    UnknownLabel = "Undefined label '%0'"
+    UnterminatedRegExp = "Invalid regular expression: missing /"
diff --git a/lib/esprima/nodes.py b/lib/esprima/nodes.py
new file mode 100644
index 00000000..bbbbdb89
--- /dev/null
+++ b/lib/esprima/nodes.py
@@ -0,0 +1,620 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+from .objects import Object
+from .syntax import Syntax
+from .scanner import RegExp
+
+
+class Node(Object):
+    def __dir__(self):
+        return list(self.__dict__.keys())
+
+    def __iter__(self):
+        return self.__iter__
+
+    def keys(self):
+        return self.__dict__.keys()
+
+    def items(self):
+        return self.__dict__.items()
+
+
+class ArrayExpression(Node):
+    def __init__(self, elements):
+        self.type = Syntax.ArrayExpression
+        self.elements = elements
+
+
+class ArrayPattern(Node):
+    def __init__(self, elements):
+        self.type = Syntax.ArrayPattern
+        self.elements = elements
+
+
+class ArrowFunctionExpression(Node):
+    def __init__(self, params, body, expression):
+        self.type = Syntax.ArrowFunctionExpression
+        self.generator = False
+        self.isAsync = False
+        self.params = params
+        self.body = body
+        self.expression = expression
+
+
+class AssignmentExpression(Node):
+    def __init__(self, operator, left, right):
+        self.type = Syntax.AssignmentExpression
+        self.operator = operator
+        self.left = left
+        self.right = right
+
+
+class AssignmentPattern(Node):
+    def __init__(self, left, right):
+        self.type = Syntax.AssignmentPattern
+        self.left = left
+        self.right = right
+
+
+class AsyncArrowFunctionExpression(Node):
+    def __init__(self, params, body, expression):
+        self.type = Syntax.ArrowFunctionExpression
+        self.generator = False
+        self.isAsync = True
+        self.params = params
+        self.body = body
+        self.expression = expression
+
+
+class AsyncFunctionDeclaration(Node):
+    def __init__(self, id, params, body):
+        self.type = Syntax.FunctionDeclaration
+        self.generator = False
+        self.expression = False
+        self.isAsync = True
+        self.id = id
+        self.params = params
+        self.body = body
+
+
+class AsyncFunctionExpression(Node):
+    def __init__(self, id, params, body):
+        self.type = Syntax.FunctionExpression
+        self.generator = False
+        self.expression = False
+        self.isAsync = True
+        self.id = id
+        self.params = params
+        self.body = body
+
+
+class AwaitExpression(Node):
+    def __init__(self, argument):
+        self.type = Syntax.AwaitExpression
+        self.argument = argument
+
+
+class BinaryExpression(Node):
+    def __init__(self, operator, left, right):
+        self.type = Syntax.LogicalExpression if operator in ('||', '&&') else Syntax.BinaryExpression
+        self.operator = operator
+        self.left = left
+        self.right = right
+
+
+class BlockStatement(Node):
+    def __init__(self, body):
+        self.type = Syntax.BlockStatement
+        self.body = body
+
+
+class BreakStatement(Node):
+    def __init__(self, label):
+        self.type = Syntax.BreakStatement
+        self.label = label
+
+
+class CallExpression(Node):
+    def __init__(self, callee, args):
+        self.type = Syntax.CallExpression
+        self.callee = callee
+        self.arguments = args
+
+
+class CatchClause(Node):
+    def __init__(self, param, body):
+        self.type = Syntax.CatchClause
+        self.param = param
+        self.body = body
+
+
+class ClassBody(Node):
+    def __init__(self, body):
+        self.type = Syntax.ClassBody
+        self.body = body
+
+
+class ClassDeclaration(Node):
+    def __init__(self, id, superClass, body):
+        self.type = Syntax.ClassDeclaration
+        self.id = id
+        self.superClass = superClass
+        self.body = body
+
+
+class ClassExpression(Node):
+    def __init__(self, id, superClass, body):
+        self.type = Syntax.ClassExpression
+        self.id = id
+        self.superClass = superClass
+        self.body = body
+
+
+class ComputedMemberExpression(Node):
+    def __init__(self, object, property):
+        self.type = Syntax.MemberExpression
+        self.computed = True
+        self.object = object
+        self.property = property
+
+
+class ConditionalExpression(Node):
+    def __init__(self, test, consequent, alternate):
+        self.type = Syntax.ConditionalExpression
+        self.test = test
+        self.consequent = consequent
+        self.alternate = alternate
+
+
+class ContinueStatement(Node):
+    def __init__(self, label):
+        self.type = Syntax.ContinueStatement
+        self.label = label
+
+
+class DebuggerStatement(Node):
+    def __init__(self):
+        self.type = Syntax.DebuggerStatement
+
+
+class Directive(Node):
+    def __init__(self, expression, directive):
+        self.type = Syntax.ExpressionStatement
+        self.expression = expression
+        self.directive = directive
+
+
+class DoWhileStatement(Node):
+    def __init__(self, body, test):
+        self.type = Syntax.DoWhileStatement
+        self.body = body
+        self.test = test
+
+
+class EmptyStatement(Node):
+    def __init__(self):
+        self.type = Syntax.EmptyStatement
+
+
+class ExportAllDeclaration(Node):
+    def __init__(self, source):
+        self.type = Syntax.ExportAllDeclaration
+        self.source = source
+
+
+class ExportDefaultDeclaration(Node):
+    def __init__(self, declaration):
+        self.type = Syntax.ExportDefaultDeclaration
+        self.declaration = declaration
+
+
+class ExportNamedDeclaration(Node):
+    def __init__(self, declaration, specifiers, source):
+        self.type = Syntax.ExportNamedDeclaration
+        self.declaration = declaration
+        self.specifiers = specifiers
+        self.source = source
+
+
+class ExportSpecifier(Node):
+    def __init__(self, local, exported):
+        self.type = Syntax.ExportSpecifier
+        self.exported = exported
+        self.local = local
+
+
+class ExportDefaultSpecifier(Node):
+    def __init__(self, local):
+        self.type = Syntax.ExportDefaultSpecifier
+        self.local = local
+
+
+class ExpressionStatement(Node):
+    def __init__(self, expression):
+        self.type = Syntax.ExpressionStatement
+        self.expression = expression
+
+
+class ForInStatement(Node):
+    def __init__(self, left, right, body):
+        self.type = Syntax.ForInStatement
+        self.each = False
+        self.left = left
+        self.right = right
+        self.body = body
+
+
+class ForOfStatement(Node):
+    def __init__(self, left, right, body):
+        self.type = Syntax.ForOfStatement
+        self.left = left
+        self.right = right
+        self.body = body
+
+
+class ForStatement(Node):
+    def __init__(self, init, test, update, body):
+        self.type = Syntax.ForStatement
+        self.init = init
+        self.test = test
+        self.update = update
+        self.body = body
+
+
+class FunctionDeclaration(Node):
+    def __init__(self, id, params, body, generator):
+        self.type = Syntax.FunctionDeclaration
+        self.expression = False
+        self.isAsync = False
+        self.id = id
+        self.params = params
+        self.body = body
+        self.generator = generator
+
+
+class FunctionExpression(Node):
+    def __init__(self, id, params, body, generator):
+        self.type = Syntax.FunctionExpression
+        self.expression = False
+        self.isAsync = False
+        self.id = id
+        self.params = params
+        self.body = body
+        self.generator = generator
+
+
+class Identifier(Node):
+    def __init__(self, name):
+        self.type = Syntax.Identifier
+        self.name = name
+
+
+class IfStatement(Node):
+    def __init__(self, test, consequent, alternate):
+        self.type = Syntax.IfStatement
+        self.test = test
+        self.consequent = consequent
+        self.alternate = alternate
+
+
+class Import(Node):
+    def __init__(self):
+        self.type = Syntax.Import
+
+
+class ImportDeclaration(Node):
+    def __init__(self, specifiers, source):
+        self.type = Syntax.ImportDeclaration
+        self.specifiers = specifiers
+        self.source = source
+
+
+class ImportDefaultSpecifier(Node):
+    def __init__(self, local):
+        self.type = Syntax.ImportDefaultSpecifier
+        self.local = local
+
+
+class ImportNamespaceSpecifier(Node):
+    def __init__(self, local):
+        self.type = Syntax.ImportNamespaceSpecifier
+        self.local = local
+
+
+class ImportSpecifier(Node):
+    def __init__(self, local, imported):
+        self.type = Syntax.ImportSpecifier
+        self.local = local
+        self.imported = imported
+
+
+class LabeledStatement(Node):
+    def __init__(self, label, body):
+        self.type = Syntax.LabeledStatement
+        self.label = label
+        self.body = body
+
+
+class Literal(Node):
+    def __init__(self, value, raw):
+        self.type = Syntax.Literal
+        self.value = value
+        self.raw = raw
+
+
+class MetaProperty(Node):
+    def __init__(self, meta, property):
+        self.type = Syntax.MetaProperty
+        self.meta = meta
+        self.property = property
+
+
+class MethodDefinition(Node):
+    def __init__(self, key, computed, value, kind, isStatic):
+        self.type = Syntax.MethodDefinition
+        self.key = key
+        self.computed = computed
+        self.value = value
+        self.kind = kind
+        self.static = isStatic
+
+
+class FieldDefinition(Node):
+    def __init__(self, key, computed, value, kind, isStatic):
+        self.type = Syntax.FieldDefinition
+        self.key = key
+        self.computed = computed
+        self.value = value
+        self.kind = kind
+        self.static = isStatic
+
+
+class Module(Node):
+    def __init__(self, body):
+        self.type = Syntax.Program
+        self.sourceType = 'module'
+        self.body = body
+
+
+class NewExpression(Node):
+    def __init__(self, callee, args):
+        self.type = Syntax.NewExpression
+        self.callee = callee
+        self.arguments = args
+
+
+class ObjectExpression(Node):
+    def __init__(self, properties):
+        self.type = Syntax.ObjectExpression
+        self.properties = properties
+
+
+class ObjectPattern(Node):
+    def __init__(self, properties):
+        self.type = Syntax.ObjectPattern
+        self.properties = properties
+
+
+class Property(Node):
+    def __init__(self, kind, key, computed, value, method, shorthand):
+        self.type = Syntax.Property
+        self.key = key
+        self.computed = computed
+        self.value = value
+        self.kind = kind
+        self.method = method
+        self.shorthand = shorthand
+
+
+class RegexLiteral(Node):
+    def __init__(self, value, raw, pattern, flags):
+        self.type = Syntax.Literal
+        self.value = value
+        self.raw = raw
+        self.regex = RegExp(
+            pattern=pattern,
+            flags=flags,
+        )
+
+
+class RestElement(Node):
+    def __init__(self, argument):
+        self.type = Syntax.RestElement
+        self.argument = argument
+
+
+class ReturnStatement(Node):
+    def __init__(self, argument):
+        self.type = Syntax.ReturnStatement
+        self.argument = argument
+
+
+class Script(Node):
+    def __init__(self, body):
+        self.type = Syntax.Program
+        self.sourceType = 'script'
+        self.body = body
+
+
+class SequenceExpression(Node):
+    def __init__(self, expressions):
+        self.type = Syntax.SequenceExpression
+        self.expressions = expressions
+
+
+class SpreadElement(Node):
+    def __init__(self, argument):
+        self.type = Syntax.SpreadElement
+        self.argument = argument
+
+
+class StaticMemberExpression(Node):
+    def __init__(self, object, property):
+        self.type = Syntax.MemberExpression
+        self.computed = False
+        self.object = object
+        self.property = property
+
+
+class Super(Node):
+    def __init__(self):
+        self.type = Syntax.Super
+
+
+class SwitchCase(Node):
+    def __init__(self, test, consequent):
+        self.type = Syntax.SwitchCase
+        self.test = test
+        self.consequent = consequent
+
+
+class SwitchStatement(Node):
+    def __init__(self, discriminant, cases):
+        self.type = Syntax.SwitchStatement
+        self.discriminant = discriminant
+        self.cases = cases
+
+
+class TaggedTemplateExpression(Node):
+    def __init__(self, tag, quasi):
+        self.type = Syntax.TaggedTemplateExpression
+        self.tag = tag
+        self.quasi = quasi
+
+
+class TemplateElement(Node):
+    class Value(Object):
+        def __init__(self, raw, cooked):
+            self.raw = raw
+            self.cooked = cooked
+
+    def __init__(self, raw, cooked, tail):
+        self.type = Syntax.TemplateElement
+        self.value = TemplateElement.Value(raw, cooked)
+        self.tail = tail
+
+
+class TemplateLiteral(Node):
+    def __init__(self, quasis, expressions):
+        self.type = Syntax.TemplateLiteral
+        self.quasis = quasis
+        self.expressions = expressions
+
+
+class ThisExpression(Node):
+    def __init__(self):
+        self.type = Syntax.ThisExpression
+
+
+class ThrowStatement(Node):
+    def __init__(self, argument):
+        self.type = Syntax.ThrowStatement
+        self.argument = argument
+
+
+class TryStatement(Node):
+    def __init__(self, block, handler, finalizer):
+        self.type = Syntax.TryStatement
+        self.block = block
+        self.handler = handler
+        self.finalizer = finalizer
+
+
+class UnaryExpression(Node):
+    def __init__(self, operator, argument):
+        self.type = Syntax.UnaryExpression
+        self.prefix = True
+        self.operator = operator
+        self.argument = argument
+
+
+class UpdateExpression(Node):
+    def __init__(self, operator, argument, prefix):
+        self.type = Syntax.UpdateExpression
+        self.operator = operator
+        self.argument = argument
+        self.prefix = prefix
+
+
+class VariableDeclaration(Node):
+    def __init__(self, declarations, kind):
+        self.type = Syntax.VariableDeclaration
+        self.declarations = declarations
+        self.kind = kind
+
+
+class VariableDeclarator(Node):
+    def __init__(self, id, init):
+        self.type = Syntax.VariableDeclarator
+        self.id = id
+        self.init = init
+
+
+class WhileStatement(Node):
+    def __init__(self, test, body):
+        self.type = Syntax.WhileStatement
+        self.test = test
+        self.body = body
+
+
+class WithStatement(Node):
+    def __init__(self, object, body):
+        self.type = Syntax.WithStatement
+        self.object = object
+        self.body = body
+
+
+class YieldExpression(Node):
+    def __init__(self, argument, delegate):
+        self.type = Syntax.YieldExpression
+        self.argument = argument
+        self.delegate = delegate
+
+
+class ArrowParameterPlaceHolder(Node):
+    def __init__(self, params):
+        self.type = Syntax.ArrowParameterPlaceHolder
+        self.params = params
+        self.isAsync = False
+
+
+class AsyncArrowParameterPlaceHolder(Node):
+    def __init__(self, params):
+        self.type = Syntax.ArrowParameterPlaceHolder
+        self.params = params
+        self.isAsync = True
+
+
+class BlockComment(Node):
+    def __init__(self, value):
+        self.type = Syntax.BlockComment
+        self.value = value
+
+
+class LineComment(Node):
+    def __init__(self, value):
+        self.type = Syntax.LineComment
+        self.value = value
diff --git a/lib/esprima/objects.py b/lib/esprima/objects.py
new file mode 100644
index 00000000..a8acca1b
--- /dev/null
+++ b/lib/esprima/objects.py
@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+
+def toDict(value):
+    from .visitor import ToDictVisitor
+    return ToDictVisitor().visit(value)
+
+
+class Array(list):
+    pass
+
+
+class Object(object):
+    def toDict(self):
+        from .visitor import ToDictVisitor
+        return ToDictVisitor().visit(self)
+
+    def __repr__(self):
+        from .visitor import ReprVisitor
+        return ReprVisitor().visit(self)
+
+    def __getattr__(self, name):
+        return None
diff --git a/lib/esprima/parser.py b/lib/esprima/parser.py
new file mode 100644
index 00000000..2639f4c5
--- /dev/null
+++ b/lib/esprima/parser.py
@@ -0,0 +1,3104 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+from .objects import Object
+from .compat import basestring, unicode
+from .utils import format
+from .error_handler import ErrorHandler
+from .messages import Messages
+from .scanner import RawToken, Scanner, SourceLocation, Position, RegExp
+from .token import Token, TokenName
+from .syntax import Syntax
+from . import nodes as Node
+
+
+class Value(object):
+    def __init__(self, value):
+        self.value = value
+
+
+class Params(object):
+    def __init__(self, simple=None, message=None, stricted=None, firstRestricted=None, inFor=None, paramSet=None, params=None, get=None):
+        self.simple = simple
+        self.message = message
+        self.stricted = stricted
+        self.firstRestricted = firstRestricted
+        self.inFor = inFor
+        self.paramSet = paramSet
+        self.params = params
+        self.get = get
+
+
+class Config(Object):
+    def __init__(self, range=False, loc=False, source=None, tokens=False, comment=False, tolerant=False, **options):
+        self.range = range
+        self.loc = loc
+        self.source = source
+        self.tokens = tokens
+        self.comment = comment
+        self.tolerant = tolerant
+        for k, v in options.items():
+            setattr(self, k, v)
+
+
+class Context(object):
+    def __init__(self, isModule=False, allowAwait=False, allowIn=True, allowStrictDirective=True, allowYield=True, firstCoverInitializedNameError=None, isAssignmentTarget=False, isBindingElement=False, inFunctionBody=False, inIteration=False, inSwitch=False, labelSet=None, strict=False):
+        self.isModule = isModule
+        self.allowAwait = allowAwait
+        self.allowIn = allowIn
+        self.allowStrictDirective = allowStrictDirective
+        self.allowYield = allowYield
+        self.firstCoverInitializedNameError = firstCoverInitializedNameError
+        self.isAssignmentTarget = isAssignmentTarget
+        self.isBindingElement = isBindingElement
+        self.inFunctionBody = inFunctionBody
+        self.inIteration = inIteration
+        self.inSwitch = inSwitch
+        self.labelSet = {} if labelSet is None else labelSet
+        self.strict = strict
+
+
+class Marker(object):
+    def __init__(self, index=None, line=None, column=None):
+        self.index = index
+        self.line = line
+        self.column = column
+
+
+class TokenEntry(Object):
+    def __init__(self, type=None, value=None, regex=None, range=None, loc=None):
+        self.type = type
+        self.value = value
+        self.regex = regex
+        self.range = range
+        self.loc = loc
+
+
+class Parser(object):
+    def __init__(self, code, options={}, delegate=None):
+        self.config = Config(**options)
+
+        self.delegate = delegate
+
+        self.errorHandler = ErrorHandler()
+        self.errorHandler.tolerant = self.config.tolerant
+        self.scanner = Scanner(code, self.errorHandler)
+        self.scanner.trackComment = self.config.comment
+
+        self.operatorPrecedence = {
+            '||': 1,
+            '&&': 2,
+            '|': 3,
+            '^': 4,
+            '&': 5,
+            '==': 6,
+            '!=': 6,
+            '===': 6,
+            '!==': 6,
+            '<': 7,
+            '>': 7,
+            '<=': 7,
+            '>=': 7,
+            'instanceof': 7,
+            'in': 7,
+            '<<': 8,
+            '>>': 8,
+            '>>>': 8,
+            '+': 9,
+            '-': 9,
+            '*': 11,
+            '/': 11,
+            '%': 11,
+        }
+
+        self.lookahead = RawToken(
+            type=Token.EOF,
+            value='',
+            lineNumber=self.scanner.lineNumber,
+            lineStart=0,
+            start=0,
+            end=0
+        )
+        self.hasLineTerminator = False
+
+        self.context = Context(
+            isModule=False,
+            allowAwait=False,
+            allowIn=True,
+            allowStrictDirective=True,
+            allowYield=True,
+            firstCoverInitializedNameError=None,
+            isAssignmentTarget=False,
+            isBindingElement=False,
+            inFunctionBody=False,
+            inIteration=False,
+            inSwitch=False,
+            labelSet={},
+            strict=False
+        )
+        self.tokens = []
+
+        self.startMarker = Marker(
+            index=0,
+            line=self.scanner.lineNumber,
+            column=0
+        )
+        self.lastMarker = Marker(
+            index=0,
+            line=self.scanner.lineNumber,
+            column=0
+        )
+        self.nextToken()
+        self.lastMarker = Marker(
+            index=self.scanner.index,
+            line=self.scanner.lineNumber,
+            column=self.scanner.index - self.scanner.lineStart
+        )
+
+    def throwError(self, messageFormat, *args):
+        msg = format(messageFormat, *args)
+        index = self.lastMarker.index
+        line = self.lastMarker.line
+        column = self.lastMarker.column + 1
+        raise self.errorHandler.createError(index, line, column, msg)
+
+    def tolerateError(self, messageFormat, *args):
+        msg = format(messageFormat, *args)
+        index = self.lastMarker.index
+        line = self.scanner.lineNumber
+        column = self.lastMarker.column + 1
+        self.errorHandler.tolerateError(index, line, column, msg)
+
+    # Throw an exception because of the token.
+
+    def unexpectedTokenError(self, token=None, message=None):
+        msg = message or Messages.UnexpectedToken
+        if token:
+            if not message:
+                typ = token.type
+                if typ is Token.EOF:
+                    msg = Messages.UnexpectedEOS
+                elif typ is Token.Identifier:
+                    msg = Messages.UnexpectedIdentifier
+                elif typ is Token.NumericLiteral:
+                    msg = Messages.UnexpectedNumber
+                elif typ is Token.StringLiteral:
+                    msg = Messages.UnexpectedString
+                elif typ is Token.Template:
+                    msg = Messages.UnexpectedTemplate
+                elif typ is Token.Keyword:
+                    if self.scanner.isFutureReservedWord(token.value):
+                        msg = Messages.UnexpectedReserved
+                    elif self.context.strict and self.scanner.isStrictModeReservedWord(token.value):
+                        msg = Messages.StrictReservedWord
+                else:
+                    msg = Messages.UnexpectedToken
+            value = token.value
+        else:
+            value = 'ILLEGAL'
+
+        msg = msg.replace('%0', unicode(value), 1)
+
+        if token and isinstance(token.lineNumber, int):
+            index = token.start
+            line = token.lineNumber
+            lastMarkerLineStart = self.lastMarker.index - self.lastMarker.column
+            column = token.start - lastMarkerLineStart + 1
+            return self.errorHandler.createError(index, line, column, msg)
+        else:
+            index = self.lastMarker.index
+            line = self.lastMarker.line
+            column = self.lastMarker.column + 1
+            return self.errorHandler.createError(index, line, column, msg)
+
+    def throwUnexpectedToken(self, token=None, message=None):
+        raise self.unexpectedTokenError(token, message)
+
+    def tolerateUnexpectedToken(self, token=None, message=None):
+        self.errorHandler.tolerate(self.unexpectedTokenError(token, message))
+
+    def collectComments(self):
+        if not self.config.comment:
+            self.scanner.scanComments()
+        else:
+            comments = self.scanner.scanComments()
+            if comments:
+                for e in comments:
+                    if e.multiLine:
+                        node = Node.BlockComment(self.scanner.source[e.slice[0]:e.slice[1]])
+                    else:
+                        node = Node.LineComment(self.scanner.source[e.slice[0]:e.slice[1]])
+                    if self.config.range:
+                        node.range = e.range
+                    if self.config.loc:
+                        node.loc = e.loc
+                    if self.delegate:
+                        metadata = SourceLocation(
+                            start=Position(
+                                line=e.loc.start.line,
+                                column=e.loc.start.column,
+                                offset=e.range[0],
+                            ),
+                            end=Position(
+                                line=e.loc.end.line,
+                                column=e.loc.end.column,
+                                offset=e.range[1],
+                            )
+                        )
+                        new_node = self.delegate(node, metadata)
+                        if new_node is not None:
+                            node = new_node
+
+    # From internal representation to an external structure
+
+    def getTokenRaw(self, token):
+        return self.scanner.source[token.start:token.end]
+
+    def convertToken(self, token):
+        t = TokenEntry(
+            type=TokenName[token.type],
+            value=self.getTokenRaw(token),
+        )
+        if self.config.range:
+            t.range = [token.start, token.end]
+        if self.config.loc:
+            t.loc = SourceLocation(
+                start=Position(
+                    line=self.startMarker.line,
+                    column=self.startMarker.column,
+                ),
+                end=Position(
+                    line=self.scanner.lineNumber,
+                    column=self.scanner.index - self.scanner.lineStart,
+                ),
+            )
+        if token.type is Token.RegularExpression:
+            t.regex = RegExp(
+                pattern=token.pattern,
+                flags=token.flags,
+            )
+
+        return t
+
+    def nextToken(self):
+        token = self.lookahead
+
+        self.lastMarker.index = self.scanner.index
+        self.lastMarker.line = self.scanner.lineNumber
+        self.lastMarker.column = self.scanner.index - self.scanner.lineStart
+
+        self.collectComments()
+
+        if self.scanner.index != self.startMarker.index:
+            self.startMarker.index = self.scanner.index
+            self.startMarker.line = self.scanner.lineNumber
+            self.startMarker.column = self.scanner.index - self.scanner.lineStart
+
+        next = self.scanner.lex()
+        self.hasLineTerminator = token.lineNumber != next.lineNumber
+
+        if next and self.context.strict and next.type is Token.Identifier:
+            if self.scanner.isStrictModeReservedWord(next.value):
+                next.type = Token.Keyword
+        self.lookahead = next
+
+        if self.config.tokens and next.type is not Token.EOF:
+            self.tokens.append(self.convertToken(next))
+
+        return token
+
+    def nextRegexToken(self):
+        self.collectComments()
+
+        token = self.scanner.scanRegExp()
+        if self.config.tokens:
+            # Pop the previous token, '/' or '/='
+            # self is added from the lookahead token.
+            self.tokens.pop()
+
+            self.tokens.append(self.convertToken(token))
+
+        # Prime the next lookahead.
+        self.lookahead = token
+        self.nextToken()
+
+        return token
+
+    def createNode(self):
+        return Marker(
+            index=self.startMarker.index,
+            line=self.startMarker.line,
+            column=self.startMarker.column,
+        )
+
+    def startNode(self, token, lastLineStart=0):
+        column = token.start - token.lineStart
+        line = token.lineNumber
+        if column < 0:
+            column += lastLineStart
+            line -= 1
+
+        return Marker(
+            index=token.start,
+            line=line,
+            column=column,
+        )
+
+    def finalize(self, marker, node):
+        if self.config.range:
+            node.range = [marker.index, self.lastMarker.index]
+
+        if self.config.loc:
+            node.loc = SourceLocation(
+                start=Position(
+                    line=marker.line,
+                    column=marker.column,
+                ),
+                end=Position(
+                    line=self.lastMarker.line,
+                    column=self.lastMarker.column,
+                ),
+            )
+            if self.config.source:
+                node.loc.source = self.config.source
+
+        if self.delegate:
+            metadata = SourceLocation(
+                start=Position(
+                    line=marker.line,
+                    column=marker.column,
+                    offset=marker.index,
+                ),
+                end=Position(
+                    line=self.lastMarker.line,
+                    column=self.lastMarker.column,
+                    offset=self.lastMarker.index,
+                )
+            )
+            new_node = self.delegate(node, metadata)
+            if new_node is not None:
+                node = new_node
+
+        return node
+
+    # Expect the next token to match the specified punctuator.
+    # If not, an exception will be thrown.
+
+    def expect(self, value):
+        token = self.nextToken()
+        if token.type is not Token.Punctuator or token.value != value:
+            self.throwUnexpectedToken(token)
+
+    # Quietly expect a comma when in tolerant mode, otherwise delegates to expect().
+
+    def expectCommaSeparator(self):
+        if self.config.tolerant:
+            token = self.lookahead
+            if token.type is Token.Punctuator and token.value == ',':
+                self.nextToken()
+            elif token.type is Token.Punctuator and token.value == ';':
+                self.nextToken()
+                self.tolerateUnexpectedToken(token)
+            else:
+                self.tolerateUnexpectedToken(token, Messages.UnexpectedToken)
+        else:
+            self.expect(',')
+
+    # Expect the next token to match the specified keyword.
+    # If not, an exception will be thrown.
+
+    def expectKeyword(self, keyword):
+        token = self.nextToken()
+        if token.type is not Token.Keyword or token.value != keyword:
+            self.throwUnexpectedToken(token)
+
+    # Return true if the next token matches the specified punctuator.
+
+    def match(self, *value):
+        return self.lookahead.type is Token.Punctuator and self.lookahead.value in value
+
+    # Return true if the next token matches the specified keyword
+
+    def matchKeyword(self, *keyword):
+        return self.lookahead.type is Token.Keyword and self.lookahead.value in keyword
+
+    # Return true if the next token matches the specified contextual keyword
+    # (where an identifier is sometimes a keyword depending on the context)
+
+    def matchContextualKeyword(self, *keyword):
+        return self.lookahead.type is Token.Identifier and self.lookahead.value in keyword
+
+    # Return true if the next token is an assignment operator
+
+    def matchAssign(self):
+        if self.lookahead.type is not Token.Punctuator:
+            return False
+
+        op = self.lookahead.value
+        return op in ('=', '*=', '**=', '/=', '%=', '+=', '-=', '<<=', '>>=', '>>>=', '&=', '^=', '|=')
+
+    # Cover grammar support.
+    #
+    # When an assignment expression position starts with a left parenthesis, the determination of the type
+    # of the syntax is to be deferred arbitrarily long until the end of the parentheses pair (plus a lookahead)
+    # or the first comma. This situation also defers the determination of all the expressions nested in the pair.
+    #
+    # There are three productions that can be parsed in a parentheses pair that needs to be determined
+    # after the outermost pair is closed. They are:
+    #
+    #   1. AssignmentExpression
+    #   2. BindingElements
+    #   3. AssignmentTargets
+    #
+    # In order to avoid exponential backtracking, we use two flags to denote if the production can be
+    # binding element or assignment target.
+    #
+    # The three productions have the relationship:
+    #
+    #   BindingElements ⊆ AssignmentTargets ⊆ AssignmentExpression
+    #
+    # with a single exception that CoverInitializedName when used directly in an Expression, generates
+    # an early error. Therefore, we need the third state, firstCoverInitializedNameError, to track the
+    # first usage of CoverInitializedName and report it when we reached the end of the parentheses pair.
+    #
+    # isolateCoverGrammar function runs the given parser function with a new cover grammar context, and it does not
+    # effect the current flags. This means the production the parser parses is only used as an expression. Therefore
+    # the CoverInitializedName check is conducted.
+    #
+    # inheritCoverGrammar function runs the given parse function with a new cover grammar context, and it propagates
+    # the flags outside of the parser. This means the production the parser parses is used as a part of a potential
+    # pattern. The CoverInitializedName check is deferred.
+
+    def isolateCoverGrammar(self, parseFunction):
+        previousIsBindingElement = self.context.isBindingElement
+        previousIsAssignmentTarget = self.context.isAssignmentTarget
+        previousFirstCoverInitializedNameError = self.context.firstCoverInitializedNameError
+
+        self.context.isBindingElement = True
+        self.context.isAssignmentTarget = True
+        self.context.firstCoverInitializedNameError = None
+
+        result = parseFunction()
+        if self.context.firstCoverInitializedNameError is not None:
+            self.throwUnexpectedToken(self.context.firstCoverInitializedNameError)
+
+        self.context.isBindingElement = previousIsBindingElement
+        self.context.isAssignmentTarget = previousIsAssignmentTarget
+        self.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError
+
+        return result
+
+    def inheritCoverGrammar(self, parseFunction):
+        previousIsBindingElement = self.context.isBindingElement
+        previousIsAssignmentTarget = self.context.isAssignmentTarget
+        previousFirstCoverInitializedNameError = self.context.firstCoverInitializedNameError
+
+        self.context.isBindingElement = True
+        self.context.isAssignmentTarget = True
+        self.context.firstCoverInitializedNameError = None
+
+        result = parseFunction()
+
+        self.context.isBindingElement = self.context.isBindingElement and previousIsBindingElement
+        self.context.isAssignmentTarget = self.context.isAssignmentTarget and previousIsAssignmentTarget
+        self.context.firstCoverInitializedNameError = previousFirstCoverInitializedNameError or self.context.firstCoverInitializedNameError
+
+        return result
+
+    def consumeSemicolon(self):
+        if self.match(';'):
+            self.nextToken()
+        elif not self.hasLineTerminator:
+            if self.lookahead.type is not Token.EOF and not self.match('}'):
+                self.throwUnexpectedToken(self.lookahead)
+            self.lastMarker.index = self.startMarker.index
+            self.lastMarker.line = self.startMarker.line
+            self.lastMarker.column = self.startMarker.column
+
+    # https://tc39.github.io/ecma262/#sec-primary-expression
+
+    def parsePrimaryExpression(self):
+        node = self.createNode()
+
+        typ = self.lookahead.type
+        if typ is Token.Identifier:
+            if (self.context.isModule or self.context.allowAwait) and self.lookahead.value == 'await':
+                self.tolerateUnexpectedToken(self.lookahead)
+            expr = self.parseFunctionExpression() if self.matchAsyncFunction() else self.finalize(node, Node.Identifier(self.nextToken().value))
+
+        elif typ in (
+            Token.NumericLiteral,
+            Token.StringLiteral,
+        ):
+            if self.context.strict and self.lookahead.octal:
+                self.tolerateUnexpectedToken(self.lookahead, Messages.StrictOctalLiteral)
+            self.context.isAssignmentTarget = False
+            self.context.isBindingElement = False
+            token = self.nextToken()
+            raw = self.getTokenRaw(token)
+            expr = self.finalize(node, Node.Literal(token.value, raw))
+
+        elif typ is Token.BooleanLiteral:
+            self.context.isAssignmentTarget = False
+            self.context.isBindingElement = False
+            token = self.nextToken()
+            raw = self.getTokenRaw(token)
+            expr = self.finalize(node, Node.Literal(token.value == 'true', raw))
+
+        elif typ is Token.NullLiteral:
+            self.context.isAssignmentTarget = False
+            self.context.isBindingElement = False
+            token = self.nextToken()
+            raw = self.getTokenRaw(token)
+            expr = self.finalize(node, Node.Literal(None, raw))
+
+        elif typ is Token.Template:
+            expr = self.parseTemplateLiteral()
+
+        elif typ is Token.Punctuator:
+            value = self.lookahead.value
+            if value == '(':
+                self.context.isBindingElement = False
+                expr = self.inheritCoverGrammar(self.parseGroupExpression)
+            elif value == '[':
+                expr = self.inheritCoverGrammar(self.parseArrayInitializer)
+            elif value == '{':
+                expr = self.inheritCoverGrammar(self.parseObjectInitializer)
+            elif value in ('/', '/='):
+                self.context.isAssignmentTarget = False
+                self.context.isBindingElement = False
+                self.scanner.index = self.startMarker.index
+                token = self.nextRegexToken()
+                raw = self.getTokenRaw(token)
+                expr = self.finalize(node, Node.RegexLiteral(token.regex, raw, token.pattern, token.flags))
+            else:
+                expr = self.throwUnexpectedToken(self.nextToken())
+
+        elif typ is Token.Keyword:
+            if not self.context.strict and self.context.allowYield and self.matchKeyword('yield'):
+                expr = self.parseIdentifierName()
+            elif not self.context.strict and self.matchKeyword('let'):
+                expr = self.finalize(node, Node.Identifier(self.nextToken().value))
+            else:
+                self.context.isAssignmentTarget = False
+                self.context.isBindingElement = False
+                if self.matchKeyword('function'):
+                    expr = self.parseFunctionExpression()
+                elif self.matchKeyword('this'):
+                    self.nextToken()
+                    expr = self.finalize(node, Node.ThisExpression())
+                elif self.matchKeyword('class'):
+                    expr = self.parseClassExpression()
+                elif self.matchImportCall():
+                    expr = self.parseImportCall()
+                else:
+                    expr = self.throwUnexpectedToken(self.nextToken())
+
+        else:
+            expr = self.throwUnexpectedToken(self.nextToken())
+
+        return expr
+
+    # https://tc39.github.io/ecma262/#sec-array-initializer
+
+    def parseSpreadElement(self):
+        node = self.createNode()
+        self.expect('...')
+        arg = self.inheritCoverGrammar(self.parseAssignmentExpression)
+        return self.finalize(node, Node.SpreadElement(arg))
+
+    def parseArrayInitializer(self):
+        node = self.createNode()
+        elements = []
+
+        self.expect('[')
+        while not self.match(']'):
+            if self.match(','):
+                self.nextToken()
+                elements.append(None)
+            elif self.match('...'):
+                element = self.parseSpreadElement()
+                if not self.match(']'):
+                    self.context.isAssignmentTarget = False
+                    self.context.isBindingElement = False
+                    self.expect(',')
+                elements.append(element)
+            else:
+                elements.append(self.inheritCoverGrammar(self.parseAssignmentExpression))
+                if not self.match(']'):
+                    self.expect(',')
+        self.expect(']')
+
+        return self.finalize(node, Node.ArrayExpression(elements))
+
+    # https://tc39.github.io/ecma262/#sec-object-initializer
+
+    def parsePropertyMethod(self, params):
+        self.context.isAssignmentTarget = False
+        self.context.isBindingElement = False
+
+        previousStrict = self.context.strict
+        previousAllowStrictDirective = self.context.allowStrictDirective
+        self.context.allowStrictDirective = params.simple
+        body = self.isolateCoverGrammar(self.parseFunctionSourceElements)
+        if self.context.strict and params.firstRestricted:
+            self.tolerateUnexpectedToken(params.firstRestricted, params.message)
+        if self.context.strict and params.stricted:
+            self.tolerateUnexpectedToken(params.stricted, params.message)
+        self.context.strict = previousStrict
+        self.context.allowStrictDirective = previousAllowStrictDirective
+
+        return body
+
+    def parsePropertyMethodFunction(self):
+        isGenerator = False
+        node = self.createNode()
+
+        previousAllowYield = self.context.allowYield
+        self.context.allowYield = True
+        params = self.parseFormalParameters()
+        method = self.parsePropertyMethod(params)
+        self.context.allowYield = previousAllowYield
+
+        return self.finalize(node, Node.FunctionExpression(None, params.params, method, isGenerator))
+
+    def parsePropertyMethodAsyncFunction(self):
+        node = self.createNode()
+
+        previousAllowYield = self.context.allowYield
+        previousAwait = self.context.allowAwait
+        self.context.allowYield = False
+        self.context.allowAwait = True
+        params = self.parseFormalParameters()
+        method = self.parsePropertyMethod(params)
+        self.context.allowYield = previousAllowYield
+        self.context.allowAwait = previousAwait
+
+        return self.finalize(node, Node.AsyncFunctionExpression(None, params.params, method))
+
+    def parseObjectPropertyKey(self):
+        node = self.createNode()
+        token = self.nextToken()
+
+        typ = token.type
+        if typ in (
+            Token.StringLiteral,
+            Token.NumericLiteral,
+        ):
+            if self.context.strict and token.octal:
+                self.tolerateUnexpectedToken(token, Messages.StrictOctalLiteral)
+            raw = self.getTokenRaw(token)
+            key = self.finalize(node, Node.Literal(token.value, raw))
+
+        elif typ in (
+            Token.Identifier,
+            Token.BooleanLiteral,
+            Token.NullLiteral,
+            Token.Keyword,
+        ):
+            key = self.finalize(node, Node.Identifier(token.value))
+
+        elif typ is Token.Punctuator:
+            if token.value == '[':
+                key = self.isolateCoverGrammar(self.parseAssignmentExpression)
+                self.expect(']')
+            else:
+                key = self.throwUnexpectedToken(token)
+
+        else:
+            key = self.throwUnexpectedToken(token)
+
+        return key
+
+    def isPropertyKey(self, key, value):
+        return (
+            (key.type is Syntax.Identifier and key.name == value) or
+            (key.type is Syntax.Literal and key.value == value)
+        )
+
+    def parseObjectProperty(self, hasProto):
+        node = self.createNode()
+        token = self.lookahead
+
+        key = None
+        value = None
+
+        computed = False
+        method = False
+        shorthand = False
+        isAsync = False
+
+        if token.type is Token.Identifier:
+            id = token.value
+            self.nextToken()
+            computed = self.match('[')
+            isAsync = not self.hasLineTerminator and (id == 'async') and not (self.match(':', '(', '*', ','))
+            key = self.parseObjectPropertyKey() if isAsync else self.finalize(node, Node.Identifier(id))
+        elif self.match('*'):
+            self.nextToken()
+        else:
+            computed = self.match('[')
+            key = self.parseObjectPropertyKey()
+
+        lookaheadPropertyKey = self.qualifiedPropertyName(self.lookahead)
+        if token.type is Token.Identifier and not isAsync and token.value == 'get' and lookaheadPropertyKey:
+            kind = 'get'
+            computed = self.match('[')
+            key = self.parseObjectPropertyKey()
+            self.context.allowYield = False
+            value = self.parseGetterMethod()
+
+        elif token.type is Token.Identifier and not isAsync and token.value == 'set' and lookaheadPropertyKey:
+            kind = 'set'
+            computed = self.match('[')
+            key = self.parseObjectPropertyKey()
+            value = self.parseSetterMethod()
+
+        elif token.type is Token.Punctuator and token.value == '*' and lookaheadPropertyKey:
+            kind = 'init'
+            computed = self.match('[')
+            key = self.parseObjectPropertyKey()
+            value = self.parseGeneratorMethod()
+            method = True
+
+        else:
+            if not key:
+                self.throwUnexpectedToken(self.lookahead)
+
+            kind = 'init'
+            if self.match(':') and not isAsync:
+                if not computed and self.isPropertyKey(key, '__proto__'):
+                    if hasProto.value:
+                        self.tolerateError(Messages.DuplicateProtoProperty)
+                    hasProto.value = True
+                self.nextToken()
+                value = self.inheritCoverGrammar(self.parseAssignmentExpression)
+
+            elif self.match('('):
+                value = self.parsePropertyMethodAsyncFunction() if isAsync else self.parsePropertyMethodFunction()
+                method = True
+
+            elif token.type is Token.Identifier:
+                id = self.finalize(node, Node.Identifier(token.value))
+                if self.match('='):
+                    self.context.firstCoverInitializedNameError = self.lookahead
+                    self.nextToken()
+                    shorthand = True
+                    init = self.isolateCoverGrammar(self.parseAssignmentExpression)
+                    value = self.finalize(node, Node.AssignmentPattern(id, init))
+                else:
+                    shorthand = True
+                    value = id
+            else:
+                self.throwUnexpectedToken(self.nextToken())
+
+        return self.finalize(node, Node.Property(kind, key, computed, value, method, shorthand))
+
+    def parseObjectInitializer(self):
+        node = self.createNode()
+
+        self.expect('{')
+        properties = []
+        hasProto = Value(False)
+        while not self.match('}'):
+            properties.append(self.parseSpreadElement() if self.match('...') else self.parseObjectProperty(hasProto))
+            if not self.match('}'):
+                self.expectCommaSeparator()
+        self.expect('}')
+
+        return self.finalize(node, Node.ObjectExpression(properties))
+
+    # https://tc39.github.io/ecma262/#sec-template-literals
+
+    def parseTemplateHead(self):
+        assert self.lookahead.head, 'Template literal must start with a template head'
+
+        node = self.createNode()
+        token = self.nextToken()
+        raw = token.value
+        cooked = token.cooked
+
+        return self.finalize(node, Node.TemplateElement(raw, cooked, token.tail))
+
+    def parseTemplateElement(self):
+        if self.lookahead.type is not Token.Template:
+            self.throwUnexpectedToken()
+
+        node = self.createNode()
+        token = self.nextToken()
+        raw = token.value
+        cooked = token.cooked
+
+        return self.finalize(node, Node.TemplateElement(raw, cooked, token.tail))
+
+    def parseTemplateLiteral(self):
+        node = self.createNode()
+
+        expressions = []
+        quasis = []
+
+        quasi = self.parseTemplateHead()
+        quasis.append(quasi)
+        while not quasi.tail:
+            expressions.append(self.parseExpression())
+            quasi = self.parseTemplateElement()
+            quasis.append(quasi)
+
+        return self.finalize(node, Node.TemplateLiteral(quasis, expressions))
+
+    # https://tc39.github.io/ecma262/#sec-grouping-operator
+
+    def reinterpretExpressionAsPattern(self, expr):
+        typ = expr.type
+        if typ in (
+            Syntax.Identifier,
+            Syntax.MemberExpression,
+            Syntax.RestElement,
+            Syntax.AssignmentPattern,
+        ):
+            pass
+        elif typ is Syntax.SpreadElement:
+            expr.type = Syntax.RestElement
+            self.reinterpretExpressionAsPattern(expr.argument)
+        elif typ is Syntax.ArrayExpression:
+            expr.type = Syntax.ArrayPattern
+            for elem in expr.elements:
+                if elem is not None:
+                    self.reinterpretExpressionAsPattern(elem)
+        elif typ is Syntax.ObjectExpression:
+            expr.type = Syntax.ObjectPattern
+            for prop in expr.properties:
+                self.reinterpretExpressionAsPattern(prop if prop.type is Syntax.SpreadElement else prop.value)
+        elif typ is Syntax.AssignmentExpression:
+            expr.type = Syntax.AssignmentPattern
+            del expr.operator
+            self.reinterpretExpressionAsPattern(expr.left)
+        else:
+            # Allow other node type for tolerant parsing.
+            pass
+
+    def parseGroupExpression(self):
+        self.expect('(')
+        if self.match(')'):
+            self.nextToken()
+            if not self.match('=>'):
+                self.expect('=>')
+            expr = Node.ArrowParameterPlaceHolder([])
+        else:
+            startToken = self.lookahead
+            params = []
+            if self.match('...'):
+                expr = self.parseRestElement(params)
+                self.expect(')')
+                if not self.match('=>'):
+                    self.expect('=>')
+                expr = Node.ArrowParameterPlaceHolder([expr])
+            else:
+                arrow = False
+                self.context.isBindingElement = True
+                expr = self.inheritCoverGrammar(self.parseAssignmentExpression)
+
+                if self.match(','):
+                    expressions = []
+
+                    self.context.isAssignmentTarget = False
+                    expressions.append(expr)
+                    while self.lookahead.type is not Token.EOF:
+                        if not self.match(','):
+                            break
+                        self.nextToken()
+                        if self.match(')'):
+                            self.nextToken()
+                            for expression in expressions:
+                                self.reinterpretExpressionAsPattern(expression)
+                            arrow = True
+                            expr = Node.ArrowParameterPlaceHolder(expressions)
+                        elif self.match('...'):
+                            if not self.context.isBindingElement:
+                                self.throwUnexpectedToken(self.lookahead)
+                            expressions.append(self.parseRestElement(params))
+                            self.expect(')')
+                            if not self.match('=>'):
+                                self.expect('=>')
+                            self.context.isBindingElement = False
+                            for expression in expressions:
+                                self.reinterpretExpressionAsPattern(expression)
+                            arrow = True
+                            expr = Node.ArrowParameterPlaceHolder(expressions)
+                        else:
+                            expressions.append(self.inheritCoverGrammar(self.parseAssignmentExpression))
+                        if arrow:
+                            break
+                    if not arrow:
+                        expr = self.finalize(self.startNode(startToken), Node.SequenceExpression(expressions))
+
+                if not arrow:
+                    self.expect(')')
+                    if self.match('=>'):
+                        if expr.type is Syntax.Identifier and expr.name == 'yield':
+                            arrow = True
+                            expr = Node.ArrowParameterPlaceHolder([expr])
+                        if not arrow:
+                            if not self.context.isBindingElement:
+                                self.throwUnexpectedToken(self.lookahead)
+
+                            if expr.type is Syntax.SequenceExpression:
+                                for expression in expr.expressions:
+                                    self.reinterpretExpressionAsPattern(expression)
+                            else:
+                                self.reinterpretExpressionAsPattern(expr)
+
+                            if expr.type is Syntax.SequenceExpression:
+                                parameters = expr.expressions
+                            else:
+                                parameters = [expr]
+                            expr = Node.ArrowParameterPlaceHolder(parameters)
+                    self.context.isBindingElement = False
+
+        return expr
+
+    # https://tc39.github.io/ecma262/#sec-left-hand-side-expressions
+
+    def parseArguments(self):
+        self.expect('(')
+        args = []
+        if not self.match(')'):
+            while True:
+                if self.match('...'):
+                    expr = self.parseSpreadElement()
+                else:
+                    expr = self.isolateCoverGrammar(self.parseAssignmentExpression)
+                args.append(expr)
+                if self.match(')'):
+                    break
+                self.expectCommaSeparator()
+                if self.match(')'):
+                    break
+        self.expect(')')
+
+        return args
+
+    def isIdentifierName(self, token):
+        return (
+            token.type is Token.Identifier or
+            token.type is Token.Keyword or
+            token.type is Token.BooleanLiteral or
+            token.type is Token.NullLiteral
+        )
+
+    def parseIdentifierName(self):
+        node = self.createNode()
+        token = self.nextToken()
+        if not self.isIdentifierName(token):
+            self.throwUnexpectedToken(token)
+        return self.finalize(node, Node.Identifier(token.value))
+
+    def parseNewExpression(self):
+        node = self.createNode()
+
+        id = self.parseIdentifierName()
+        assert id.name == 'new', 'New expression must start with `new`'
+
+        if self.match('.'):
+            self.nextToken()
+            if self.lookahead.type is Token.Identifier and self.context.inFunctionBody and self.lookahead.value == 'target':
+                property = self.parseIdentifierName()
+                expr = Node.MetaProperty(id, property)
+            else:
+                self.throwUnexpectedToken(self.lookahead)
+        elif self.matchKeyword('import'):
+            self.throwUnexpectedToken(self.lookahead)
+        else:
+            callee = self.isolateCoverGrammar(self.parseLeftHandSideExpression)
+            args = self.parseArguments() if self.match('(') else []
+            expr = Node.NewExpression(callee, args)
+            self.context.isAssignmentTarget = False
+            self.context.isBindingElement = False
+
+        return self.finalize(node, expr)
+
+    def parseAsyncArgument(self):
+        arg = self.parseAssignmentExpression()
+        self.context.firstCoverInitializedNameError = None
+        return arg
+
+    def parseAsyncArguments(self):
+        self.expect('(')
+        args = []
+        if not self.match(')'):
+            while True:
+                if self.match('...'):
+                    expr = self.parseSpreadElement()
+                else:
+                    expr = self.isolateCoverGrammar(self.parseAsyncArgument)
+                args.append(expr)
+                if self.match(')'):
+                    break
+                self.expectCommaSeparator()
+                if self.match(')'):
+                    break
+        self.expect(')')
+
+        return args
+
+    def matchImportCall(self):
+        match = self.matchKeyword('import')
+        if match:
+            state = self.scanner.saveState()
+            self.scanner.scanComments()
+            next = self.scanner.lex()
+            self.scanner.restoreState(state)
+            match = (next.type is Token.Punctuator) and (next.value == '(')
+
+        return match
+
+    def parseImportCall(self):
+        node = self.createNode()
+        self.expectKeyword('import')
+        return self.finalize(node, Node.Import())
+
+    def parseLeftHandSideExpressionAllowCall(self):
+        startToken = self.lookahead
+        maybeAsync = self.matchContextualKeyword('async')
+
+        previousAllowIn = self.context.allowIn
+        self.context.allowIn = True
+
+        if self.matchKeyword('super') and self.context.inFunctionBody:
+            expr = self.createNode()
+            self.nextToken()
+            expr = self.finalize(expr, Node.Super())
+            if not self.match('(') and not self.match('.') and not self.match('['):
+                self.throwUnexpectedToken(self.lookahead)
+        else:
+            expr = self.inheritCoverGrammar(self.parseNewExpression if self.matchKeyword('new') else self.parsePrimaryExpression)
+
+        while True:
+            if self.match('.'):
+                self.context.isBindingElement = False
+                self.context.isAssignmentTarget = True
+                self.expect('.')
+                property = self.parseIdentifierName()
+                expr = self.finalize(self.startNode(startToken), Node.StaticMemberExpression(expr, property))
+
+            elif self.match('('):
+                asyncArrow = maybeAsync and (startToken.lineNumber == self.lookahead.lineNumber)
+                self.context.isBindingElement = False
+                self.context.isAssignmentTarget = False
+                if asyncArrow:
+                    args = self.parseAsyncArguments()
+                else:
+                    args = self.parseArguments()
+                if expr.type is Syntax.Import and len(args) != 1:
+                    self.tolerateError(Messages.BadImportCallArity)
+                expr = self.finalize(self.startNode(startToken), Node.CallExpression(expr, args))
+                if asyncArrow and self.match('=>'):
+                    for arg in args:
+                        self.reinterpretExpressionAsPattern(arg)
+                    expr = Node.AsyncArrowParameterPlaceHolder(args)
+            elif self.match('['):
+                self.context.isBindingElement = False
+                self.context.isAssignmentTarget = True
+                self.expect('[')
+                property = self.isolateCoverGrammar(self.parseExpression)
+                self.expect(']')
+                expr = self.finalize(self.startNode(startToken), Node.ComputedMemberExpression(expr, property))
+
+            elif self.lookahead.type is Token.Template and self.lookahead.head:
+                quasi = self.parseTemplateLiteral()
+                expr = self.finalize(self.startNode(startToken), Node.TaggedTemplateExpression(expr, quasi))
+
+            else:
+                break
+
+        self.context.allowIn = previousAllowIn
+
+        return expr
+
+    def parseSuper(self):
+        node = self.createNode()
+
+        self.expectKeyword('super')
+        if not self.match('[') and not self.match('.'):
+            self.throwUnexpectedToken(self.lookahead)
+
+        return self.finalize(node, Node.Super())
+
+    def parseLeftHandSideExpression(self):
+        assert self.context.allowIn, 'callee of new expression always allow in keyword.'
+
+        node = self.startNode(self.lookahead)
+        if self.matchKeyword('super') and self.context.inFunctionBody:
+            expr = self.parseSuper()
+        else:
+            expr = self.inheritCoverGrammar(self.parseNewExpression if self.matchKeyword('new') else self.parsePrimaryExpression)
+
+        while True:
+            if self.match('['):
+                self.context.isBindingElement = False
+                self.context.isAssignmentTarget = True
+                self.expect('[')
+                property = self.isolateCoverGrammar(self.parseExpression)
+                self.expect(']')
+                expr = self.finalize(node, Node.ComputedMemberExpression(expr, property))
+
+            elif self.match('.'):
+                self.context.isBindingElement = False
+                self.context.isAssignmentTarget = True
+                self.expect('.')
+                property = self.parseIdentifierName()
+                expr = self.finalize(node, Node.StaticMemberExpression(expr, property))
+
+            elif self.lookahead.type is Token.Template and self.lookahead.head:
+                quasi = self.parseTemplateLiteral()
+                expr = self.finalize(node, Node.TaggedTemplateExpression(expr, quasi))
+
+            else:
+                break
+
+        return expr
+
+    # https://tc39.github.io/ecma262/#sec-update-expressions
+
+    def parseUpdateExpression(self):
+        startToken = self.lookahead
+
+        if self.match('++', '--'):
+            node = self.startNode(startToken)
+            token = self.nextToken()
+            expr = self.inheritCoverGrammar(self.parseUnaryExpression)
+            if self.context.strict and expr.type is Syntax.Identifier and self.scanner.isRestrictedWord(expr.name):
+                self.tolerateError(Messages.StrictLHSPrefix)
+            if not self.context.isAssignmentTarget:
+                self.tolerateError(Messages.InvalidLHSInAssignment)
+            prefix = True
+            expr = self.finalize(node, Node.UpdateExpression(token.value, expr, prefix))
+            self.context.isAssignmentTarget = False
+            self.context.isBindingElement = False
+        else:
+            expr = self.inheritCoverGrammar(self.parseLeftHandSideExpressionAllowCall)
+            if not self.hasLineTerminator and self.lookahead.type is Token.Punctuator:
+                if self.match('++', '--'):
+                    if self.context.strict and expr.type is Syntax.Identifier and self.scanner.isRestrictedWord(expr.name):
+                        self.tolerateError(Messages.StrictLHSPostfix)
+                    if not self.context.isAssignmentTarget:
+                        self.tolerateError(Messages.InvalidLHSInAssignment)
+                    self.context.isAssignmentTarget = False
+                    self.context.isBindingElement = False
+                    operator = self.nextToken().value
+                    prefix = False
+                    expr = self.finalize(self.startNode(startToken), Node.UpdateExpression(operator, expr, prefix))
+
+        return expr
+
+    # https://tc39.github.io/ecma262/#sec-unary-operators
+
+    def parseAwaitExpression(self):
+        node = self.createNode()
+        self.nextToken()
+        argument = self.parseUnaryExpression()
+        return self.finalize(node, Node.AwaitExpression(argument))
+
+    def parseUnaryExpression(self):
+        if (
+            self.match('+', '-', '~', '!') or
+            self.matchKeyword('delete', 'void', 'typeof')
+        ):
+            node = self.startNode(self.lookahead)
+            token = self.nextToken()
+            expr = self.inheritCoverGrammar(self.parseUnaryExpression)
+            expr = self.finalize(node, Node.UnaryExpression(token.value, expr))
+            if self.context.strict and expr.operator == 'delete' and expr.argument.type is Syntax.Identifier:
+                self.tolerateError(Messages.StrictDelete)
+            self.context.isAssignmentTarget = False
+            self.context.isBindingElement = False
+        elif self.context.allowAwait and self.matchContextualKeyword('await'):
+            expr = self.parseAwaitExpression()
+        else:
+            expr = self.parseUpdateExpression()
+
+        return expr
+
+    def parseExponentiationExpression(self):
+        startToken = self.lookahead
+
+        expr = self.inheritCoverGrammar(self.parseUnaryExpression)
+        if expr.type is not Syntax.UnaryExpression and self.match('**'):
+            self.nextToken()
+            self.context.isAssignmentTarget = False
+            self.context.isBindingElement = False
+            left = expr
+            right = self.isolateCoverGrammar(self.parseExponentiationExpression)
+            expr = self.finalize(self.startNode(startToken), Node.BinaryExpression('**', left, right))
+
+        return expr
+
+    # https://tc39.github.io/ecma262/#sec-exp-operator
+    # https://tc39.github.io/ecma262/#sec-multiplicative-operators
+    # https://tc39.github.io/ecma262/#sec-additive-operators
+    # https://tc39.github.io/ecma262/#sec-bitwise-shift-operators
+    # https://tc39.github.io/ecma262/#sec-relational-operators
+    # https://tc39.github.io/ecma262/#sec-equality-operators
+    # https://tc39.github.io/ecma262/#sec-binary-bitwise-operators
+    # https://tc39.github.io/ecma262/#sec-binary-logical-operators
+
+    def binaryPrecedence(self, token):
+        op = token.value
+        if token.type is Token.Punctuator:
+            precedence = self.operatorPrecedence.get(op, 0)
+        elif token.type is Token.Keyword:
+            precedence = 7 if (op == 'instanceof' or (self.context.allowIn and op == 'in')) else 0
+        else:
+            precedence = 0
+        return precedence
+
+    def parseBinaryExpression(self):
+        startToken = self.lookahead
+
+        expr = self.inheritCoverGrammar(self.parseExponentiationExpression)
+
+        token = self.lookahead
+        prec = self.binaryPrecedence(token)
+        if prec > 0:
+            self.nextToken()
+
+            self.context.isAssignmentTarget = False
+            self.context.isBindingElement = False
+
+            markers = [startToken, self.lookahead]
+            left = expr
+            right = self.isolateCoverGrammar(self.parseExponentiationExpression)
+
+            stack = [left, token.value, right]
+            precedences = [prec]
+            while True:
+                prec = self.binaryPrecedence(self.lookahead)
+                if prec <= 0:
+                    break
+
+                # Reduce: make a binary expression from the three topmost entries.
+                while len(stack) > 2 and prec <= precedences[-1]:
+                    right = stack.pop()
+                    operator = stack.pop()
+                    precedences.pop()
+                    left = stack.pop()
+                    markers.pop()
+                    node = self.startNode(markers[-1])
+                    stack.append(self.finalize(node, Node.BinaryExpression(operator, left, right)))
+
+                # Shift.
+                stack.append(self.nextToken().value)
+                precedences.append(prec)
+                markers.append(self.lookahead)
+                stack.append(self.isolateCoverGrammar(self.parseExponentiationExpression))
+
+            # Final reduce to clean-up the stack.
+            i = len(stack) - 1
+            expr = stack[i]
+
+            lastMarker = markers.pop()
+            while i > 1:
+                marker = markers.pop()
+                lastLineStart = lastMarker.lineStart if lastMarker else 0
+                node = self.startNode(marker, lastLineStart)
+                operator = stack[i - 1]
+                expr = self.finalize(node, Node.BinaryExpression(operator, stack[i - 2], expr))
+                i -= 2
+                lastMarker = marker
+
+        return expr
+
+    # https://tc39.github.io/ecma262/#sec-conditional-operator
+
+    def parseConditionalExpression(self):
+        startToken = self.lookahead
+
+        expr = self.inheritCoverGrammar(self.parseBinaryExpression)
+        if self.match('?'):
+            self.nextToken()
+
+            previousAllowIn = self.context.allowIn
+            self.context.allowIn = True
+            consequent = self.isolateCoverGrammar(self.parseAssignmentExpression)
+            self.context.allowIn = previousAllowIn
+
+            self.expect(':')
+            alternate = self.isolateCoverGrammar(self.parseAssignmentExpression)
+
+            expr = self.finalize(self.startNode(startToken), Node.ConditionalExpression(expr, consequent, alternate))
+            self.context.isAssignmentTarget = False
+            self.context.isBindingElement = False
+
+        return expr
+
+    # https://tc39.github.io/ecma262/#sec-assignment-operators
+
+    def checkPatternParam(self, options, param):
+        typ = param.type
+        if typ is Syntax.Identifier:
+            self.validateParam(options, param, param.name)
+        elif typ is Syntax.RestElement:
+            self.checkPatternParam(options, param.argument)
+        elif typ is Syntax.AssignmentPattern:
+            self.checkPatternParam(options, param.left)
+        elif typ is Syntax.ArrayPattern:
+            for element in param.elements:
+                if element is not None:
+                    self.checkPatternParam(options, element)
+        elif typ is Syntax.ObjectPattern:
+            for prop in param.properties:
+                self.checkPatternParam(options, prop if prop.type is Syntax.RestElement else prop.value)
+
+        options.simple = options.simple and isinstance(param, Node.Identifier)
+
+    def reinterpretAsCoverFormalsList(self, expr):
+        params = [expr]
+
+        asyncArrow = False
+        typ = expr.type
+        if typ is Syntax.Identifier:
+            pass
+        elif typ is Syntax.ArrowParameterPlaceHolder:
+            params = expr.params
+            asyncArrow = expr.isAsync
+        else:
+            return None
+
+        options = Params(
+            simple=True,
+            paramSet={},
+        )
+
+        for param in params:
+            if param.type is Syntax.AssignmentPattern:
+                if param.right.type is Syntax.YieldExpression:
+                    if param.right.argument:
+                        self.throwUnexpectedToken(self.lookahead)
+                    param.right.type = Syntax.Identifier
+                    param.right.name = 'yield'
+                    del param.right.argument
+                    del param.right.delegate
+            elif asyncArrow and param.type is Syntax.Identifier and param.name == 'await':
+                self.throwUnexpectedToken(self.lookahead)
+            self.checkPatternParam(options, param)
+
+        if self.context.strict or not self.context.allowYield:
+            for param in params:
+                if param.type is Syntax.YieldExpression:
+                    self.throwUnexpectedToken(self.lookahead)
+
+        if options.message is Messages.StrictParamDupe:
+            token = options.stricted if self.context.strict else options.firstRestricted
+            self.throwUnexpectedToken(token, options.message)
+
+        return Params(
+            simple=options.simple,
+            params=params,
+            stricted=options.stricted,
+            firstRestricted=options.firstRestricted,
+            message=options.message
+        )
+
+    def parseAssignmentExpression(self):
+        if not self.context.allowYield and self.matchKeyword('yield'):
+            expr = self.parseYieldExpression()
+        else:
+            startToken = self.lookahead
+            token = startToken
+            expr = self.parseConditionalExpression()
+
+            if token.type is Token.Identifier and (token.lineNumber == self.lookahead.lineNumber) and token.value == 'async':
+                if self.lookahead.type is Token.Identifier or self.matchKeyword('yield'):
+                    arg = self.parsePrimaryExpression()
+                    self.reinterpretExpressionAsPattern(arg)
+                    expr = Node.AsyncArrowParameterPlaceHolder([arg])
+
+            if expr.type is Syntax.ArrowParameterPlaceHolder or self.match('=>'):
+
+                # https://tc39.github.io/ecma262/#sec-arrow-function-definitions
+                self.context.isAssignmentTarget = False
+                self.context.isBindingElement = False
+                isAsync = expr.isAsync
+                list = self.reinterpretAsCoverFormalsList(expr)
+
+                if list:
+                    if self.hasLineTerminator:
+                        self.tolerateUnexpectedToken(self.lookahead)
+                    self.context.firstCoverInitializedNameError = None
+
+                    previousStrict = self.context.strict
+                    previousAllowStrictDirective = self.context.allowStrictDirective
+                    self.context.allowStrictDirective = list.simple
+
+                    previousAllowYield = self.context.allowYield
+                    previousAwait = self.context.allowAwait
+                    self.context.allowYield = True
+                    self.context.allowAwait = isAsync
+
+                    node = self.startNode(startToken)
+                    self.expect('=>')
+                    if self.match('{'):
+                        previousAllowIn = self.context.allowIn
+                        self.context.allowIn = True
+                        body = self.parseFunctionSourceElements()
+                        self.context.allowIn = previousAllowIn
+                    else:
+                        body = self.isolateCoverGrammar(self.parseAssignmentExpression)
+                    expression = body.type is not Syntax.BlockStatement
+
+                    if self.context.strict and list.firstRestricted:
+                        self.throwUnexpectedToken(list.firstRestricted, list.message)
+                    if self.context.strict and list.stricted:
+                        self.tolerateUnexpectedToken(list.stricted, list.message)
+                    if isAsync:
+                        expr = self.finalize(node, Node.AsyncArrowFunctionExpression(list.params, body, expression))
+                    else:
+                        expr = self.finalize(node, Node.ArrowFunctionExpression(list.params, body, expression))
+
+                    self.context.strict = previousStrict
+                    self.context.allowStrictDirective = previousAllowStrictDirective
+                    self.context.allowYield = previousAllowYield
+                    self.context.allowAwait = previousAwait
+            else:
+                if self.matchAssign():
+                    if not self.context.isAssignmentTarget:
+                        self.tolerateError(Messages.InvalidLHSInAssignment)
+
+                    if self.context.strict and expr.type is Syntax.Identifier:
+                        id = expr
+                        if self.scanner.isRestrictedWord(id.name):
+                            self.tolerateUnexpectedToken(token, Messages.StrictLHSAssignment)
+                        if self.scanner.isStrictModeReservedWord(id.name):
+                            self.tolerateUnexpectedToken(token, Messages.StrictReservedWord)
+
+                    if not self.match('='):
+                        self.context.isAssignmentTarget = False
+                        self.context.isBindingElement = False
+                    else:
+                        self.reinterpretExpressionAsPattern(expr)
+
+                    token = self.nextToken()
+                    operator = token.value
+                    right = self.isolateCoverGrammar(self.parseAssignmentExpression)
+                    expr = self.finalize(self.startNode(startToken), Node.AssignmentExpression(operator, expr, right))
+                    self.context.firstCoverInitializedNameError = None
+
+        return expr
+
+    # https://tc39.github.io/ecma262/#sec-comma-operator
+
+    def parseExpression(self):
+        startToken = self.lookahead
+        expr = self.isolateCoverGrammar(self.parseAssignmentExpression)
+
+        if self.match(','):
+            expressions = []
+            expressions.append(expr)
+            while self.lookahead.type is not Token.EOF:
+                if not self.match(','):
+                    break
+                self.nextToken()
+                expressions.append(self.isolateCoverGrammar(self.parseAssignmentExpression))
+
+            expr = self.finalize(self.startNode(startToken), Node.SequenceExpression(expressions))
+
+        return expr
+
+    # https://tc39.github.io/ecma262/#sec-block
+
+    def parseStatementListItem(self):
+        self.context.isAssignmentTarget = True
+        self.context.isBindingElement = True
+        if self.lookahead.type is Token.Keyword:
+            value = self.lookahead.value
+            if value == 'export':
+                if not self.context.isModule:
+                    self.tolerateUnexpectedToken(self.lookahead, Messages.IllegalExportDeclaration)
+                statement = self.parseExportDeclaration()
+            elif value == 'import':
+                if self.matchImportCall():
+                    statement = self.parseExpressionStatement()
+                else:
+                    if not self.context.isModule:
+                        self.tolerateUnexpectedToken(self.lookahead, Messages.IllegalImportDeclaration)
+                    statement = self.parseImportDeclaration()
+            elif value == 'const':
+                statement = self.parseLexicalDeclaration(Params(inFor=False))
+            elif value == 'function':
+                statement = self.parseFunctionDeclaration()
+            elif value == 'class':
+                statement = self.parseClassDeclaration()
+            elif value == 'let':
+                statement = self.parseLexicalDeclaration(Params(inFor=False)) if self.isLexicalDeclaration() else self.parseStatement()
+            else:
+                statement = self.parseStatement()
+        else:
+            statement = self.parseStatement()
+
+        return statement
+
+    def parseBlock(self):
+        node = self.createNode()
+
+        self.expect('{')
+        block = []
+        while True:
+            if self.match('}'):
+                break
+            block.append(self.parseStatementListItem())
+        self.expect('}')
+
+        return self.finalize(node, Node.BlockStatement(block))
+
+    # https://tc39.github.io/ecma262/#sec-let-and-const-declarations
+
+    def parseLexicalBinding(self, kind, options):
+        node = self.createNode()
+        params = []
+        id = self.parsePattern(params, kind)
+
+        if self.context.strict and id.type is Syntax.Identifier:
+            if self.scanner.isRestrictedWord(id.name):
+                self.tolerateError(Messages.StrictVarName)
+
+        init = None
+        if kind == 'const':
+            if not self.matchKeyword('in') and not self.matchContextualKeyword('of'):
+                if self.match('='):
+                    self.nextToken()
+                    init = self.isolateCoverGrammar(self.parseAssignmentExpression)
+                else:
+                    self.throwError(Messages.DeclarationMissingInitializer, 'const')
+        elif (not options.inFor and id.type is not Syntax.Identifier) or self.match('='):
+            self.expect('=')
+            init = self.isolateCoverGrammar(self.parseAssignmentExpression)
+
+        return self.finalize(node, Node.VariableDeclarator(id, init))
+
+    def parseBindingList(self, kind, options):
+        lst = [self.parseLexicalBinding(kind, options)]
+
+        while self.match(','):
+            self.nextToken()
+            lst.append(self.parseLexicalBinding(kind, options))
+
+        return lst
+
+    def isLexicalDeclaration(self):
+        state = self.scanner.saveState()
+        self.scanner.scanComments()
+        next = self.scanner.lex()
+        self.scanner.restoreState(state)
+
+        return (
+            (next.type is Token.Identifier) or
+            (next.type is Token.Punctuator and next.value == '[') or
+            (next.type is Token.Punctuator and next.value == '{') or
+            (next.type is Token.Keyword and next.value == 'let') or
+            (next.type is Token.Keyword and next.value == 'yield')
+        )
+
+    def parseLexicalDeclaration(self, options):
+        node = self.createNode()
+        kind = self.nextToken().value
+        assert kind == 'let' or kind == 'const', 'Lexical declaration must be either or const'
+
+        declarations = self.parseBindingList(kind, options)
+        self.consumeSemicolon()
+
+        return self.finalize(node, Node.VariableDeclaration(declarations, kind))
+
+    # https://tc39.github.io/ecma262/#sec-destructuring-binding-patterns
+
+    def parseBindingRestElement(self, params, kind=None):
+        node = self.createNode()
+
+        self.expect('...')
+        arg = self.parsePattern(params, kind)
+
+        return self.finalize(node, Node.RestElement(arg))
+
+    def parseArrayPattern(self, params, kind=None):
+        node = self.createNode()
+
+        self.expect('[')
+        elements = []
+        while not self.match(']'):
+            if self.match(','):
+                self.nextToken()
+                elements.append(None)
+            else:
+                if self.match('...'):
+                    elements.append(self.parseBindingRestElement(params, kind))
+                    break
+                else:
+                    elements.append(self.parsePatternWithDefault(params, kind))
+                if not self.match(']'):
+                    self.expect(',')
+        self.expect(']')
+
+        return self.finalize(node, Node.ArrayPattern(elements))
+
+    def parsePropertyPattern(self, params, kind=None):
+        node = self.createNode()
+
+        computed = False
+        shorthand = False
+        method = False
+
+        key = None
+
+        if self.lookahead.type is Token.Identifier:
+            keyToken = self.lookahead
+            key = self.parseVariableIdentifier()
+            init = self.finalize(node, Node.Identifier(keyToken.value))
+            if self.match('='):
+                params.append(keyToken)
+                shorthand = True
+                self.nextToken()
+                expr = self.parseAssignmentExpression()
+                value = self.finalize(self.startNode(keyToken), Node.AssignmentPattern(init, expr))
+            elif not self.match(':'):
+                params.append(keyToken)
+                shorthand = True
+                value = init
+            else:
+                self.expect(':')
+                value = self.parsePatternWithDefault(params, kind)
+        else:
+            computed = self.match('[')
+            key = self.parseObjectPropertyKey()
+            self.expect(':')
+            value = self.parsePatternWithDefault(params, kind)
+
+        return self.finalize(node, Node.Property('init', key, computed, value, method, shorthand))
+
+    def parseRestProperty(self, params, kind):
+        node = self.createNode()
+        self.expect('...')
+        arg = self.parsePattern(params)
+        if self.match('='):
+            self.throwError(Messages.DefaultRestProperty)
+        if not self.match('}'):
+            self.throwError(Messages.PropertyAfterRestProperty)
+        return self.finalize(node, Node.RestElement(arg))
+
+    def parseObjectPattern(self, params, kind=None):
+        node = self.createNode()
+        properties = []
+
+        self.expect('{')
+        while not self.match('}'):
+            properties.append(self.parseRestProperty(params, kind) if self.match('...') else self.parsePropertyPattern(params, kind))
+            if not self.match('}'):
+                self.expect(',')
+        self.expect('}')
+
+        return self.finalize(node, Node.ObjectPattern(properties))
+
+    def parsePattern(self, params, kind=None):
+        if self.match('['):
+            pattern = self.parseArrayPattern(params, kind)
+        elif self.match('{'):
+            pattern = self.parseObjectPattern(params, kind)
+        else:
+            if self.matchKeyword('let') and (kind in ('const', 'let')):
+                self.tolerateUnexpectedToken(self.lookahead, Messages.LetInLexicalBinding)
+            params.append(self.lookahead)
+            pattern = self.parseVariableIdentifier(kind)
+
+        return pattern
+
+    def parsePatternWithDefault(self, params, kind=None):
+        startToken = self.lookahead
+
+        pattern = self.parsePattern(params, kind)
+        if self.match('='):
+            self.nextToken()
+            previousAllowYield = self.context.allowYield
+            self.context.allowYield = True
+            right = self.isolateCoverGrammar(self.parseAssignmentExpression)
+            self.context.allowYield = previousAllowYield
+            pattern = self.finalize(self.startNode(startToken), Node.AssignmentPattern(pattern, right))
+
+        return pattern
+
+    # https://tc39.github.io/ecma262/#sec-variable-statement
+
+    def parseVariableIdentifier(self, kind=None):
+        node = self.createNode()
+
+        token = self.nextToken()
+        if token.type is Token.Keyword and token.value == 'yield':
+            if self.context.strict:
+                self.tolerateUnexpectedToken(token, Messages.StrictReservedWord)
+            elif not self.context.allowYield:
+                self.throwUnexpectedToken(token)
+        elif token.type is not Token.Identifier:
+            if self.context.strict and token.type is Token.Keyword and self.scanner.isStrictModeReservedWord(token.value):
+                self.tolerateUnexpectedToken(token, Messages.StrictReservedWord)
+            else:
+                if self.context.strict or token.value != 'let' or kind != 'var':
+                    self.throwUnexpectedToken(token)
+        elif (self.context.isModule or self.context.allowAwait) and token.type is Token.Identifier and token.value == 'await':
+            self.tolerateUnexpectedToken(token)
+
+        return self.finalize(node, Node.Identifier(token.value))
+
+    def parseVariableDeclaration(self, options):
+        node = self.createNode()
+
+        params = []
+        id = self.parsePattern(params, 'var')
+
+        if self.context.strict and id.type is Syntax.Identifier:
+            if self.scanner.isRestrictedWord(id.name):
+                self.tolerateError(Messages.StrictVarName)
+
+        init = None
+        if self.match('='):
+            self.nextToken()
+            init = self.isolateCoverGrammar(self.parseAssignmentExpression)
+        elif id.type is not Syntax.Identifier and not options.inFor:
+            self.expect('=')
+
+        return self.finalize(node, Node.VariableDeclarator(id, init))
+
+    def parseVariableDeclarationList(self, options):
+        opt = Params(inFor=options.inFor)
+
+        lst = []
+        lst.append(self.parseVariableDeclaration(opt))
+        while self.match(','):
+            self.nextToken()
+            lst.append(self.parseVariableDeclaration(opt))
+
+        return lst
+
+    def parseVariableStatement(self):
+        node = self.createNode()
+        self.expectKeyword('var')
+        declarations = self.parseVariableDeclarationList(Params(inFor=False))
+        self.consumeSemicolon()
+
+        return self.finalize(node, Node.VariableDeclaration(declarations, 'var'))
+
+    # https://tc39.github.io/ecma262/#sec-empty-statement
+
+    def parseEmptyStatement(self):
+        node = self.createNode()
+        self.expect(';')
+        return self.finalize(node, Node.EmptyStatement())
+
+    # https://tc39.github.io/ecma262/#sec-expression-statement
+
+    def parseExpressionStatement(self):
+        node = self.createNode()
+        expr = self.parseExpression()
+        self.consumeSemicolon()
+        return self.finalize(node, Node.ExpressionStatement(expr))
+
+    # https://tc39.github.io/ecma262/#sec-if-statement
+
+    def parseIfClause(self):
+        if self.context.strict and self.matchKeyword('function'):
+            self.tolerateError(Messages.StrictFunction)
+        return self.parseStatement()
+
+    def parseIfStatement(self):
+        node = self.createNode()
+        alternate = None
+
+        self.expectKeyword('if')
+        self.expect('(')
+        test = self.parseExpression()
+
+        if not self.match(')') and self.config.tolerant:
+            self.tolerateUnexpectedToken(self.nextToken())
+            consequent = self.finalize(self.createNode(), Node.EmptyStatement())
+        else:
+            self.expect(')')
+            consequent = self.parseIfClause()
+            if self.matchKeyword('else'):
+                self.nextToken()
+                alternate = self.parseIfClause()
+
+        return self.finalize(node, Node.IfStatement(test, consequent, alternate))
+
+    # https://tc39.github.io/ecma262/#sec-do-while-statement
+
+    def parseDoWhileStatement(self):
+        node = self.createNode()
+        self.expectKeyword('do')
+
+        previousInIteration = self.context.inIteration
+        self.context.inIteration = True
+        body = self.parseStatement()
+        self.context.inIteration = previousInIteration
+
+        self.expectKeyword('while')
+        self.expect('(')
+        test = self.parseExpression()
+
+        if not self.match(')') and self.config.tolerant:
+            self.tolerateUnexpectedToken(self.nextToken())
+        else:
+            self.expect(')')
+            if self.match(';'):
+                self.nextToken()
+
+        return self.finalize(node, Node.DoWhileStatement(body, test))
+
+    # https://tc39.github.io/ecma262/#sec-while-statement
+
+    def parseWhileStatement(self):
+        node = self.createNode()
+
+        self.expectKeyword('while')
+        self.expect('(')
+        test = self.parseExpression()
+
+        if not self.match(')') and self.config.tolerant:
+            self.tolerateUnexpectedToken(self.nextToken())
+            body = self.finalize(self.createNode(), Node.EmptyStatement())
+        else:
+            self.expect(')')
+
+            previousInIteration = self.context.inIteration
+            self.context.inIteration = True
+            body = self.parseStatement()
+            self.context.inIteration = previousInIteration
+
+        return self.finalize(node, Node.WhileStatement(test, body))
+
+    # https://tc39.github.io/ecma262/#sec-for-statement
+    # https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements
+
+    def parseForStatement(self):
+        init = None
+        test = None
+        update = None
+        forIn = True
+        left = None
+        right = None
+
+        node = self.createNode()
+        self.expectKeyword('for')
+        self.expect('(')
+
+        if self.match(';'):
+            self.nextToken()
+        else:
+            if self.matchKeyword('var'):
+                init = self.createNode()
+                self.nextToken()
+
+                previousAllowIn = self.context.allowIn
+                self.context.allowIn = False
+                declarations = self.parseVariableDeclarationList(Params(inFor=True))
+                self.context.allowIn = previousAllowIn
+
+                if len(declarations) == 1 and self.matchKeyword('in'):
+                    decl = declarations[0]
+                    if decl.init and (decl.id.type is Syntax.ArrayPattern or decl.id.type is Syntax.ObjectPattern or self.context.strict):
+                        self.tolerateError(Messages.ForInOfLoopInitializer, 'for-in')
+                    init = self.finalize(init, Node.VariableDeclaration(declarations, 'var'))
+                    self.nextToken()
+                    left = init
+                    right = self.parseExpression()
+                    init = None
+                elif len(declarations) == 1 and declarations[0].init is None and self.matchContextualKeyword('of'):
+                    init = self.finalize(init, Node.VariableDeclaration(declarations, 'var'))
+                    self.nextToken()
+                    left = init
+                    right = self.parseAssignmentExpression()
+                    init = None
+                    forIn = False
+                else:
+                    init = self.finalize(init, Node.VariableDeclaration(declarations, 'var'))
+                    self.expect(';')
+            elif self.matchKeyword('const', 'let'):
+                init = self.createNode()
+                kind = self.nextToken().value
+
+                if not self.context.strict and self.lookahead.value == 'in':
+                    init = self.finalize(init, Node.Identifier(kind))
+                    self.nextToken()
+                    left = init
+                    right = self.parseExpression()
+                    init = None
+                else:
+                    previousAllowIn = self.context.allowIn
+                    self.context.allowIn = False
+                    declarations = self.parseBindingList(kind, Params(inFor=True))
+                    self.context.allowIn = previousAllowIn
+
+                    if len(declarations) == 1 and declarations[0].init is None and self.matchKeyword('in'):
+                        init = self.finalize(init, Node.VariableDeclaration(declarations, kind))
+                        self.nextToken()
+                        left = init
+                        right = self.parseExpression()
+                        init = None
+                    elif len(declarations) == 1 and declarations[0].init is None and self.matchContextualKeyword('of'):
+                        init = self.finalize(init, Node.VariableDeclaration(declarations, kind))
+                        self.nextToken()
+                        left = init
+                        right = self.parseAssignmentExpression()
+                        init = None
+                        forIn = False
+                    else:
+                        self.consumeSemicolon()
+                        init = self.finalize(init, Node.VariableDeclaration(declarations, kind))
+            else:
+                initStartToken = self.lookahead
+                previousAllowIn = self.context.allowIn
+                self.context.allowIn = False
+                init = self.inheritCoverGrammar(self.parseAssignmentExpression)
+                self.context.allowIn = previousAllowIn
+
+                if self.matchKeyword('in'):
+                    if not self.context.isAssignmentTarget or init.type is Syntax.AssignmentExpression:
+                        self.tolerateError(Messages.InvalidLHSInForIn)
+
+                    self.nextToken()
+                    self.reinterpretExpressionAsPattern(init)
+                    left = init
+                    right = self.parseExpression()
+                    init = None
+                elif self.matchContextualKeyword('of'):
+                    if not self.context.isAssignmentTarget or init.type is Syntax.AssignmentExpression:
+                        self.tolerateError(Messages.InvalidLHSInForLoop)
+
+                    self.nextToken()
+                    self.reinterpretExpressionAsPattern(init)
+                    left = init
+                    right = self.parseAssignmentExpression()
+                    init = None
+                    forIn = False
+                else:
+                    if self.match(','):
+                        initSeq = [init]
+                        while self.match(','):
+                            self.nextToken()
+                            initSeq.append(self.isolateCoverGrammar(self.parseAssignmentExpression))
+                        init = self.finalize(self.startNode(initStartToken), Node.SequenceExpression(initSeq))
+                    self.expect(';')
+
+        if left is None:
+            if not self.match(';'):
+                test = self.parseExpression()
+            self.expect(';')
+            if not self.match(')'):
+                update = self.parseExpression()
+
+        if not self.match(')') and self.config.tolerant:
+            self.tolerateUnexpectedToken(self.nextToken())
+            body = self.finalize(self.createNode(), Node.EmptyStatement())
+        else:
+            self.expect(')')
+
+            previousInIteration = self.context.inIteration
+            self.context.inIteration = True
+            body = self.isolateCoverGrammar(self.parseStatement)
+            self.context.inIteration = previousInIteration
+
+        if left is None:
+            return self.finalize(node, Node.ForStatement(init, test, update, body))
+
+        if forIn:
+            return self.finalize(node, Node.ForInStatement(left, right, body))
+
+        return self.finalize(node, Node.ForOfStatement(left, right, body))
+
+    # https://tc39.github.io/ecma262/#sec-continue-statement
+
+    def parseContinueStatement(self):
+        node = self.createNode()
+        self.expectKeyword('continue')
+
+        label = None
+        if self.lookahead.type is Token.Identifier and not self.hasLineTerminator:
+            id = self.parseVariableIdentifier()
+            label = id
+
+            key = '$' + id.name
+            if key not in self.context.labelSet:
+                self.throwError(Messages.UnknownLabel, id.name)
+
+        self.consumeSemicolon()
+        if label is None and not self.context.inIteration:
+            self.throwError(Messages.IllegalContinue)
+
+        return self.finalize(node, Node.ContinueStatement(label))
+
+    # https://tc39.github.io/ecma262/#sec-break-statement
+
+    def parseBreakStatement(self):
+        node = self.createNode()
+        self.expectKeyword('break')
+
+        label = None
+        if self.lookahead.type is Token.Identifier and not self.hasLineTerminator:
+            id = self.parseVariableIdentifier()
+
+            key = '$' + id.name
+            if key not in self.context.labelSet:
+                self.throwError(Messages.UnknownLabel, id.name)
+            label = id
+
+        self.consumeSemicolon()
+        if label is None and not self.context.inIteration and not self.context.inSwitch:
+            self.throwError(Messages.IllegalBreak)
+
+        return self.finalize(node, Node.BreakStatement(label))
+
+    # https://tc39.github.io/ecma262/#sec-return-statement
+
+    def parseReturnStatement(self):
+        if not self.context.inFunctionBody:
+            self.tolerateError(Messages.IllegalReturn)
+
+        node = self.createNode()
+        self.expectKeyword('return')
+
+        hasArgument = (
+            (
+                not self.match(';') and not self.match('}') and
+                not self.hasLineTerminator and self.lookahead.type is not Token.EOF
+            ) or
+            self.lookahead.type is Token.StringLiteral or
+            self.lookahead.type is Token.Template
+        )
+        argument = self.parseExpression() if hasArgument else None
+        self.consumeSemicolon()
+
+        return self.finalize(node, Node.ReturnStatement(argument))
+
+    # https://tc39.github.io/ecma262/#sec-with-statement
+
+    def parseWithStatement(self):
+        if self.context.strict:
+            self.tolerateError(Messages.StrictModeWith)
+
+        node = self.createNode()
+
+        self.expectKeyword('with')
+        self.expect('(')
+        object = self.parseExpression()
+
+        if not self.match(')') and self.config.tolerant:
+            self.tolerateUnexpectedToken(self.nextToken())
+            body = self.finalize(self.createNode(), Node.EmptyStatement())
+        else:
+            self.expect(')')
+            body = self.parseStatement()
+
+        return self.finalize(node, Node.WithStatement(object, body))
+
+    # https://tc39.github.io/ecma262/#sec-switch-statement
+
+    def parseSwitchCase(self):
+        node = self.createNode()
+
+        if self.matchKeyword('default'):
+            self.nextToken()
+            test = None
+        else:
+            self.expectKeyword('case')
+            test = self.parseExpression()
+        self.expect(':')
+
+        consequent = []
+        while True:
+            if self.match('}') or self.matchKeyword('default', 'case'):
+                break
+            consequent.append(self.parseStatementListItem())
+
+        return self.finalize(node, Node.SwitchCase(test, consequent))
+
+    def parseSwitchStatement(self):
+        node = self.createNode()
+        self.expectKeyword('switch')
+
+        self.expect('(')
+        discriminant = self.parseExpression()
+        self.expect(')')
+
+        previousInSwitch = self.context.inSwitch
+        self.context.inSwitch = True
+
+        cases = []
+        defaultFound = False
+        self.expect('{')
+        while True:
+            if self.match('}'):
+                break
+            clause = self.parseSwitchCase()
+            if clause.test is None:
+                if defaultFound:
+                    self.throwError(Messages.MultipleDefaultsInSwitch)
+                defaultFound = True
+            cases.append(clause)
+        self.expect('}')
+
+        self.context.inSwitch = previousInSwitch
+
+        return self.finalize(node, Node.SwitchStatement(discriminant, cases))
+
+    # https://tc39.github.io/ecma262/#sec-labelled-statements
+
+    def parseLabelledStatement(self):
+        node = self.createNode()
+        expr = self.parseExpression()
+
+        if expr.type is Syntax.Identifier and self.match(':'):
+            self.nextToken()
+
+            id = expr
+            key = '$' + id.name
+            if key in self.context.labelSet:
+                self.throwError(Messages.Redeclaration, 'Label', id.name)
+
+            self.context.labelSet[key] = True
+            if self.matchKeyword('class'):
+                self.tolerateUnexpectedToken(self.lookahead)
+                body = self.parseClassDeclaration()
+            elif self.matchKeyword('function'):
+                token = self.lookahead
+                declaration = self.parseFunctionDeclaration()
+                if self.context.strict:
+                    self.tolerateUnexpectedToken(token, Messages.StrictFunction)
+                elif declaration.generator:
+                    self.tolerateUnexpectedToken(token, Messages.GeneratorInLegacyContext)
+                body = declaration
+            else:
+                body = self.parseStatement()
+            del self.context.labelSet[key]
+
+            statement = Node.LabeledStatement(id, body)
+        else:
+            self.consumeSemicolon()
+            statement = Node.ExpressionStatement(expr)
+
+        return self.finalize(node, statement)
+
+    # https://tc39.github.io/ecma262/#sec-throw-statement
+
+    def parseThrowStatement(self):
+        node = self.createNode()
+        self.expectKeyword('throw')
+
+        if self.hasLineTerminator:
+            self.throwError(Messages.NewlineAfterThrow)
+
+        argument = self.parseExpression()
+        self.consumeSemicolon()
+
+        return self.finalize(node, Node.ThrowStatement(argument))
+
+    # https://tc39.github.io/ecma262/#sec-try-statement
+
+    def parseCatchClause(self):
+        node = self.createNode()
+
+        self.expectKeyword('catch')
+
+        self.expect('(')
+        if self.match(')'):
+            self.throwUnexpectedToken(self.lookahead)
+
+        params = []
+        param = self.parsePattern(params)
+        paramMap = {}
+        for p in params:
+            key = '$' + p.value
+            if key in paramMap:
+                self.tolerateError(Messages.DuplicateBinding, p.value)
+            paramMap[key] = True
+
+        if self.context.strict and param.type is Syntax.Identifier:
+            if self.scanner.isRestrictedWord(param.name):
+                self.tolerateError(Messages.StrictCatchVariable)
+
+        self.expect(')')
+        body = self.parseBlock()
+
+        return self.finalize(node, Node.CatchClause(param, body))
+
+    def parseFinallyClause(self):
+        self.expectKeyword('finally')
+        return self.parseBlock()
+
+    def parseTryStatement(self):
+        node = self.createNode()
+        self.expectKeyword('try')
+
+        block = self.parseBlock()
+        handler = self.parseCatchClause() if self.matchKeyword('catch') else None
+        finalizer = self.parseFinallyClause() if self.matchKeyword('finally') else None
+
+        if not handler and not finalizer:
+            self.throwError(Messages.NoCatchOrFinally)
+
+        return self.finalize(node, Node.TryStatement(block, handler, finalizer))
+
+    # https://tc39.github.io/ecma262/#sec-debugger-statement
+
+    def parseDebuggerStatement(self):
+        node = self.createNode()
+        self.expectKeyword('debugger')
+        self.consumeSemicolon()
+        return self.finalize(node, Node.DebuggerStatement())
+
+    # https://tc39.github.io/ecma262/#sec-ecmascript-language-statements-and-declarations
+
+    def parseStatement(self):
+        typ = self.lookahead.type
+        if typ in (
+            Token.BooleanLiteral,
+            Token.NullLiteral,
+            Token.NumericLiteral,
+            Token.StringLiteral,
+            Token.Template,
+            Token.RegularExpression,
+        ):
+            statement = self.parseExpressionStatement()
+
+        elif typ is Token.Punctuator:
+            value = self.lookahead.value
+            if value == '{':
+                statement = self.parseBlock()
+            elif value == '(':
+                statement = self.parseExpressionStatement()
+            elif value == ';':
+                statement = self.parseEmptyStatement()
+            else:
+                statement = self.parseExpressionStatement()
+
+        elif typ is Token.Identifier:
+            statement = self.parseFunctionDeclaration() if self.matchAsyncFunction() else self.parseLabelledStatement()
+
+        elif typ is Token.Keyword:
+            value = self.lookahead.value
+            if value == 'break':
+                statement = self.parseBreakStatement()
+            elif value == 'continue':
+                statement = self.parseContinueStatement()
+            elif value == 'debugger':
+                statement = self.parseDebuggerStatement()
+            elif value == 'do':
+                statement = self.parseDoWhileStatement()
+            elif value == 'for':
+                statement = self.parseForStatement()
+            elif value == 'function':
+                statement = self.parseFunctionDeclaration()
+            elif value == 'if':
+                statement = self.parseIfStatement()
+            elif value == 'return':
+                statement = self.parseReturnStatement()
+            elif value == 'switch':
+                statement = self.parseSwitchStatement()
+            elif value == 'throw':
+                statement = self.parseThrowStatement()
+            elif value == 'try':
+                statement = self.parseTryStatement()
+            elif value == 'var':
+                statement = self.parseVariableStatement()
+            elif value == 'while':
+                statement = self.parseWhileStatement()
+            elif value == 'with':
+                statement = self.parseWithStatement()
+            else:
+                statement = self.parseExpressionStatement()
+
+        else:
+            statement = self.throwUnexpectedToken(self.lookahead)
+
+        return statement
+
+    # https://tc39.github.io/ecma262/#sec-function-definitions
+
+    def parseFunctionSourceElements(self):
+        node = self.createNode()
+
+        self.expect('{')
+        body = self.parseDirectivePrologues()
+
+        previousLabelSet = self.context.labelSet
+        previousInIteration = self.context.inIteration
+        previousInSwitch = self.context.inSwitch
+        previousInFunctionBody = self.context.inFunctionBody
+
+        self.context.labelSet = {}
+        self.context.inIteration = False
+        self.context.inSwitch = False
+        self.context.inFunctionBody = True
+
+        while self.lookahead.type is not Token.EOF:
+            if self.match('}'):
+                break
+            body.append(self.parseStatementListItem())
+
+        self.expect('}')
+
+        self.context.labelSet = previousLabelSet
+        self.context.inIteration = previousInIteration
+        self.context.inSwitch = previousInSwitch
+        self.context.inFunctionBody = previousInFunctionBody
+
+        return self.finalize(node, Node.BlockStatement(body))
+
+    def validateParam(self, options, param, name):
+        key = '$' + name
+        if self.context.strict:
+            if self.scanner.isRestrictedWord(name):
+                options.stricted = param
+                options.message = Messages.StrictParamName
+            if key in options.paramSet:
+                options.stricted = param
+                options.message = Messages.StrictParamDupe
+        elif not options.firstRestricted:
+            if self.scanner.isRestrictedWord(name):
+                options.firstRestricted = param
+                options.message = Messages.StrictParamName
+            elif self.scanner.isStrictModeReservedWord(name):
+                options.firstRestricted = param
+                options.message = Messages.StrictReservedWord
+            elif key in options.paramSet:
+                options.stricted = param
+                options.message = Messages.StrictParamDupe
+
+        options.paramSet[key] = True
+
+    def parseRestElement(self, params):
+        node = self.createNode()
+
+        self.expect('...')
+        arg = self.parsePattern(params)
+        if self.match('='):
+            self.throwError(Messages.DefaultRestParameter)
+        if not self.match(')'):
+            self.throwError(Messages.ParameterAfterRestParameter)
+
+        return self.finalize(node, Node.RestElement(arg))
+
+    def parseFormalParameter(self, options):
+        params = []
+        param = self.parseRestElement(params) if self.match('...') else self.parsePatternWithDefault(params)
+        for p in params:
+            self.validateParam(options, p, p.value)
+        options.simple = options.simple and isinstance(param, Node.Identifier)
+        options.params.append(param)
+
+    def parseFormalParameters(self, firstRestricted=None):
+        options = Params(
+            simple=True,
+            params=[],
+            firstRestricted=firstRestricted
+        )
+
+        self.expect('(')
+        if not self.match(')'):
+            options.paramSet = {}
+            while self.lookahead.type is not Token.EOF:
+                self.parseFormalParameter(options)
+                if self.match(')'):
+                    break
+                self.expect(',')
+                if self.match(')'):
+                    break
+        self.expect(')')
+
+        return Params(
+            simple=options.simple,
+            params=options.params,
+            stricted=options.stricted,
+            firstRestricted=options.firstRestricted,
+            message=options.message
+        )
+
+    def matchAsyncFunction(self):
+        match = self.matchContextualKeyword('async')
+        if match:
+            state = self.scanner.saveState()
+            self.scanner.scanComments()
+            next = self.scanner.lex()
+            self.scanner.restoreState(state)
+
+            match = (state.lineNumber == next.lineNumber) and (next.type is Token.Keyword) and (next.value == 'function')
+
+        return match
+
+    def parseFunctionDeclaration(self, identifierIsOptional=False):
+        node = self.createNode()
+
+        isAsync = self.matchContextualKeyword('async')
+        if isAsync:
+            self.nextToken()
+
+        self.expectKeyword('function')
+
+        isGenerator = False if isAsync else self.match('*')
+        if isGenerator:
+            self.nextToken()
+
+        id = None
+        firstRestricted = None
+
+        if not identifierIsOptional or not self.match('('):
+            token = self.lookahead
+            id = self.parseVariableIdentifier()
+            if self.context.strict:
+                if self.scanner.isRestrictedWord(token.value):
+                    self.tolerateUnexpectedToken(token, Messages.StrictFunctionName)
+            else:
+                if self.scanner.isRestrictedWord(token.value):
+                    firstRestricted = token
+                    message = Messages.StrictFunctionName
+                elif self.scanner.isStrictModeReservedWord(token.value):
+                    firstRestricted = token
+                    message = Messages.StrictReservedWord
+
+        previousAllowAwait = self.context.allowAwait
+        previousAllowYield = self.context.allowYield
+        self.context.allowAwait = isAsync
+        self.context.allowYield = not isGenerator
+
+        formalParameters = self.parseFormalParameters(firstRestricted)
+        params = formalParameters.params
+        stricted = formalParameters.stricted
+        firstRestricted = formalParameters.firstRestricted
+        if formalParameters.message:
+            message = formalParameters.message
+
+        previousStrict = self.context.strict
+        previousAllowStrictDirective = self.context.allowStrictDirective
+        self.context.allowStrictDirective = formalParameters.simple
+        body = self.parseFunctionSourceElements()
+        if self.context.strict and firstRestricted:
+            self.throwUnexpectedToken(firstRestricted, message)
+        if self.context.strict and stricted:
+            self.tolerateUnexpectedToken(stricted, message)
+
+        self.context.strict = previousStrict
+        self.context.allowStrictDirective = previousAllowStrictDirective
+        self.context.allowAwait = previousAllowAwait
+        self.context.allowYield = previousAllowYield
+
+        if isAsync:
+            return self.finalize(node, Node.AsyncFunctionDeclaration(id, params, body))
+
+        return self.finalize(node, Node.FunctionDeclaration(id, params, body, isGenerator))
+
+    def parseFunctionExpression(self):
+        node = self.createNode()
+
+        isAsync = self.matchContextualKeyword('async')
+        if isAsync:
+            self.nextToken()
+
+        self.expectKeyword('function')
+
+        isGenerator = False if isAsync else self.match('*')
+        if isGenerator:
+            self.nextToken()
+
+        id = None
+        firstRestricted = None
+
+        previousAllowAwait = self.context.allowAwait
+        previousAllowYield = self.context.allowYield
+        self.context.allowAwait = isAsync
+        self.context.allowYield = not isGenerator
+
+        if not self.match('('):
+            token = self.lookahead
+            id = self.parseIdentifierName() if not self.context.strict and not isGenerator and self.matchKeyword('yield') else self.parseVariableIdentifier()
+            if self.context.strict:
+                if self.scanner.isRestrictedWord(token.value):
+                    self.tolerateUnexpectedToken(token, Messages.StrictFunctionName)
+            else:
+                if self.scanner.isRestrictedWord(token.value):
+                    firstRestricted = token
+                    message = Messages.StrictFunctionName
+                elif self.scanner.isStrictModeReservedWord(token.value):
+                    firstRestricted = token
+                    message = Messages.StrictReservedWord
+
+        formalParameters = self.parseFormalParameters(firstRestricted)
+        params = formalParameters.params
+        stricted = formalParameters.stricted
+        firstRestricted = formalParameters.firstRestricted
+        if formalParameters.message:
+            message = formalParameters.message
+
+        previousStrict = self.context.strict
+        previousAllowStrictDirective = self.context.allowStrictDirective
+        self.context.allowStrictDirective = formalParameters.simple
+        body = self.parseFunctionSourceElements()
+        if self.context.strict and firstRestricted:
+            self.throwUnexpectedToken(firstRestricted, message)
+        if self.context.strict and stricted:
+            self.tolerateUnexpectedToken(stricted, message)
+        self.context.strict = previousStrict
+        self.context.allowStrictDirective = previousAllowStrictDirective
+        self.context.allowAwait = previousAllowAwait
+        self.context.allowYield = previousAllowYield
+
+        if isAsync:
+            return self.finalize(node, Node.AsyncFunctionExpression(id, params, body))
+
+        return self.finalize(node, Node.FunctionExpression(id, params, body, isGenerator))
+
+    # https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive
+
+    def parseDirective(self):
+        token = self.lookahead
+
+        node = self.createNode()
+        expr = self.parseExpression()
+        directive = self.getTokenRaw(token)[1:-1] if expr.type is Syntax.Literal else None
+        self.consumeSemicolon()
+
+        return self.finalize(node, Node.Directive(expr, directive) if directive else Node.ExpressionStatement(expr))
+
+    def parseDirectivePrologues(self):
+        firstRestricted = None
+
+        body = []
+        while True:
+            token = self.lookahead
+            if token.type is not Token.StringLiteral:
+                break
+
+            statement = self.parseDirective()
+            body.append(statement)
+            directive = statement.directive
+            if not isinstance(directive, basestring):
+                break
+
+            if directive == 'use strict':
+                self.context.strict = True
+                if firstRestricted:
+                    self.tolerateUnexpectedToken(firstRestricted, Messages.StrictOctalLiteral)
+                if not self.context.allowStrictDirective:
+                    self.tolerateUnexpectedToken(token, Messages.IllegalLanguageModeDirective)
+            else:
+                if not firstRestricted and token.octal:
+                    firstRestricted = token
+
+        return body
+
+    # https://tc39.github.io/ecma262/#sec-method-definitions
+
+    def qualifiedPropertyName(self, token):
+        typ = token.type
+        if typ in (
+            Token.Identifier,
+            Token.StringLiteral,
+            Token.BooleanLiteral,
+            Token.NullLiteral,
+            Token.NumericLiteral,
+            Token.Keyword,
+        ):
+            return True
+        elif typ is Token.Punctuator:
+            return token.value == '['
+        return False
+
+    def parseGetterMethod(self):
+        node = self.createNode()
+
+        isGenerator = False
+        previousAllowYield = self.context.allowYield
+        self.context.allowYield = not isGenerator
+        formalParameters = self.parseFormalParameters()
+        if len(formalParameters.params) > 0:
+            self.tolerateError(Messages.BadGetterArity)
+        method = self.parsePropertyMethod(formalParameters)
+        self.context.allowYield = previousAllowYield
+
+        return self.finalize(node, Node.FunctionExpression(None, formalParameters.params, method, isGenerator))
+
+    def parseSetterMethod(self):
+        node = self.createNode()
+
+        isGenerator = False
+        previousAllowYield = self.context.allowYield
+        self.context.allowYield = not isGenerator
+        formalParameters = self.parseFormalParameters()
+        if len(formalParameters.params) != 1:
+            self.tolerateError(Messages.BadSetterArity)
+        elif isinstance(formalParameters.params[0], Node.RestElement):
+            self.tolerateError(Messages.BadSetterRestParameter)
+        method = self.parsePropertyMethod(formalParameters)
+        self.context.allowYield = previousAllowYield
+
+        return self.finalize(node, Node.FunctionExpression(None, formalParameters.params, method, isGenerator))
+
+    def parseGeneratorMethod(self):
+        node = self.createNode()
+
+        isGenerator = True
+        previousAllowYield = self.context.allowYield
+
+        self.context.allowYield = True
+        params = self.parseFormalParameters()
+        self.context.allowYield = False
+        method = self.parsePropertyMethod(params)
+        self.context.allowYield = previousAllowYield
+
+        return self.finalize(node, Node.FunctionExpression(None, params.params, method, isGenerator))
+
+    # https://tc39.github.io/ecma262/#sec-generator-function-definitions
+
+    def isStartOfExpression(self):
+        start = True
+
+        value = self.lookahead.value
+        typ = self.lookahead.type
+        if typ is Token.Punctuator:
+            start = value in ('[', '(', '{', '+', '-', '!', '~', '++', '--', '/', '/=')  # regular expression literal )
+
+        elif typ is Token.Keyword:
+            start = value in ('class', 'delete', 'function', 'let', 'new', 'super', 'this', 'typeof', 'void', 'yield')
+
+        return start
+
+    def parseYieldExpression(self):
+        node = self.createNode()
+        self.expectKeyword('yield')
+
+        argument = None
+        delegate = False
+        if not self.hasLineTerminator:
+            previousAllowYield = self.context.allowYield
+            self.context.allowYield = False
+            delegate = self.match('*')
+            if delegate:
+                self.nextToken()
+                argument = self.parseAssignmentExpression()
+            elif self.isStartOfExpression():
+                argument = self.parseAssignmentExpression()
+            self.context.allowYield = previousAllowYield
+
+        return self.finalize(node, Node.YieldExpression(argument, delegate))
+
+    # https://tc39.github.io/ecma262/#sec-class-definitions
+
+    def parseClassElement(self, hasConstructor):
+        token = self.lookahead
+        node = self.createNode()
+
+        kind = ''
+        key = None
+        value = None
+        computed = False
+        isStatic = False
+        isAsync = False
+
+        if self.match('*'):
+            self.nextToken()
+
+        else:
+            computed = self.match('[')
+            key = self.parseObjectPropertyKey()
+            id = key
+            if id.name == 'static' and (self.qualifiedPropertyName(self.lookahead) or self.match('*')):
+                token = self.lookahead
+                isStatic = True
+                computed = self.match('[')
+                if self.match('*'):
+                    self.nextToken()
+                else:
+                    key = self.parseObjectPropertyKey()
+            if token.type is Token.Identifier and not self.hasLineTerminator and token.value == 'async':
+                punctuator = self.lookahead.value
+                if punctuator != ':' and punctuator != '(' and punctuator != '*':
+                    isAsync = True
+                    token = self.lookahead
+                    key = self.parseObjectPropertyKey()
+                    if token.type is Token.Identifier and token.value == 'constructor':
+                        self.tolerateUnexpectedToken(token, Messages.ConstructorIsAsync)
+
+        lookaheadPropertyKey = self.qualifiedPropertyName(self.lookahead)
+        if token.type is Token.Identifier:
+            if token.value == 'get' and lookaheadPropertyKey:
+                kind = 'get'
+                computed = self.match('[')
+                key = self.parseObjectPropertyKey()
+                self.context.allowYield = False
+                value = self.parseGetterMethod()
+            elif token.value == 'set' and lookaheadPropertyKey:
+                kind = 'set'
+                computed = self.match('[')
+                key = self.parseObjectPropertyKey()
+                value = self.parseSetterMethod()
+            elif self.config.classProperties and not self.match('('):
+                kind = 'init'
+                id = self.finalize(node, Node.Identifier(token.value))
+                if self.match('='):
+                    self.nextToken()
+                    value = self.parseAssignmentExpression()
+
+        elif token.type is Token.Punctuator and token.value == '*' and lookaheadPropertyKey:
+            kind = 'method'
+            computed = self.match('[')
+            key = self.parseObjectPropertyKey()
+            value = self.parseGeneratorMethod()
+
+        if not kind and key and self.match('('):
+            kind = 'method'
+            value = self.parsePropertyMethodAsyncFunction() if isAsync else self.parsePropertyMethodFunction()
+
+        if not kind:
+            self.throwUnexpectedToken(self.lookahead)
+
+        if not computed:
+            if isStatic and self.isPropertyKey(key, 'prototype'):
+                self.throwUnexpectedToken(token, Messages.StaticPrototype)
+            if not isStatic and self.isPropertyKey(key, 'constructor'):
+                if kind != 'method' or (value and value.generator):
+                    self.throwUnexpectedToken(token, Messages.ConstructorSpecialMethod)
+                if hasConstructor.value:
+                    self.throwUnexpectedToken(token, Messages.DuplicateConstructor)
+                else:
+                    hasConstructor.value = True
+                kind = 'constructor'
+
+        if kind in ('constructor', 'method', 'get', 'set'):
+            return self.finalize(node, Node.MethodDefinition(key, computed, value, kind, isStatic))
+
+        else:
+            return self.finalize(node, Node.FieldDefinition(key, computed, value, kind, isStatic))
+
+    def parseClassElementList(self):
+        body = []
+        hasConstructor = Value(False)
+
+        self.expect('{')
+        while not self.match('}'):
+            if self.match(';'):
+                self.nextToken()
+            else:
+                body.append(self.parseClassElement(hasConstructor))
+        self.expect('}')
+
+        return body
+
+    def parseClassBody(self):
+        node = self.createNode()
+        elementList = self.parseClassElementList()
+
+        return self.finalize(node, Node.ClassBody(elementList))
+
+    def parseClassDeclaration(self, identifierIsOptional=False):
+        node = self.createNode()
+
+        previousStrict = self.context.strict
+        self.context.strict = True
+        self.expectKeyword('class')
+
+        id = None if identifierIsOptional and self.lookahead.type is not Token.Identifier else self.parseVariableIdentifier()
+        superClass = None
+        if self.matchKeyword('extends'):
+            self.nextToken()
+            superClass = self.isolateCoverGrammar(self.parseLeftHandSideExpressionAllowCall)
+        classBody = self.parseClassBody()
+        self.context.strict = previousStrict
+
+        return self.finalize(node, Node.ClassDeclaration(id, superClass, classBody))
+
+    def parseClassExpression(self):
+        node = self.createNode()
+
+        previousStrict = self.context.strict
+        self.context.strict = True
+        self.expectKeyword('class')
+        id = self.parseVariableIdentifier() if self.lookahead.type is Token.Identifier else None
+        superClass = None
+        if self.matchKeyword('extends'):
+            self.nextToken()
+            superClass = self.isolateCoverGrammar(self.parseLeftHandSideExpressionAllowCall)
+        classBody = self.parseClassBody()
+        self.context.strict = previousStrict
+
+        return self.finalize(node, Node.ClassExpression(id, superClass, classBody))
+
+    # https://tc39.github.io/ecma262/#sec-scripts
+    # https://tc39.github.io/ecma262/#sec-modules
+
+    def parseModule(self):
+        self.context.strict = True
+        self.context.isModule = True
+        self.scanner.isModule = True
+        node = self.createNode()
+        body = self.parseDirectivePrologues()
+        while self.lookahead.type is not Token.EOF:
+            body.append(self.parseStatementListItem())
+        return self.finalize(node, Node.Module(body))
+
+    def parseScript(self):
+        node = self.createNode()
+        body = self.parseDirectivePrologues()
+        while self.lookahead.type is not Token.EOF:
+            body.append(self.parseStatementListItem())
+        return self.finalize(node, Node.Script(body))
+
+    # https://tc39.github.io/ecma262/#sec-imports
+
+    def parseModuleSpecifier(self):
+        node = self.createNode()
+
+        if self.lookahead.type is not Token.StringLiteral:
+            self.throwError(Messages.InvalidModuleSpecifier)
+
+        token = self.nextToken()
+        raw = self.getTokenRaw(token)
+        return self.finalize(node, Node.Literal(token.value, raw))
+
+    # import {<foo as bar>} ...
+    def parseImportSpecifier(self):
+        node = self.createNode()
+
+        if self.lookahead.type is Token.Identifier:
+            imported = self.parseVariableIdentifier()
+            local = imported
+            if self.matchContextualKeyword('as'):
+                self.nextToken()
+                local = self.parseVariableIdentifier()
+        else:
+            imported = self.parseIdentifierName()
+            local = imported
+            if self.matchContextualKeyword('as'):
+                self.nextToken()
+                local = self.parseVariableIdentifier()
+            else:
+                self.throwUnexpectedToken(self.nextToken())
+
+        return self.finalize(node, Node.ImportSpecifier(local, imported))
+
+    # {foo, bar as bas
+    def parseNamedImports(self):
+        self.expect('{')
+        specifiers = []
+        while not self.match('}'):
+            specifiers.append(self.parseImportSpecifier())
+            if not self.match('}'):
+                self.expect(',')
+        self.expect('}')
+
+        return specifiers
+
+    # import <foo> ...
+    def parseImportDefaultSpecifier(self):
+        node = self.createNode()
+        local = self.parseIdentifierName()
+        return self.finalize(node, Node.ImportDefaultSpecifier(local))
+
+    # import <* as foo> ...
+    def parseImportNamespaceSpecifier(self):
+        node = self.createNode()
+
+        self.expect('*')
+        if not self.matchContextualKeyword('as'):
+            self.throwError(Messages.NoAsAfterImportNamespace)
+        self.nextToken()
+        local = self.parseIdentifierName()
+
+        return self.finalize(node, Node.ImportNamespaceSpecifier(local))
+
+    def parseImportDeclaration(self):
+        if self.context.inFunctionBody:
+            self.throwError(Messages.IllegalImportDeclaration)
+
+        node = self.createNode()
+        self.expectKeyword('import')
+
+        specifiers = []
+        if self.lookahead.type is Token.StringLiteral:
+            # import 'foo'
+            src = self.parseModuleSpecifier()
+        else:
+            if self.match('{'):
+                # import {bar
+                specifiers.extend(self.parseNamedImports())
+            elif self.match('*'):
+                # import * as foo
+                specifiers.append(self.parseImportNamespaceSpecifier())
+            elif self.isIdentifierName(self.lookahead) and not self.matchKeyword('default'):
+                # import foo
+                specifiers.append(self.parseImportDefaultSpecifier())
+                if self.match(','):
+                    self.nextToken()
+                    if self.match('*'):
+                        # import foo, * as foo
+                        specifiers.append(self.parseImportNamespaceSpecifier())
+                    elif self.match('{'):
+                        # import foo, {bar
+                        specifiers.extend(self.parseNamedImports())
+                    else:
+                        self.throwUnexpectedToken(self.lookahead)
+            else:
+                self.throwUnexpectedToken(self.nextToken())
+
+            if not self.matchContextualKeyword('from'):
+                message = Messages.UnexpectedToken if self.lookahead.value else Messages.MissingFromClause
+                self.throwError(message, self.lookahead.value)
+            self.nextToken()
+            src = self.parseModuleSpecifier()
+        self.consumeSemicolon()
+
+        return self.finalize(node, Node.ImportDeclaration(specifiers, src))
+
+    # https://tc39.github.io/ecma262/#sec-exports
+
+    def parseExportSpecifier(self):
+        node = self.createNode()
+
+        local = self.parseIdentifierName()
+        exported = local
+        if self.matchContextualKeyword('as'):
+            self.nextToken()
+            exported = self.parseIdentifierName()
+
+        return self.finalize(node, Node.ExportSpecifier(local, exported))
+
+    def parseExportDefaultSpecifier(self):
+        node = self.createNode()
+        local = self.parseIdentifierName()
+        return self.finalize(node, Node.ExportDefaultSpecifier(local))
+
+    def parseExportDeclaration(self):
+        if self.context.inFunctionBody:
+            self.throwError(Messages.IllegalExportDeclaration)
+
+        node = self.createNode()
+        self.expectKeyword('export')
+
+        if self.matchKeyword('default'):
+            # export default ...
+            self.nextToken()
+            if self.matchKeyword('function'):
+                # export default function foo (:
+                # export default function (:
+                declaration = self.parseFunctionDeclaration(True)
+                exportDeclaration = self.finalize(node, Node.ExportDefaultDeclaration(declaration))
+            elif self.matchKeyword('class'):
+                # export default class foo {
+                declaration = self.parseClassDeclaration(True)
+                exportDeclaration = self.finalize(node, Node.ExportDefaultDeclaration(declaration))
+            elif self.matchContextualKeyword('async'):
+                # export default async function f (:
+                # export default async function (:
+                # export default async x => x
+                declaration = self.parseFunctionDeclaration(True) if self.matchAsyncFunction() else self.parseAssignmentExpression()
+                exportDeclaration = self.finalize(node, Node.ExportDefaultDeclaration(declaration))
+            else:
+                if self.matchContextualKeyword('from'):
+                    self.throwError(Messages.UnexpectedToken, self.lookahead.value)
+                # export default {}
+                # export default []
+                # export default (1 + 2)
+                if self.match('{'):
+                    declaration = self.parseObjectInitializer()
+                elif self.match('['):
+                    declaration = self.parseArrayInitializer()
+                else:
+                    declaration = self.parseAssignmentExpression()
+                self.consumeSemicolon()
+                exportDeclaration = self.finalize(node, Node.ExportDefaultDeclaration(declaration))
+
+        elif self.match('*'):
+            # export * from 'foo'
+            self.nextToken()
+            if not self.matchContextualKeyword('from'):
+                message = Messages.UnexpectedToken if self.lookahead.value else Messages.MissingFromClause
+                self.throwError(message, self.lookahead.value)
+            self.nextToken()
+            src = self.parseModuleSpecifier()
+            self.consumeSemicolon()
+            exportDeclaration = self.finalize(node, Node.ExportAllDeclaration(src))
+
+        elif self.lookahead.type is Token.Keyword:
+            # export var f = 1
+            value = self.lookahead.value
+            if value in (
+                'let',
+                'const',
+            ):
+                declaration = self.parseLexicalDeclaration(Params(inFor=False))
+            elif value in (
+                'var',
+                'class',
+                'function',
+            ):
+                declaration = self.parseStatementListItem()
+            else:
+                self.throwUnexpectedToken(self.lookahead)
+            exportDeclaration = self.finalize(node, Node.ExportNamedDeclaration(declaration, [], None))
+
+        elif self.matchAsyncFunction():
+            declaration = self.parseFunctionDeclaration()
+            exportDeclaration = self.finalize(node, Node.ExportNamedDeclaration(declaration, [], None))
+
+        else:
+            specifiers = []
+            source = None
+            isExportFromIdentifier = False
+
+            expectSpecifiers = True
+            if self.lookahead.type is Token.Identifier:
+                specifiers.append(self.parseExportDefaultSpecifier())
+                if self.match(','):
+                    self.nextToken()
+                else:
+                    expectSpecifiers = False
+
+            if expectSpecifiers:
+                self.expect('{')
+                while not self.match('}'):
+                    isExportFromIdentifier = isExportFromIdentifier or self.matchKeyword('default')
+                    specifiers.append(self.parseExportSpecifier())
+                    if not self.match('}'):
+                        self.expect(',')
+                self.expect('}')
+
+            if self.matchContextualKeyword('from'):
+                # export {default} from 'foo'
+                # export {foo} from 'foo'
+                self.nextToken()
+                source = self.parseModuleSpecifier()
+                self.consumeSemicolon()
+            elif isExportFromIdentifier:
+                # export {default}; # missing fromClause
+                message = Messages.UnexpectedToken if self.lookahead.value else Messages.MissingFromClause
+                self.throwError(message, self.lookahead.value)
+            else:
+                # export {foo}
+                self.consumeSemicolon()
+            exportDeclaration = self.finalize(node, Node.ExportNamedDeclaration(None, specifiers, source))
+
+        return exportDeclaration
diff --git a/lib/esprima/scanner.py b/lib/esprima/scanner.py
new file mode 100644
index 00000000..53502a51
--- /dev/null
+++ b/lib/esprima/scanner.py
@@ -0,0 +1,1189 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+import re
+
+from .objects import Object
+from .compat import xrange, unicode, uchr, uord
+from .character import Character, HEX_CONV, OCTAL_CONV
+from .messages import Messages
+from .token import Token
+
+
+def hexValue(ch):
+    return HEX_CONV[ch]
+
+
+def octalValue(ch):
+    return OCTAL_CONV[ch]
+
+
+class RegExp(Object):
+    def __init__(self, pattern=None, flags=None):
+        self.pattern = pattern
+        self.flags = flags
+
+
+class Position(Object):
+    def __init__(self, line=None, column=None, offset=None):
+        self.line = line
+        self.column = column
+        self.offset = offset
+
+
+class SourceLocation(Object):
+    def __init__(self, start=None, end=None, source=None):
+        self.start = start
+        self.end = end
+        self.source = source
+
+
+class Comment(Object):
+    def __init__(self, multiLine=None, slice=None, range=None, loc=None):
+        self.multiLine = multiLine
+        self.slice = slice
+        self.range = range
+        self.loc = loc
+
+
+class RawToken(Object):
+    def __init__(self, type=None, value=None, pattern=None, flags=None, regex=None, octal=None, cooked=None, head=None, tail=None, lineNumber=None, lineStart=None, start=None, end=None):
+        self.type = type
+        self.value = value
+        self.pattern = pattern
+        self.flags = flags
+        self.regex = regex
+        self.octal = octal
+        self.cooked = cooked
+        self.head = head
+        self.tail = tail
+        self.lineNumber = lineNumber
+        self.lineStart = lineStart
+        self.start = start
+        self.end = end
+
+
+class ScannerState(Object):
+    def __init__(self, index=None, lineNumber=None, lineStart=None):
+        self.index = index
+        self.lineNumber = lineNumber
+        self.lineStart = lineStart
+
+
+class Octal(object):
+    def __init__(self, octal, code):
+        self.octal = octal
+        self.code = code
+
+
+class Scanner(object):
+    def __init__(self, code, handler):
+        self.source = unicode(code) + '\x00'
+        self.errorHandler = handler
+        self.trackComment = False
+        self.isModule = False
+
+        self.length = len(code)
+        self.index = 0
+        self.lineNumber = 1 if self.length > 0 else 0
+        self.lineStart = 0
+        self.curlyStack = []
+
+    def saveState(self):
+        return ScannerState(
+            index=self.index,
+            lineNumber=self.lineNumber,
+            lineStart=self.lineStart
+        )
+
+    def restoreState(self, state):
+        self.index = state.index
+        self.lineNumber = state.lineNumber
+        self.lineStart = state.lineStart
+
+    def eof(self):
+        return self.index >= self.length
+
+    def throwUnexpectedToken(self, message=Messages.UnexpectedTokenIllegal):
+        return self.errorHandler.throwError(self.index, self.lineNumber,
+            self.index - self.lineStart + 1, message)
+
+    def tolerateUnexpectedToken(self, message=Messages.UnexpectedTokenIllegal):
+        self.errorHandler.tolerateError(self.index, self.lineNumber,
+            self.index - self.lineStart + 1, message)
+
+    # https://tc39.github.io/ecma262/#sec-comments
+
+    def skipSingleLineComment(self, offset):
+        comments = []
+
+        if self.trackComment:
+            start = self.index - offset
+            loc = SourceLocation(
+                start=Position(
+                    line=self.lineNumber,
+                    column=self.index - self.lineStart - offset
+                ),
+                end=Position()
+            )
+
+        while not self.eof():
+            ch = self.source[self.index]
+            self.index += 1
+            if Character.isLineTerminator(ch):
+                if self.trackComment:
+                    loc.end = Position(
+                        line=self.lineNumber,
+                        column=self.index - self.lineStart - 1
+                    )
+                    entry = Comment(
+                        multiLine=False,
+                        slice=[start + offset, self.index - 1],
+                        range=[start, self.index - 1],
+                        loc=loc
+                    )
+                    comments.append(entry)
+
+                if ch == '\r' and self.source[self.index] == '\n':
+                    self.index += 1
+
+                self.lineNumber += 1
+                self.lineStart = self.index
+                return comments
+
+        if self.trackComment:
+            loc.end = Position(
+                line=self.lineNumber,
+                column=self.index - self.lineStart
+            )
+            entry = Comment(
+                multiLine=False,
+                slice=[start + offset, self.index],
+                range=[start, self.index],
+                loc=loc
+            )
+            comments.append(entry)
+
+        return comments
+
+    def skipMultiLineComment(self):
+        comments = []
+
+        if self.trackComment:
+            comments = []
+            start = self.index - 2
+            loc = SourceLocation(
+                start=Position(
+                    line=self.lineNumber,
+                    column=self.index - self.lineStart - 2
+                ),
+                end=Position()
+            )
+
+        while not self.eof():
+            ch = self.source[self.index]
+            if Character.isLineTerminator(ch):
+                if ch == '\r' and self.source[self.index + 1] == '\n':
+                    self.index += 1
+
+                self.lineNumber += 1
+                self.index += 1
+                self.lineStart = self.index
+            elif ch == '*':
+                # Block comment ends with '*/'.
+                if self.source[self.index + 1] == '/':
+                    self.index += 2
+                    if self.trackComment:
+                        loc.end = Position(
+                            line=self.lineNumber,
+                            column=self.index - self.lineStart
+                        )
+                        entry = Comment(
+                            multiLine=True,
+                            slice=[start + 2, self.index - 2],
+                            range=[start, self.index],
+                            loc=loc
+                        )
+                        comments.append(entry)
+
+                    return comments
+
+                self.index += 1
+            else:
+                self.index += 1
+
+        # Ran off the end of the file - the whole thing is a comment
+        if self.trackComment:
+            loc.end = Position(
+                line=self.lineNumber,
+                column=self.index - self.lineStart
+            )
+            entry = Comment(
+                multiLine=True,
+                slice=[start + 2, self.index],
+                range=[start, self.index],
+                loc=loc
+            )
+            comments.append(entry)
+
+        self.tolerateUnexpectedToken()
+        return comments
+
+    def scanComments(self):
+        comments = []
+
+        start = self.index == 0
+        while not self.eof():
+            ch = self.source[self.index]
+
+            if Character.isWhiteSpace(ch):
+                self.index += 1
+            elif Character.isLineTerminator(ch):
+                self.index += 1
+                if ch == '\r' and self.source[self.index] == '\n':
+                    self.index += 1
+
+                self.lineNumber += 1
+                self.lineStart = self.index
+                start = True
+            elif ch == '/':  # U+002F is '/'
+                ch = self.source[self.index + 1]
+                if ch == '/':
+                    self.index += 2
+                    comment = self.skipSingleLineComment(2)
+                    if self.trackComment:
+                        comments.extend(comment)
+
+                    start = True
+                elif ch == '*':  # U+002A is '*'
+                    self.index += 2
+                    comment = self.skipMultiLineComment()
+                    if self.trackComment:
+                        comments.extend(comment)
+
+                else:
+                    break
+
+            elif start and ch == '-':  # U+002D is '-'
+                # U+003E is '>'
+                if self.source[self.index + 1:self.index + 3] == '->':
+                    # '-->' is a single-line comment
+                    self.index += 3
+                    comment = self.skipSingleLineComment(3)
+                    if self.trackComment:
+                        comments.extend(comment)
+
+                else:
+                    break
+
+            elif ch == '<' and not self.isModule:  # U+003C is '<'
+                if self.source[self.index + 1:self.index + 4] == '!--':
+                    self.index += 4  # `<!--`
+                    comment = self.skipSingleLineComment(4)
+                    if self.trackComment:
+                        comments.extend(comment)
+
+                else:
+                    break
+
+            else:
+                break
+
+        return comments
+
+    # https://tc39.github.io/ecma262/#sec-future-reserved-words
+
+    def isFutureReservedWord(self, id):
+        return id in self.isFutureReservedWord.set
+    isFutureReservedWord.set = set((
+        'enum',
+        'export',
+        'import',
+        'super',
+    ))
+
+    def isStrictModeReservedWord(self, id):
+        return id in self.isStrictModeReservedWord.set
+    isStrictModeReservedWord.set = set((
+        'implements',
+        'interface',
+        'package',
+        'private',
+        'protected',
+        'public',
+        'static',
+        'yield',
+        'let',
+    ))
+
+    def isRestrictedWord(self, id):
+        return id in self.isRestrictedWord.set
+    isRestrictedWord.set = set((
+        'eval', 'arguments',
+    ))
+
+    # https://tc39.github.io/ecma262/#sec-keywords
+
+    def isKeyword(self, id):
+        return id in self.isKeyword.set
+    isKeyword.set = set((
+        'if', 'in', 'do',
+
+        'var', 'for', 'new',
+        'try', 'let',
+
+        'this', 'else', 'case',
+        'void', 'with', 'enum',
+
+        'while', 'break', 'catch',
+        'throw', 'const', 'yield',
+        'class', 'super',
+
+        'return', 'typeof', 'delete',
+        'switch', 'export', 'import',
+
+        'default', 'finally', 'extends',
+
+        'function', 'continue', 'debugger',
+
+        'instanceof',
+    ))
+
+    def codePointAt(self, i):
+        return uord(self.source[i:i + 2])
+
+    def scanHexEscape(self, prefix):
+        length = 4 if prefix == 'u' else 2
+        code = 0
+
+        for i in xrange(length):
+            if not self.eof() and Character.isHexDigit(self.source[self.index]):
+                ch = self.source[self.index]
+                self.index += 1
+                code = code * 16 + hexValue(ch)
+            else:
+                return None
+
+        return uchr(code)
+
+    def scanUnicodeCodePointEscape(self):
+        ch = self.source[self.index]
+        code = 0
+
+        # At least, one hex digit is required.
+        if ch == '}':
+            self.throwUnexpectedToken()
+
+        while not self.eof():
+            ch = self.source[self.index]
+            self.index += 1
+            if not Character.isHexDigit(ch):
+                break
+
+            code = code * 16 + hexValue(ch)
+
+        if code > 0x10FFFF or ch != '}':
+            self.throwUnexpectedToken()
+
+        return Character.fromCodePoint(code)
+
+    def getIdentifier(self):
+        start = self.index
+        self.index += 1
+        while not self.eof():
+            ch = self.source[self.index]
+            if ch == '\\':
+                # Blackslash (U+005C) marks Unicode escape sequence.
+                self.index = start
+                return self.getComplexIdentifier()
+            else:
+                cp = ord(ch)
+                if cp >= 0xD800 and cp < 0xDFFF:
+                    # Need to handle surrogate pairs.
+                    self.index = start
+                    return self.getComplexIdentifier()
+
+            if Character.isIdentifierPart(ch):
+                self.index += 1
+            else:
+                break
+
+        return self.source[start:self.index]
+
+    def getComplexIdentifier(self):
+        cp = self.codePointAt(self.index)
+        id = Character.fromCodePoint(cp)
+        self.index += len(id)
+
+        # '\u' (U+005C, U+0075) denotes an escaped character.
+        if cp == 0x5C:
+            if self.source[self.index] != 'u':
+                self.throwUnexpectedToken()
+
+            self.index += 1
+            if self.source[self.index] == '{':
+                self.index += 1
+                ch = self.scanUnicodeCodePointEscape()
+            else:
+                ch = self.scanHexEscape('u')
+                if not ch or ch == '\\' or not Character.isIdentifierStart(ch[0]):
+                    self.throwUnexpectedToken()
+
+            id = ch
+
+        while not self.eof():
+            cp = self.codePointAt(self.index)
+            ch = Character.fromCodePoint(cp)
+            if not Character.isIdentifierPart(ch):
+                break
+
+            id += ch
+            self.index += len(ch)
+
+            # '\u' (U+005C, U+0075) denotes an escaped character.
+            if cp == 0x5C:
+                id = id[:-1]
+                if self.source[self.index] != 'u':
+                    self.throwUnexpectedToken()
+
+                self.index += 1
+                if self.source[self.index] == '{':
+                    self.index += 1
+                    ch = self.scanUnicodeCodePointEscape()
+                else:
+                    ch = self.scanHexEscape('u')
+                    if not ch or ch == '\\' or not Character.isIdentifierPart(ch[0]):
+                        self.throwUnexpectedToken()
+
+                id += ch
+
+        return id
+
+    def octalToDecimal(self, ch):
+        # \0 is not octal escape sequence
+        octal = ch != '0'
+        code = octalValue(ch)
+
+        if not self.eof() and Character.isOctalDigit(self.source[self.index]):
+            octal = True
+            code = code * 8 + octalValue(self.source[self.index])
+            self.index += 1
+
+            # 3 digits are only allowed when string starts
+            # with 0, 1, 2, 3
+            if ch in '0123' and not self.eof() and Character.isOctalDigit(self.source[self.index]):
+                code = code * 8 + octalValue(self.source[self.index])
+                self.index += 1
+
+        return Octal(octal, code)
+
+    # https://tc39.github.io/ecma262/#sec-names-and-keywords
+
+    def scanIdentifier(self):
+        start = self.index
+
+        # Backslash (U+005C) starts an escaped character.
+        id = self.getComplexIdentifier() if self.source[start] == '\\' else self.getIdentifier()
+
+        # There is no keyword or literal with only one character.
+        # Thus, it must be an identifier.
+        if len(id) == 1:
+            type = Token.Identifier
+        elif self.isKeyword(id):
+            type = Token.Keyword
+        elif id == 'null':
+            type = Token.NullLiteral
+        elif id == 'true' or id == 'false':
+            type = Token.BooleanLiteral
+        else:
+            type = Token.Identifier
+
+        if type is not Token.Identifier and start + len(id) != self.index:
+            restore = self.index
+            self.index = start
+            self.tolerateUnexpectedToken(Messages.InvalidEscapedReservedWord)
+            self.index = restore
+
+        return RawToken(
+            type=type,
+            value=id,
+            lineNumber=self.lineNumber,
+            lineStart=self.lineStart,
+            start=start,
+            end=self.index
+        )
+
+    # https://tc39.github.io/ecma262/#sec-punctuators
+
+    def scanPunctuator(self):
+        start = self.index
+
+        # Check for most common single-character punctuators.
+        str = self.source[self.index]
+        if str in (
+            '(',
+            '{',
+        ):
+            if str == '{':
+                self.curlyStack.append('{')
+
+            self.index += 1
+
+        elif str == '.':
+            self.index += 1
+            if self.source[self.index] == '.' and self.source[self.index + 1] == '.':
+                # Spread operator: ...
+                self.index += 2
+                str = '...'
+
+        elif str == '}':
+            self.index += 1
+            if self.curlyStack:
+                self.curlyStack.pop()
+
+        elif str in (
+            ')',
+            ';',
+            ',',
+            '[',
+            ']',
+            ':',
+            '?',
+            '~',
+        ):
+            self.index += 1
+
+        else:
+            # 4-character punctuator.
+            str = self.source[self.index:self.index + 4]
+            if str == '>>>=':
+                self.index += 4
+            else:
+
+                # 3-character punctuators.
+                str = str[:3]
+                if str in (
+                    '===', '!==', '>>>',
+                    '<<=', '>>=', '**='
+                ):
+                    self.index += 3
+                else:
+
+                    # 2-character punctuators.
+                    str = str[:2]
+                    if str in (
+                        '&&', '||', '==', '!=',
+                        '+=', '-=', '*=', '/=',
+                        '++', '--', '<<', '>>',
+                        '&=', '|=', '^=', '%=',
+                        '<=', '>=', '=>', '**',
+                    ):
+                        self.index += 2
+                    else:
+
+                        # 1-character punctuators.
+                        str = self.source[self.index]
+                        if str in '<>=!+-*%&|^/':
+                            self.index += 1
+
+        if self.index == start:
+            self.throwUnexpectedToken()
+
+        return RawToken(
+            type=Token.Punctuator,
+            value=str,
+            lineNumber=self.lineNumber,
+            lineStart=self.lineStart,
+            start=start,
+            end=self.index
+        )
+
+    # https://tc39.github.io/ecma262/#sec-literals-numeric-literals
+
+    def scanHexLiteral(self, start):
+        num = ''
+
+        while not self.eof():
+            if not Character.isHexDigit(self.source[self.index]):
+                break
+
+            num += self.source[self.index]
+            self.index += 1
+
+        if len(num) == 0:
+            self.throwUnexpectedToken()
+
+        if Character.isIdentifierStart(self.source[self.index]):
+            self.throwUnexpectedToken()
+
+        return RawToken(
+            type=Token.NumericLiteral,
+            value=int(num, 16),
+            lineNumber=self.lineNumber,
+            lineStart=self.lineStart,
+            start=start,
+            end=self.index
+        )
+
+    def scanBinaryLiteral(self, start):
+        num = ''
+
+        while not self.eof():
+            ch = self.source[self.index]
+            if ch != '0' and ch != '1':
+                break
+
+            num += self.source[self.index]
+            self.index += 1
+
+        if len(num) == 0:
+            # only 0b or 0B
+            self.throwUnexpectedToken()
+
+        if not self.eof():
+            ch = self.source[self.index]
+            if Character.isIdentifierStart(ch) or Character.isDecimalDigit(ch):
+                self.throwUnexpectedToken()
+
+        return RawToken(
+            type=Token.NumericLiteral,
+            value=int(num, 2),
+            lineNumber=self.lineNumber,
+            lineStart=self.lineStart,
+            start=start,
+            end=self.index
+        )
+
+    def scanOctalLiteral(self, prefix, start):
+        num = ''
+        octal = False
+
+        if Character.isOctalDigit(prefix[0]):
+            octal = True
+            num = '0' + self.source[self.index]
+        self.index += 1
+
+        while not self.eof():
+            if not Character.isOctalDigit(self.source[self.index]):
+                break
+
+            num += self.source[self.index]
+            self.index += 1
+
+        if not octal and len(num) == 0:
+            # only 0o or 0O
+            self.throwUnexpectedToken()
+
+        if Character.isIdentifierStart(self.source[self.index]) or Character.isDecimalDigit(self.source[self.index]):
+            self.throwUnexpectedToken()
+
+        return RawToken(
+            type=Token.NumericLiteral,
+            value=int(num, 8),
+            octal=octal,
+            lineNumber=self.lineNumber,
+            lineStart=self.lineStart,
+            start=start,
+            end=self.index
+        )
+
+    def isImplicitOctalLiteral(self):
+        # Implicit octal, unless there is a non-octal digit.
+        # (Annex B.1.1 on Numeric Literals)
+        for i in xrange(self.index + 1, self.length):
+            ch = self.source[i]
+            if ch in '89':
+                return False
+            if not Character.isOctalDigit(ch):
+                return True
+        return True
+
+    def scanNumericLiteral(self):
+        start = self.index
+        ch = self.source[start]
+        assert Character.isDecimalDigit(ch) or ch == '.', 'Numeric literal must start with a decimal digit or a decimal point'
+
+        num = ''
+        if ch != '.':
+            num = self.source[self.index]
+            self.index += 1
+            ch = self.source[self.index]
+
+            # Hex number starts with '0x'.
+            # Octal number starts with '0'.
+            # Octal number in ES6 starts with '0o'.
+            # Binary number in ES6 starts with '0b'.
+            if num == '0':
+                if ch in ('x', 'X'):
+                    self.index += 1
+                    return self.scanHexLiteral(start)
+
+                if ch in ('b', 'B'):
+                    self.index += 1
+                    return self.scanBinaryLiteral(start)
+
+                if ch in ('o', 'O'):
+                    return self.scanOctalLiteral(ch, start)
+
+                if ch and Character.isOctalDigit(ch):
+                    if self.isImplicitOctalLiteral():
+                        return self.scanOctalLiteral(ch, start)
+
+            while Character.isDecimalDigit(self.source[self.index]):
+                num += self.source[self.index]
+                self.index += 1
+
+            ch = self.source[self.index]
+
+        if ch == '.':
+            num += self.source[self.index]
+            self.index += 1
+            while Character.isDecimalDigit(self.source[self.index]):
+                num += self.source[self.index]
+                self.index += 1
+
+            ch = self.source[self.index]
+
+        if ch in ('e', 'E'):
+            num += self.source[self.index]
+            self.index += 1
+
+            ch = self.source[self.index]
+            if ch in ('+', '-'):
+                num += self.source[self.index]
+                self.index += 1
+
+            if Character.isDecimalDigit(self.source[self.index]):
+                while Character.isDecimalDigit(self.source[self.index]):
+                    num += self.source[self.index]
+                    self.index += 1
+
+            else:
+                self.throwUnexpectedToken()
+
+        if Character.isIdentifierStart(self.source[self.index]):
+            self.throwUnexpectedToken()
+
+        value = float(num)
+        return RawToken(
+            type=Token.NumericLiteral,
+            value=int(value) if value.is_integer() else value,
+            lineNumber=self.lineNumber,
+            lineStart=self.lineStart,
+            start=start,
+            end=self.index
+        )
+
+    # https://tc39.github.io/ecma262/#sec-literals-string-literals
+
+    def scanStringLiteral(self):
+        start = self.index
+        quote = self.source[start]
+        assert quote in ('\'', '"'), 'String literal must starts with a quote'
+
+        self.index += 1
+        octal = False
+        str = ''
+
+        while not self.eof():
+            ch = self.source[self.index]
+            self.index += 1
+
+            if ch == quote:
+                quote = ''
+                break
+            elif ch == '\\':
+                ch = self.source[self.index]
+                self.index += 1
+                if not ch or not Character.isLineTerminator(ch):
+                    if ch == 'u':
+                        if self.source[self.index] == '{':
+                            self.index += 1
+                            str += self.scanUnicodeCodePointEscape()
+                        else:
+                            unescapedChar = self.scanHexEscape(ch)
+                            if not unescapedChar:
+                                self.throwUnexpectedToken()
+
+                            str += unescapedChar
+
+                    elif ch == 'x':
+                        unescaped = self.scanHexEscape(ch)
+                        if not unescaped:
+                            self.throwUnexpectedToken(Messages.InvalidHexEscapeSequence)
+
+                        str += unescaped
+                    elif ch == 'n':
+                        str += '\n'
+                    elif ch == 'r':
+                        str += '\r'
+                    elif ch == 't':
+                        str += '\t'
+                    elif ch == 'b':
+                        str += '\b'
+                    elif ch == 'f':
+                        str += '\f'
+                    elif ch == 'v':
+                        str += '\x0B'
+                    elif ch in (
+                        '8',
+                        '9',
+                    ):
+                        str += ch
+                        self.tolerateUnexpectedToken()
+
+                    else:
+                        if ch and Character.isOctalDigit(ch):
+                            octToDec = self.octalToDecimal(ch)
+
+                            octal = octToDec.octal or octal
+                            str += uchr(octToDec.code)
+                        else:
+                            str += ch
+
+                else:
+                    self.lineNumber += 1
+                    if ch == '\r' and self.source[self.index] == '\n':
+                        self.index += 1
+
+                    self.lineStart = self.index
+
+            elif Character.isLineTerminator(ch):
+                break
+            else:
+                str += ch
+
+        if quote != '':
+            self.index = start
+            self.throwUnexpectedToken()
+
+        return RawToken(
+            type=Token.StringLiteral,
+            value=str,
+            octal=octal,
+            lineNumber=self.lineNumber,
+            lineStart=self.lineStart,
+            start=start,
+            end=self.index
+        )
+
+    # https://tc39.github.io/ecma262/#sec-template-literal-lexical-components
+
+    def scanTemplate(self):
+        cooked = ''
+        terminated = False
+        start = self.index
+
+        head = self.source[start] == '`'
+        tail = False
+        rawOffset = 2
+
+        self.index += 1
+
+        while not self.eof():
+            ch = self.source[self.index]
+            self.index += 1
+            if ch == '`':
+                rawOffset = 1
+                tail = True
+                terminated = True
+                break
+            elif ch == '$':
+                if self.source[self.index] == '{':
+                    self.curlyStack.append('${')
+                    self.index += 1
+                    terminated = True
+                    break
+
+                cooked += ch
+            elif ch == '\\':
+                ch = self.source[self.index]
+                self.index += 1
+                if not Character.isLineTerminator(ch):
+                    if ch == 'n':
+                        cooked += '\n'
+                    elif ch == 'r':
+                        cooked += '\r'
+                    elif ch == 't':
+                        cooked += '\t'
+                    elif ch == 'u':
+                        if self.source[self.index] == '{':
+                            self.index += 1
+                            cooked += self.scanUnicodeCodePointEscape()
+                        else:
+                            restore = self.index
+                            unescapedChar = self.scanHexEscape(ch)
+                            if unescapedChar:
+                                cooked += unescapedChar
+                            else:
+                                self.index = restore
+                                cooked += ch
+
+                    elif ch == 'x':
+                        unescaped = self.scanHexEscape(ch)
+                        if not unescaped:
+                            self.throwUnexpectedToken(Messages.InvalidHexEscapeSequence)
+
+                        cooked += unescaped
+                    elif ch == 'b':
+                        cooked += '\b'
+                    elif ch == 'f':
+                        cooked += '\f'
+                    elif ch == 'v':
+                        cooked += '\v'
+
+                    else:
+                        if ch == '0':
+                            if Character.isDecimalDigit(self.source[self.index]):
+                                # Illegal: \01 \02 and so on
+                                self.throwUnexpectedToken(Messages.TemplateOctalLiteral)
+
+                            cooked += '\0'
+                        elif Character.isOctalDigit(ch):
+                            # Illegal: \1 \2
+                            self.throwUnexpectedToken(Messages.TemplateOctalLiteral)
+                        else:
+                            cooked += ch
+
+                else:
+                    self.lineNumber += 1
+                    if ch == '\r' and self.source[self.index] == '\n':
+                        self.index += 1
+
+                    self.lineStart = self.index
+
+            elif Character.isLineTerminator(ch):
+                self.lineNumber += 1
+                if ch == '\r' and self.source[self.index] == '\n':
+                    self.index += 1
+
+                self.lineStart = self.index
+                cooked += '\n'
+            else:
+                cooked += ch
+
+        if not terminated:
+            self.throwUnexpectedToken()
+
+        if not head:
+            if self.curlyStack:
+                self.curlyStack.pop()
+
+        return RawToken(
+            type=Token.Template,
+            value=self.source[start + 1:self.index - rawOffset],
+            cooked=cooked,
+            head=head,
+            tail=tail,
+            lineNumber=self.lineNumber,
+            lineStart=self.lineStart,
+            start=start,
+            end=self.index
+        )
+
+    # https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
+
+    def testRegExp(self, pattern, flags):
+        # The BMP character to use as a replacement for astral symbols when
+        # translating an ES6 "u"-flagged pattern to an ES5-compatible
+        # approximation.
+        # Note: replacing with '\uFFFF' enables false positives in unlikely
+        # scenarios. For example, `[\u{1044f}-\u{10440}]` is an invalid
+        # pattern that would not be detected by this substitution.
+        astralSubstitute = '\uFFFF'
+
+        # Replace every Unicode escape sequence with the equivalent
+        # BMP character or a constant ASCII code point in the case of
+        # astral symbols. (See the above note on `astralSubstitute`
+        # for more information.)
+        def astralSub(m):
+            codePoint = int(m.group(1) or m.group(2), 16)
+            if codePoint > 0x10FFFF:
+                self.tolerateUnexpectedToken(Messages.InvalidRegExp)
+            elif codePoint <= 0xFFFF:
+                return uchr(codePoint)
+            return astralSubstitute
+        pattern = re.sub(r'\\u\{([0-9a-fA-F]+)\}|\\u([a-fA-F0-9]{4})', astralSub, pattern)
+
+        # Replace each paired surrogate with a single ASCII symbol to
+        # avoid throwing on regular expressions that are only valid in
+        # combination with the "u" flag.
+        pattern = re.sub(r'[\uD800-\uDBFF][\uDC00-\uDFFF]', astralSubstitute, pattern)
+
+        # Return a regular expression object for this pattern-flag pair, or
+        # `null` in case the current environment doesn't support the flags it
+        # uses.
+        pyflags = 0 | re.M if 'm' in flags else 0 | re.I if 'i' in flags else 0
+        try:
+            return re.compile(pattern, pyflags)
+        except Exception:
+            self.tolerateUnexpectedToken(Messages.InvalidRegExp)
+
+    def scanRegExpBody(self):
+        ch = self.source[self.index]
+        assert ch == '/', 'Regular expression literal must start with a slash'
+
+        str = self.source[self.index]
+        self.index += 1
+        classMarker = False
+        terminated = False
+
+        while not self.eof():
+            ch = self.source[self.index]
+            self.index += 1
+            str += ch
+            if ch == '\\':
+                ch = self.source[self.index]
+                self.index += 1
+                # https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals
+                if Character.isLineTerminator(ch):
+                    self.throwUnexpectedToken(Messages.UnterminatedRegExp)
+
+                str += ch
+            elif Character.isLineTerminator(ch):
+                self.throwUnexpectedToken(Messages.UnterminatedRegExp)
+            elif classMarker:
+                if ch == ']':
+                    classMarker = False
+
+            else:
+                if ch == '/':
+                    terminated = True
+                    break
+                elif ch == '[':
+                    classMarker = True
+
+        if not terminated:
+            self.throwUnexpectedToken(Messages.UnterminatedRegExp)
+
+        # Exclude leading and trailing slash.
+        return str[1:-1]
+
+    def scanRegExpFlags(self):
+        str = ''
+        flags = ''
+        while not self.eof():
+            ch = self.source[self.index]
+            if not Character.isIdentifierPart(ch):
+                break
+
+            self.index += 1
+            if ch == '\\' and not self.eof():
+                ch = self.source[self.index]
+                if ch == 'u':
+                    self.index += 1
+                    restore = self.index
+                    char = self.scanHexEscape('u')
+                    if char:
+                        flags += char
+                        str += '\\u'
+                        while restore < self.index:
+                            str += self.source[restore]
+                            restore += 1
+
+                    else:
+                        self.index = restore
+                        flags += 'u'
+                        str += '\\u'
+
+                    self.tolerateUnexpectedToken()
+                else:
+                    str += '\\'
+                    self.tolerateUnexpectedToken()
+
+            else:
+                flags += ch
+                str += ch
+
+        return flags
+
+    def scanRegExp(self):
+        start = self.index
+
+        pattern = self.scanRegExpBody()
+        flags = self.scanRegExpFlags()
+        value = self.testRegExp(pattern, flags)
+
+        return RawToken(
+            type=Token.RegularExpression,
+            value='',
+            pattern=pattern,
+            flags=flags,
+            regex=value,
+            lineNumber=self.lineNumber,
+            lineStart=self.lineStart,
+            start=start,
+            end=self.index
+        )
+
+    def lex(self):
+        if self.eof():
+            return RawToken(
+                type=Token.EOF,
+                value='',
+                lineNumber=self.lineNumber,
+                lineStart=self.lineStart,
+                start=self.index,
+                end=self.index
+            )
+
+        ch = self.source[self.index]
+
+        if Character.isIdentifierStart(ch):
+            return self.scanIdentifier()
+
+        # Very common: ( and ) and ;
+        if ch in ('(', ')', ';'):
+            return self.scanPunctuator()
+
+        # String literal starts with single quote (U+0027) or double quote (U+0022).
+        if ch in ('\'', '"'):
+            return self.scanStringLiteral()
+
+        # Dot (.) U+002E can also start a floating-point number, hence the need
+        # to check the next character.
+        if ch == '.':
+            if Character.isDecimalDigit(self.source[self.index + 1]):
+                return self.scanNumericLiteral()
+
+            return self.scanPunctuator()
+
+        if Character.isDecimalDigit(ch):
+            return self.scanNumericLiteral()
+
+        # Template literals start with ` (U+0060) for template head
+        # or } (U+007D) for template middle or template tail.
+        if ch == '`' or (ch == '}' and self.curlyStack and self.curlyStack[-1] == '${'):
+            return self.scanTemplate()
+
+        # Possible identifier start in a surrogate pair.
+        cp = ord(ch)
+        if cp >= 0xD800 and cp < 0xDFFF:
+            cp = self.codePointAt(self.index)
+            ch = Character.fromCodePoint(cp)
+            if Character.isIdentifierStart(ch):
+                return self.scanIdentifier()
+
+        return self.scanPunctuator()
diff --git a/lib/esprima/syntax.py b/lib/esprima/syntax.py
new file mode 100644
index 00000000..001b641e
--- /dev/null
+++ b/lib/esprima/syntax.py
@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import unicode_literals
+
+
+class Syntax:
+    AssignmentExpression = "AssignmentExpression"
+    AssignmentPattern = "AssignmentPattern"
+    ArrayExpression = "ArrayExpression"
+    ArrayPattern = "ArrayPattern"
+    ArrowFunctionExpression = "ArrowFunctionExpression"
+    AwaitExpression = "AwaitExpression"
+    BlockStatement = "BlockStatement"
+    BinaryExpression = "BinaryExpression"
+    BreakStatement = "BreakStatement"
+    CallExpression = "CallExpression"
+    CatchClause = "CatchClause"
+    ClassBody = "ClassBody"
+    ClassDeclaration = "ClassDeclaration"
+    ClassExpression = "ClassExpression"
+    ConditionalExpression = "ConditionalExpression"
+    ContinueStatement = "ContinueStatement"
+    DoWhileStatement = "DoWhileStatement"
+    DebuggerStatement = "DebuggerStatement"
+    EmptyStatement = "EmptyStatement"
+    ExportAllDeclaration = "ExportAllDeclaration"
+    ExportDefaultDeclaration = "ExportDefaultDeclaration"
+    ExportNamedDeclaration = "ExportNamedDeclaration"
+    ExportSpecifier = "ExportSpecifier"
+    ExportDefaultSpecifier = "ExportDefaultSpecifier"
+    ExpressionStatement = "ExpressionStatement"
+    ForStatement = "ForStatement"
+    ForOfStatement = "ForOfStatement"
+    ForInStatement = "ForInStatement"
+    FunctionDeclaration = "FunctionDeclaration"
+    FunctionExpression = "FunctionExpression"
+    Identifier = "Identifier"
+    IfStatement = "IfStatement"
+    Import = "Import"
+    ImportDeclaration = "ImportDeclaration"
+    ImportDefaultSpecifier = "ImportDefaultSpecifier"
+    ImportNamespaceSpecifier = "ImportNamespaceSpecifier"
+    ImportSpecifier = "ImportSpecifier"
+    Literal = "Literal"
+    LabeledStatement = "LabeledStatement"
+    LogicalExpression = "LogicalExpression"
+    MemberExpression = "MemberExpression"
+    MetaProperty = "MetaProperty"
+    MethodDefinition = "MethodDefinition"
+    FieldDefinition = "FieldDefinition"
+    NewExpression = "NewExpression"
+    ObjectExpression = "ObjectExpression"
+    ObjectPattern = "ObjectPattern"
+    Program = "Program"
+    Property = "Property"
+    RestElement = "RestElement"
+    ReturnStatement = "ReturnStatement"
+    SequenceExpression = "SequenceExpression"
+    SpreadElement = "SpreadElement"
+    Super = "Super"
+    SwitchCase = "SwitchCase"
+    SwitchStatement = "SwitchStatement"
+    TaggedTemplateExpression = "TaggedTemplateExpression"
+    TemplateElement = "TemplateElement"
+    TemplateLiteral = "TemplateLiteral"
+    ThisExpression = "ThisExpression"
+    ThrowStatement = "ThrowStatement"
+    TryStatement = "TryStatement"
+    UnaryExpression = "UnaryExpression"
+    UpdateExpression = "UpdateExpression"
+    VariableDeclaration = "VariableDeclaration"
+    VariableDeclarator = "VariableDeclarator"
+    WhileStatement = "WhileStatement"
+    WithStatement = "WithStatement"
+    YieldExpression = "YieldExpression"
+
+    ArrowParameterPlaceHolder = "ArrowParameterPlaceHolder"
+    BlockComment = "BlockComment"
+    LineComment = "LineComment"
diff --git a/lib/esprima/token.py b/lib/esprima/token.py
new file mode 100644
index 00000000..846ced60
--- /dev/null
+++ b/lib/esprima/token.py
@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import unicode_literals
+
+
+class Token:
+    BooleanLiteral = 1
+    EOF = 2
+    Identifier = 3
+    Keyword = 4
+    NullLiteral = 5
+    NumericLiteral = 6
+    Punctuator = 7
+    StringLiteral = 8
+    RegularExpression = 9
+    Template = 10
+
+
+TokenName = {}
+TokenName[Token.BooleanLiteral] = "Boolean"
+TokenName[Token.EOF] = "<end>"
+TokenName[Token.Identifier] = "Identifier"
+TokenName[Token.Keyword] = "Keyword"
+TokenName[Token.NullLiteral] = "Null"
+TokenName[Token.NumericLiteral] = "Numeric"
+TokenName[Token.Punctuator] = "Punctuator"
+TokenName[Token.StringLiteral] = "String"
+TokenName[Token.RegularExpression] = "RegularExpression"
+TokenName[Token.Template] = "Template"
diff --git a/lib/esprima/tokenizer.py b/lib/esprima/tokenizer.py
new file mode 100644
index 00000000..4a11ca05
--- /dev/null
+++ b/lib/esprima/tokenizer.py
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+from collections import deque
+
+from .objects import Object
+from .error_handler import ErrorHandler
+from .scanner import Scanner, SourceLocation, Position, RegExp
+from .token import Token, TokenName
+
+
+class BufferEntry(Object):
+    def __init__(self, type, value, regex=None, range=None, loc=None):
+        self.type = type
+        self.value = value
+        self.regex = regex
+        self.range = range
+        self.loc = loc
+
+
+class Reader(object):
+    def __init__(self):
+        self.values = []
+        self.curly = self.paren = -1
+
+    # A function following one of those tokens is an expression.
+    def beforeFunctionExpression(self, t):
+        return t in (
+            '(', '{', '[', 'in', 'typeof', 'instanceof', 'new',
+            'return', 'case', 'delete', 'throw', 'void',
+            # assignment operators
+            '=', '+=', '-=', '*=', '**=', '/=', '%=', '<<=', '>>=', '>>>=',
+            '&=', '|=', '^=', ',',
+            # binary/unary operators
+            '+', '-', '*', '**', '/', '%', '++', '--', '<<', '>>', '>>>', '&',
+            '|', '^', '!', '~', '&&', '||', '?', ':', '===', '==', '>=',
+            '<=', '<', '>', '!=', '!=='
+        )
+
+    # Determine if forward slash (/) is an operator or part of a regular expression
+    # https://github.com/mozilla/sweet.js/wiki/design
+    def isRegexStart(self):
+        if not self.values:
+            return True
+
+        previous = self.values[-1]
+        regex = previous is not None
+
+        if previous in (
+            'this',
+            ']',
+        ):
+            regex = False
+        elif previous == ')':
+            keyword = self.values[self.paren - 1]
+            regex = keyword in ('if', 'while', 'for', 'with')
+
+        elif previous == '}':
+            # Dividing a function by anything makes little sense,
+            # but we have to check for that.
+            regex = True
+            if len(self.values) >= 3 and self.values[self.curly - 3] == 'function':
+                # Anonymous function, e.g. function(){} /42
+                check = self.values[self.curly - 4]
+                regex = not self.beforeFunctionExpression(check) if check else False
+            elif len(self.values) >= 4 and self.values[self.curly - 4] == 'function':
+                # Named function, e.g. function f(){} /42/
+                check = self.values[self.curly - 5]
+                regex = not self.beforeFunctionExpression(check) if check else True
+
+        return regex
+
+    def append(self, token):
+        if token.type in (Token.Punctuator, Token.Keyword):
+            if token.value == '{':
+                self.curly = len(self.values)
+            elif token.value == '(':
+                self.paren = len(self.values)
+            self.values.append(token.value)
+        else:
+            self.values.append(None)
+
+
+class Config(Object):
+    def __init__(self, tolerant=None, comment=None, range=None, loc=None, **options):
+        self.tolerant = tolerant
+        self.comment = comment
+        self.range = range
+        self.loc = loc
+        for k, v in options.items():
+            setattr(self, k, v)
+
+
+class Tokenizer(object):
+    def __init__(self, code, options):
+        self.config = Config(**options)
+
+        self.errorHandler = ErrorHandler()
+        self.errorHandler.tolerant = self.config.tolerant
+        self.scanner = Scanner(code, self.errorHandler)
+        self.scanner.trackComment = self.config.comment
+
+        self.trackRange = self.config.range
+        self.trackLoc = self.config.loc
+        self.buffer = deque()
+        self.reader = Reader()
+
+    def errors(self):
+        return self.errorHandler.errors
+
+    def getNextToken(self):
+        if not self.buffer:
+
+            comments = self.scanner.scanComments()
+            if self.scanner.trackComment:
+                for e in comments:
+                    value = self.scanner.source[e.slice[0]:e.slice[1]]
+                    comment = BufferEntry(
+                        type='BlockComment' if e.multiLine else 'LineComment',
+                        value=value
+                    )
+                    if self.trackRange:
+                        comment.range = e.range
+                    if self.trackLoc:
+                        comment.loc = e.loc
+                    self.buffer.append(comment)
+
+            if not self.scanner.eof():
+                if self.trackLoc:
+                    loc = SourceLocation(
+                        start=Position(
+                            line=self.scanner.lineNumber,
+                            column=self.scanner.index - self.scanner.lineStart
+                        ),
+                        end=Position(),
+                    )
+
+                maybeRegex = self.scanner.source[self.scanner.index] == '/' and self.reader.isRegexStart()
+                if maybeRegex:
+                    state = self.scanner.saveState()
+                    try:
+                        token = self.scanner.scanRegExp()
+                    except Exception:
+                        self.scanner.restoreState(state)
+                        token = self.scanner.lex()
+                else:
+                    token = self.scanner.lex()
+
+                self.reader.append(token)
+
+                entry = BufferEntry(
+                    type=TokenName[token.type],
+                    value=self.scanner.source[token.start:token.end]
+                )
+                if self.trackRange:
+                    entry.range = [token.start, token.end]
+                if self.trackLoc:
+                    loc.end = Position(
+                        line=self.scanner.lineNumber,
+                        column=self.scanner.index - self.scanner.lineStart
+                    )
+                    entry.loc = loc
+                if token.type is Token.RegularExpression:
+                    entry.regex = RegExp(
+                        pattern=token.pattern,
+                        flags=token.flags,
+                    )
+
+                self.buffer.append(entry)
+
+        return self.buffer.popleft() if self.buffer else None
diff --git a/lib/esprima/utils.py b/lib/esprima/utils.py
new file mode 100644
index 00000000..62cbe9e9
--- /dev/null
+++ b/lib/esprima/utils.py
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import absolute_import, unicode_literals
+
+import re
+
+from .compat import unicode
+
+
+def format(messageFormat, *args):
+    def formatter(m):
+        formatter.idx += 1
+        assert formatter.idx < len(args), 'Message reference must be in range'
+        return unicode(args[formatter.idx])
+    formatter.idx = -1
+    return format.re.sub(formatter, messageFormat)
+
+
+format.re = re.compile(r'%(\d)')
diff --git a/lib/esprima/visitor.py b/lib/esprima/visitor.py
new file mode 100644
index 00000000..ad323751
--- /dev/null
+++ b/lib/esprima/visitor.py
@@ -0,0 +1,288 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import unicode_literals
+
+import json
+import types
+from collections import deque
+
+from .objects import Object
+from .compat import PY3, unicode
+
+
+class VisitRecursionError(Exception):
+    pass
+
+
+class Visited(object):
+    def __init__(self, result):
+        if isinstance(result, Visited):
+            result = result.result
+        self.result = result
+
+
+class Visitor(object):
+    """
+    An Object visitor base class that walks the abstract syntax tree and calls a
+    visitor function for every Object found.  This function may return a value
+    which is forwarded by the `visit` method.
+
+    This class is meant to be subclassed, with the subclass adding visitor
+    methods.
+
+    Per default the visitor functions for the nodes are ``'visit_'`` +
+    class name of the Object.  So a `Module` Object visit function would
+    be `visit_Module`.  This behavior can be changed by overriding
+    the `visit` method.  If no visitor function exists for an Object
+    (return value `None`) the `generic_visit` visitor is used instead.
+    """
+
+    def __call__(self, obj, metadata):
+        return self.transform(obj, metadata)
+
+    def transform(self, obj, metadata):
+        """Transform an Object."""
+        if isinstance(obj, Object):
+            method = 'transform_' + obj.__class__.__name__
+            transformer = getattr(self, method, self.transform_Object)
+            new_obj = transformer(obj, metadata)
+            if new_obj is not None and obj is not new_obj:
+                obj = new_obj
+        return obj
+
+    def transform_Object(self, obj, metadata):
+        """Called if no explicit transform function exists for an Object."""
+        return obj
+
+    def generic_visit(self, obj):
+        return self.visit(self.visit_Object(obj))
+
+    def visit(self, obj):
+        """Visit an Object."""
+        if not hasattr(self, 'visitors'):
+            self._visit_context = {}
+            self._visit_count = 0
+        try:
+            self._visit_count += 1
+            stack = deque()
+            stack.append((obj, None))
+            last_result = None
+            while stack:
+                try:
+                    last, visited = stack[-1]
+                    if isinstance(last, types.GeneratorType):
+                        stack.append((last.send(last_result), None))
+                        last_result = None
+                    elif isinstance(last, Visited):
+                        stack.pop()
+                        last_result = last.result
+                    elif isinstance(last, Object):
+                        if last in self._visit_context:
+                            if self._visit_context[last] == self.visit_Object:
+                                visitor = self.visit_RecursionError
+                            else:
+                                visitor = self.visit_Object
+                        else:
+                            method = 'visit_' + last.__class__.__name__
+                            visitor = getattr(self, method, self.visit_Object)
+                        self._visit_context[last] = visitor
+                        stack.pop()
+                        stack.append((visitor(last), last))
+                    else:
+                        method = 'visit_' + last.__class__.__name__
+                        visitor = getattr(self, method, self.visit_Generic)
+                        stack.pop()
+                        stack.append((visitor(last), None))
+                except StopIteration:
+                    stack.pop()
+                    if visited and visited in self._visit_context:
+                        del self._visit_context[visited]
+            return last_result
+        finally:
+            self._visit_count -= 1
+            if self._visit_count <= 0:
+                self._visit_context = {}
+
+    def visit_RecursionError(self, obj):
+        raise VisitRecursionError
+
+    def visit_Object(self, obj):
+        """Called if no explicit visitor function exists for an Object."""
+        yield obj.__dict__
+        yield Visited(obj)
+
+    def visit_Generic(self, obj):
+        """Called if no explicit visitor function exists for an object."""
+        yield Visited(obj)
+
+    def visit_list(self, obj):
+        for item in obj:
+            yield item
+        yield Visited(obj)
+
+    visit_Array = visit_list
+
+    def visit_dict(self, obj):
+        for field, value in list(obj.items()):
+            if not field.startswith('_'):
+                yield value
+        yield Visited(obj)
+
+
+class NodeVisitor(Visitor):
+    pass
+
+
+class ReprVisitor(Visitor):
+    def visit(self, obj, indent=4, nl="\n", sp="", skip=()):
+        self.level = 0
+        if isinstance(indent, int):
+            indent = " " * indent
+        self.indent = indent
+        self.nl = nl
+        self.sp = sp
+        self.skip = skip
+        return super(ReprVisitor, self).visit(obj)
+
+    def visit_RecursionError(self, obj):
+        yield Visited("...")
+
+    def visit_Object(self, obj):
+        value_repr = yield obj.__dict__
+        yield Visited(value_repr)
+
+    def visit_Generic(self, obj):
+        yield Visited(repr(obj))
+
+    def visit_list(self, obj):
+        indent1 = self.indent * self.level
+        indent2 = indent1 + self.indent
+        self.level += 1
+        try:
+            items = []
+            for item in obj:
+                v = yield item
+                items.append(v)
+            if items:
+                value_repr = "[%s%s%s%s%s%s%s]" % (
+                    self.sp,
+                    self.nl,
+                    indent2,
+                    (",%s%s%s" % (self.nl, self.sp, indent2)).join(items),
+                    self.nl,
+                    indent1,
+                    self.sp,
+                )
+            else:
+                value_repr = "[]"
+        finally:
+            self.level -= 1
+
+        yield Visited(value_repr)
+
+    visit_Array = visit_list
+
+    def visit_dict(self, obj):
+        indent1 = self.indent * self.level
+        indent2 = indent1 + self.indent
+        self.level += 1
+        try:
+            items = []
+            for k, item in obj.items():
+                if item is not None and not k.startswith('_') and k not in self.skip:
+                    v = yield item
+                    items.append("%s: %s" % (k, v))
+            if items:
+                value_repr = "{%s%s%s%s%s%s%s}" % (
+                    self.sp,
+                    self.nl,
+                    indent2,
+                    (",%s%s%s" % (self.nl, self.sp, indent2)).join(items),
+                    self.nl,
+                    indent1,
+                    self.sp,
+                )
+            else:
+                value_repr = "{}"
+        finally:
+            self.level -= 1
+
+        yield Visited(value_repr)
+
+    if PY3:
+        def visit_str(self, obj):
+            value_repr = json.dumps(obj)
+            yield Visited(value_repr)
+    else:
+        def visit_unicode(self, obj):
+            value_repr = json.dumps(obj)
+            yield Visited(value_repr)
+
+    def visit_SourceLocation(self, obj):
+        old_indent, self.indent = self.indent, ""
+        old_nl, self.nl = self.nl, ""
+        old_sp, self.sp = self.sp, ""
+        try:
+            yield obj
+        finally:
+            self.indent = old_indent
+            self.nl = old_nl
+            self.sp = old_sp
+
+
+class ToDictVisitor(Visitor):
+    map = {
+        'isAsync': 'async',
+        'allowAwait': 'await',
+    }
+
+    def visit_RecursionError(self, obj):
+        yield Visited({
+            'error': "Infinite recursion detected...",
+        })
+
+    def visit_Object(self, obj):
+        obj = yield obj.__dict__
+        yield Visited(obj)
+
+    def visit_list(self, obj):
+        items = []
+        for item in obj:
+            v = yield item
+            items.append(v)
+        yield Visited(items)
+
+    visit_Array = visit_list
+
+    def visit_dict(self, obj):
+        items = []
+        for k, item in obj.items():
+            if item is not None and not k.startswith('_'):
+                v = yield item
+                k = unicode(k)
+                items.append((self.map.get(k, k), v))
+        yield Visited(dict(items))
+
+    def visit_SRE_Pattern(self, obj):
+        yield Visited({})
diff --git a/lib/esprima/xhtml_entities.py b/lib/esprima/xhtml_entities.py
new file mode 100644
index 00000000..7d487bbd
--- /dev/null
+++ b/lib/esprima/xhtml_entities.py
@@ -0,0 +1,281 @@
+# -*- coding: utf-8 -*-
+# Copyright JS Foundation and other contributors, https://js.foundation/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import unicode_literals
+
+# Generated by generate-xhtml-entities.js. DO NOT MODIFY!
+
+XHTMLEntities = {
+    'quot': "\u0022",
+    'amp': "\u0026",
+    'apos': "\u0027",
+    'gt': "\u003E",
+    'nbsp': "\u00A0",
+    'iexcl': "\u00A1",
+    'cent': "\u00A2",
+    'pound': "\u00A3",
+    'curren': "\u00A4",
+    'yen': "\u00A5",
+    'brvbar': "\u00A6",
+    'sect': "\u00A7",
+    'uml': "\u00A8",
+    'copy': "\u00A9",
+    'ordf': "\u00AA",
+    'laquo': "\u00AB",
+    'not': "\u00AC",
+    'shy': "\u00AD",
+    'reg': "\u00AE",
+    'macr': "\u00AF",
+    'deg': "\u00B0",
+    'plusmn': "\u00B1",
+    'sup2': "\u00B2",
+    'sup3': "\u00B3",
+    'acute': "\u00B4",
+    'micro': "\u00B5",
+    'para': "\u00B6",
+    'middot': "\u00B7",
+    'cedil': "\u00B8",
+    'sup1': "\u00B9",
+    'ordm': "\u00BA",
+    'raquo': "\u00BB",
+    'frac14': "\u00BC",
+    'frac12': "\u00BD",
+    'frac34': "\u00BE",
+    'iquest': "\u00BF",
+    'Agrave': "\u00C0",
+    'Aacute': "\u00C1",
+    'Acirc': "\u00C2",
+    'Atilde': "\u00C3",
+    'Auml': "\u00C4",
+    'Aring': "\u00C5",
+    'AElig': "\u00C6",
+    'Ccedil': "\u00C7",
+    'Egrave': "\u00C8",
+    'Eacute': "\u00C9",
+    'Ecirc': "\u00CA",
+    'Euml': "\u00CB",
+    'Igrave': "\u00CC",
+    'Iacute': "\u00CD",
+    'Icirc': "\u00CE",
+    'Iuml': "\u00CF",
+    'ETH': "\u00D0",
+    'Ntilde': "\u00D1",
+    'Ograve': "\u00D2",
+    'Oacute': "\u00D3",
+    'Ocirc': "\u00D4",
+    'Otilde': "\u00D5",
+    'Ouml': "\u00D6",
+    'times': "\u00D7",
+    'Oslash': "\u00D8",
+    'Ugrave': "\u00D9",
+    'Uacute': "\u00DA",
+    'Ucirc': "\u00DB",
+    'Uuml': "\u00DC",
+    'Yacute': "\u00DD",
+    'THORN': "\u00DE",
+    'szlig': "\u00DF",
+    'agrave': "\u00E0",
+    'aacute': "\u00E1",
+    'acirc': "\u00E2",
+    'atilde': "\u00E3",
+    'auml': "\u00E4",
+    'aring': "\u00E5",
+    'aelig': "\u00E6",
+    'ccedil': "\u00E7",
+    'egrave': "\u00E8",
+    'eacute': "\u00E9",
+    'ecirc': "\u00EA",
+    'euml': "\u00EB",
+    'igrave': "\u00EC",
+    'iacute': "\u00ED",
+    'icirc': "\u00EE",
+    'iuml': "\u00EF",
+    'eth': "\u00F0",
+    'ntilde': "\u00F1",
+    'ograve': "\u00F2",
+    'oacute': "\u00F3",
+    'ocirc': "\u00F4",
+    'otilde': "\u00F5",
+    'ouml': "\u00F6",
+    'divide': "\u00F7",
+    'oslash': "\u00F8",
+    'ugrave': "\u00F9",
+    'uacute': "\u00FA",
+    'ucirc': "\u00FB",
+    'uuml': "\u00FC",
+    'yacute': "\u00FD",
+    'thorn': "\u00FE",
+    'yuml': "\u00FF",
+    'OElig': "\u0152",
+    'oelig': "\u0153",
+    'Scaron': "\u0160",
+    'scaron': "\u0161",
+    'Yuml': "\u0178",
+    'fnof': "\u0192",
+    'circ': "\u02C6",
+    'tilde': "\u02DC",
+    'Alpha': "\u0391",
+    'Beta': "\u0392",
+    'Gamma': "\u0393",
+    'Delta': "\u0394",
+    'Epsilon': "\u0395",
+    'Zeta': "\u0396",
+    'Eta': "\u0397",
+    'Theta': "\u0398",
+    'Iota': "\u0399",
+    'Kappa': "\u039A",
+    'Lambda': "\u039B",
+    'Mu': "\u039C",
+    'Nu': "\u039D",
+    'Xi': "\u039E",
+    'Omicron': "\u039F",
+    'Pi': "\u03A0",
+    'Rho': "\u03A1",
+    'Sigma': "\u03A3",
+    'Tau': "\u03A4",
+    'Upsilon': "\u03A5",
+    'Phi': "\u03A6",
+    'Chi': "\u03A7",
+    'Psi': "\u03A8",
+    'Omega': "\u03A9",
+    'alpha': "\u03B1",
+    'beta': "\u03B2",
+    'gamma': "\u03B3",
+    'delta': "\u03B4",
+    'epsilon': "\u03B5",
+    'zeta': "\u03B6",
+    'eta': "\u03B7",
+    'theta': "\u03B8",
+    'iota': "\u03B9",
+    'kappa': "\u03BA",
+    'lambda': "\u03BB",
+    'mu': "\u03BC",
+    'nu': "\u03BD",
+    'xi': "\u03BE",
+    'omicron': "\u03BF",
+    'pi': "\u03C0",
+    'rho': "\u03C1",
+    'sigmaf': "\u03C2",
+    'sigma': "\u03C3",
+    'tau': "\u03C4",
+    'upsilon': "\u03C5",
+    'phi': "\u03C6",
+    'chi': "\u03C7",
+    'psi': "\u03C8",
+    'omega': "\u03C9",
+    'thetasym': "\u03D1",
+    'upsih': "\u03D2",
+    'piv': "\u03D6",
+    'ensp': "\u2002",
+    'emsp': "\u2003",
+    'thinsp': "\u2009",
+    'zwnj': "\u200C",
+    'zwj': "\u200D",
+    'lrm': "\u200E",
+    'rlm': "\u200F",
+    'ndash': "\u2013",
+    'mdash': "\u2014",
+    'lsquo': "\u2018",
+    'rsquo': "\u2019",
+    'sbquo': "\u201A",
+    'ldquo': "\u201C",
+    'rdquo': "\u201D",
+    'bdquo': "\u201E",
+    'dagger': "\u2020",
+    'Dagger': "\u2021",
+    'bull': "\u2022",
+    'hellip': "\u2026",
+    'permil': "\u2030",
+    'prime': "\u2032",
+    'Prime': "\u2033",
+    'lsaquo': "\u2039",
+    'rsaquo': "\u203A",
+    'oline': "\u203E",
+    'frasl': "\u2044",
+    'euro': "\u20AC",
+    'image': "\u2111",
+    'weierp': "\u2118",
+    'real': "\u211C",
+    'trade': "\u2122",
+    'alefsym': "\u2135",
+    'larr': "\u2190",
+    'uarr': "\u2191",
+    'rarr': "\u2192",
+    'darr': "\u2193",
+    'harr': "\u2194",
+    'crarr': "\u21B5",
+    'lArr': "\u21D0",
+    'uArr': "\u21D1",
+    'rArr': "\u21D2",
+    'dArr': "\u21D3",
+    'hArr': "\u21D4",
+    'forall': "\u2200",
+    'part': "\u2202",
+    'exist': "\u2203",
+    'empty': "\u2205",
+    'nabla': "\u2207",
+    'isin': "\u2208",
+    'notin': "\u2209",
+    'ni': "\u220B",
+    'prod': "\u220F",
+    'sum': "\u2211",
+    'minus': "\u2212",
+    'lowast': "\u2217",
+    'radic': "\u221A",
+    'prop': "\u221D",
+    'infin': "\u221E",
+    'ang': "\u2220",
+    'and': "\u2227",
+    'or': "\u2228",
+    'cap': "\u2229",
+    'cup': "\u222A",
+    'int': "\u222B",
+    'there4': "\u2234",
+    'sim': "\u223C",
+    'cong': "\u2245",
+    'asymp': "\u2248",
+    'ne': "\u2260",
+    'equiv': "\u2261",
+    'le': "\u2264",
+    'ge': "\u2265",
+    'sub': "\u2282",
+    'sup': "\u2283",
+    'nsub': "\u2284",
+    'sube': "\u2286",
+    'supe': "\u2287",
+    'oplus': "\u2295",
+    'otimes': "\u2297",
+    'perp': "\u22A5",
+    'sdot': "\u22C5",
+    'lceil': "\u2308",
+    'rceil': "\u2309",
+    'lfloor': "\u230A",
+    'rfloor': "\u230B",
+    'loz': "\u25CA",
+    'spades': "\u2660",
+    'clubs': "\u2663",
+    'hearts': "\u2665",
+    'diams': "\u2666",
+    'lang': "\u27E8",
+    'rang': "\u27E9",
+}
diff --git a/lib/librecaptcha/__init__.py b/lib/librecaptcha/__init__.py
new file mode 100644
index 00000000..8c224713
--- /dev/null
+++ b/lib/librecaptcha/__init__.py
@@ -0,0 +1,23 @@
+# Copyright (C) 2017-2018 taylor.fish <contact@taylor.fish>
+#
+# This file is part of librecaptcha.
+#
+# librecaptcha is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# librecaptcha is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with librecaptcha.  If not, see <https://www.gnu.org/licenses/>.
+
+# flake8: noqa
+# from . import librecaptcha, extract_strings, user_agents
+# from .recaptcha import ReCaptcha
+# from .librecaptcha import __version__, get_token, has_gui
+# from .user_agents import USER_AGENTS, random_user_agent
+# from .__main__ import main
diff --git a/lib/librecaptcha/__main__.py b/lib/librecaptcha/__main__.py
new file mode 100644
index 00000000..4d24eabf
--- /dev/null
+++ b/lib/librecaptcha/__main__.py
@@ -0,0 +1,280 @@
+# Copyright (C) 2017, 2019 taylor.fish <contact@taylor.fish>
+#
+# This file is part of librecaptcha.
+#
+# librecaptcha is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# librecaptcha is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with librecaptcha.  If not, see <https://www.gnu.org/licenses/>.
+
+from . import errors
+from .errors import UserError, UserExit
+from .librecaptcha import get_token, __version__
+from .user_agents import random_user_agent
+import os
+import re
+import sys
+
+
+def get_cmd():
+    if not sys.argv:
+        return "librecaptcha"
+    if sys.argv[0].startswith("./"):
+        return sys.argv[0]
+    return os.path.basename(sys.argv[0])
+
+
+CMD = get_cmd()
+USAGE = """\
+Usage:
+  {0} [options] [--] <api-key> <site-url> [<user-agent>]
+  {0} -h | --help | --version
+
+Arguments:
+     <api-key>  The reCAPTCHA API key to use. This is usually the value of the
+                "data-sitekey" HTML attribute.
+
+    <site-url>  The URL of the site that contains the reCAPTCHA challenge.
+                Should start with http:// or https://. Everything after the
+                hostname is optional. For example: https://example.com
+
+  <user-agent>  A user-agent string. The client that will use the obtained
+                reCAPTCHA token should have this user-agent string. If not
+                provided, a random user-agent string will be chosen and shown.
+
+Options:
+   -g --gui  Use the GTK 3 GUI (as opposed to the CLI).
+    --debug  Show debugging information while running.
+  -h --help  Show this help message.
+  --version  Show the program version.
+""".format(CMD)
+
+
+def usage(file=sys.stdout):
+    print(USAGE, end="", file=file)
+
+
+def usage_error(exit=True):
+    usage(sys.stderr)
+    if exit:
+        sys.exit(1)
+
+
+class ParsedArgs:
+    def __init__(self):
+        self.parse_error = None
+        self.api_key = None
+        self.site_url = None
+        self.user_agent = None
+        self.gui = False
+        self.debug = False
+        self.help = False
+        self.version = False
+
+
+class ArgParser:
+    def __init__(self, args):
+        self.args = args
+        self.index = 0
+        self.positional_index = 0
+        self.parsed = ParsedArgs()
+        self.options_done = False
+        self.end_early = False
+
+    @property
+    def arg(self):
+        try:
+            return self.args[self.index]
+        except IndexError:
+            return None
+
+    @property
+    def done(self):
+        return self.end_early or self.index >= len(self.args)
+
+    def advance(self):
+        self.index += 1
+
+    def error(self, message):
+        self.parsed.parse_error = message
+        self.end_early = True
+
+    def parse_long_option(self, arg):
+        body = arg[len("--"):]
+        if body == "debug":
+            self.parsed.debug = True
+            return
+        if body == "help":
+            self.parsed.help = True
+            self.end_early = True
+            return
+        if body == "version":
+            self.parsed.version = True
+            self.end_early = True
+            return
+        if body == "gui":
+            self.parsed.gui = True
+            return
+        self.error("Unrecognized option: {}".format(arg))
+
+    def parse_short_option_char(self, char):
+        if char == "h":
+            self.parsed.help = True
+            self.end_early = True
+            return
+        if char == "g":
+            self.parsed.gui = True
+            return
+        self.error("Unrecognized option: -{}".format(char))
+
+    def parse_short_option(self, arg):
+        body = arg[len("-"):]
+        for char in body:
+            self.parse_short_option_char(char)
+
+    def try_parse_option(self):
+        arg = self.arg
+        if arg == "--":
+            self.options_done = True
+            return True
+        if re.match(r"--[^-]", arg):
+            self.parse_long_option(arg)
+            return True
+        if re.match(r"-[^-]", arg):
+            self.parse_short_option(arg)
+            return True
+        return False
+
+    def parse_positional(self):
+        arg = self.arg
+        if self.positional_index == 0:
+            self.parsed.api_key = arg
+            return
+        if self.positional_index == 1:
+            self.parsed.site_url = arg
+            return
+        if self.positional_index == 2:
+            self.parsed.user_agent = arg
+            return
+        self.error("Unexpected positional argument: {}".format(arg))
+
+    def parse_single(self):
+        if not self.options_done and self.try_parse_option():
+            return
+        self.parse_positional()
+        self.positional_index += 1
+
+    def handle_end(self):
+        if self.end_early:
+            return
+        if self.positional_index < 1:
+            self.error("Missing positional argument: <api-key>")
+            return
+        if self.positional_index < 2:
+            self.error("Missing positional argument: <site-url>")
+            return
+
+    def parse(self):
+        while not self.done:
+            self.parse_single()
+            self.advance()
+        self.handle_end()
+        return self.parsed
+
+
+USER_ERRORS = (
+    errors.GtkImportError,
+    errors.SiteUrlParseError,
+    errors.UnsupportedChallengeError,
+)
+
+GOT_TOKEN_MSG = """\
+Received token. This token should usually be submitted with the form as the
+value of the "g-recaptcha-response" field.
+"""
+
+
+def run(args: ParsedArgs):
+    random_ua = False
+    user_agent = args.user_agent
+    if args.user_agent is None:
+        random_ua = True
+        user_agent = random_user_agent()
+    if args.debug:
+        print("User-agent string: {}".format(user_agent), file=sys.stderr)
+
+    try:
+        uvtoken = get_token(
+            api_key=args.api_key,
+            site_url=args.site_url,
+            user_agent=user_agent,
+            gui=args.gui,
+            debug=args.debug,
+        )
+    except USER_ERRORS as e:
+        raise UserError(str(e)) from e
+
+    print(GOT_TOKEN_MSG)
+    if random_ua:
+        print("Note: The following user-agent string was used:")
+        print(user_agent)
+        print()
+    print("Token:")
+    print(uvtoken)
+
+
+UNEXPECTED_ERR_MSG = """\
+An unexpected error occurred. The exception traceback is shown below:
+"""
+
+
+def run_or_exit(args: ParsedArgs):
+    if args.debug:
+        return run(args)
+    try:
+        return run(args)
+    except UserExit:
+        sys.exit(2)
+    except UserError as e:
+        if e.show_by_default:
+            print(e.message, file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print(file=sys.stderr)
+        sys.exit(2)
+    except Exception:
+        print(UNEXPECTED_ERR_MSG, file=sys.stderr)
+        raise
+
+
+def main():
+    args = sys.argv[1:]
+    parsed = ArgParser(args).parse()
+    error = parsed.parse_error
+
+    if error is not None:
+        print(error, file=sys.stderr)
+        print("For usage information, run: {} --help".format(CMD),
+              file=sys.stderr)
+        sys.exit(1)
+
+    if parsed.help:
+        usage()
+        return
+
+    if parsed.version:
+        print(__version__)
+        return
+    run_or_exit(parsed)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/lib/librecaptcha/cli.py b/lib/librecaptcha/cli.py
new file mode 100644
index 00000000..c6e9a79e
--- /dev/null
+++ b/lib/librecaptcha/cli.py
@@ -0,0 +1,317 @@
+# Copyright (C) 2017, 2019, 2021 taylor.fish <contact@taylor.fish>
+#
+# This file is part of librecaptcha.
+#
+# librecaptcha is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# librecaptcha is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with librecaptcha.  If not, see <https://www.gnu.org/licenses/>.
+
+from .recaptcha import ChallengeGoal, GridDimensions, ImageGridChallenge
+from .recaptcha import DynamicSolver, MultiCaptchaSolver, Solver
+from .recaptcha import ReCaptcha, Solution
+from .typing import List
+from PIL import Image, ImageDraw, ImageFont
+
+from threading import Thread
+from queue import Queue
+import io
+import os
+import random
+import readline  # noqa: F401
+import subprocess
+import sys
+import time
+
+TYPEFACES = [
+    "FreeSans",
+    "LiberationSans-Regular",
+    "DejaVuSans",
+    "Arial",
+    "arial",
+]
+
+
+def get_font(size: int) -> ImageFont.ImageFont:
+    for typeface in TYPEFACES:
+        try:
+            return ImageFont.truetype(typeface, size=size)
+        except OSError:
+            pass
+    return ImageFont.load_default()
+
+
+FONT_SIZE = 16
+FONT = get_font(FONT_SIZE)
+
+
+def read_indices(prompt: str, max_index: int) -> List[int]:
+    while True:
+        line = input(prompt)
+        try:
+            indices = [int(i) - 1 for i in line.split()]
+        except ValueError:
+            print("Invalid input.")
+            continue
+        if all(0 <= i < max_index for i in indices):
+            return indices
+        print("Numbers out of bounds.")
+
+
+def draw_lines(image: Image.Image, dimensions: GridDimensions):
+    draw = ImageDraw.Draw(image)
+
+    def line(p1, p2):
+        draw.line([p1, p2], fill=(255, 255, 255), width=2)
+
+    for i in range(1, dimensions.rows):
+        y = image.height * i // dimensions.rows - 1
+        line((0, y), (image.width, y))
+
+    for i in range(1, dimensions.columns):
+        x = image.width * i // dimensions.columns - 1
+        line((x, 0), (x, image.height))
+
+
+def draw_indices(image: Image.Image, dimensions: GridDimensions):
+    draw = ImageDraw.Draw(image, "RGBA")
+    for i in range(dimensions.rows * dimensions.columns):
+        row, column = divmod(i, dimensions.columns)
+        corner = (
+            image.width * column // dimensions.columns,
+            image.height * (row + 1) // dimensions.rows,
+        )
+        text_loc = (
+            corner[0] + round(FONT_SIZE / 2),
+            corner[1] - round(FONT_SIZE * 1.5),
+        )
+
+        text = str(i + 1)
+        text_size = FONT.getsize(text)
+        draw.rectangle([
+            (text_loc[0] - round(FONT_SIZE / 10), text_loc[1]), (
+                text_loc[0] + text_size[0] + round(FONT_SIZE / 10),
+                text_loc[1] + text_size[1] + round(FONT_SIZE / 10),
+            ),
+        ], fill=(0, 0, 0, 128))
+        draw.text(text_loc, str(i + 1), fill=(255, 255, 255), font=FONT)
+
+
+def print_temporary(string: str, file=sys.stdout):
+    end = "" if file.isatty() else "\n"
+    print(string, file=file, end=end, flush=True)
+
+
+def clear_temporary(file=sys.stdout):
+    if not file.isatty():
+        return
+    print("\r\x1b[K", file=file, end="", flush=True)
+
+
+HAS_DISPLAY_CMD = (os.name == "posix")
+
+
+def run_display_cmd():
+    return subprocess.Popen(
+        ["display", "-"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+def try_display_cmd(image: Image.Image):
+    global HAS_DISPLAY_CMD
+    if not HAS_DISPLAY_CMD:
+        return None
+
+    img_buffer = io.BytesIO()
+    image.save(img_buffer, "png")
+    img_bytes = img_buffer.getvalue()
+
+    try:
+        proc = run_display_cmd()
+    except FileNotFoundError:
+        HAS_DISPLAY_CMD = False
+        return None
+
+    proc.stdin.write(img_bytes)
+    proc.stdin.close()
+    return proc
+
+
+class SolverCli:
+    def __init__(self, cli: "Cli", solver: Solver):
+        self.cli = cli
+        self.solver = solver
+        self.__image_procs = []
+
+    def show_image(self, image):
+        proc = try_display_cmd(image)
+        if proc is None:
+            image.show()
+        else:
+            self.__image_procs.append(proc)
+
+    def hide_images(self):
+        for proc in self.__image_procs:
+            proc.terminate()
+        self.__image_procs.clear()
+
+    def run(self):
+        self.solver.run()
+
+
+class DynamicCli(SolverCli):
+    def __init__(self, cli: "Cli", solver: DynamicSolver):
+        super().__init__(cli, solver)
+        self.image_open = False
+        self.image_queue = Queue()
+        self.num_pending = 0
+
+    def run(self):
+        challenge = self.solver.get_challenge()
+        self.cli.handle_challenge(challenge)
+
+        image = challenge.image
+        num_rows = challenge.dimensions.rows
+        num_columns = challenge.dimensions.columns
+        num_tiles = challenge.dimensions.count
+        draw_indices(image, challenge.dimensions)
+        self.show_image(image)
+
+        print("Take a look at the grid of tiles that just appeared. ", end="")
+        print("({} rows, {} columns)".format(num_rows, num_columns))
+        print("Which tiles should be selected?")
+        print("(Top-left is 1; bottom-right is {}.)".format(num_tiles))
+        indices = read_indices(
+            "Enter numbers separated by spaces: ",
+            num_tiles,
+        )
+        print()
+        self.hide_images()
+        self.select_initial(indices)
+        self.new_tile_loop()
+        return self.solver.finish()
+
+    def new_tile_loop(self):
+        while self.num_pending > 0:
+            print_temporary("Waiting for next image...")
+            index, image = self.image_queue.get()
+            clear_temporary()
+            self.num_pending -= 1
+            self.show_image(image)
+
+            print("Take a look at the image that just appeared.")
+            accept = input(
+                "Should this image be selected? [y/N] ",
+            )[:1].lower() == "y"
+            print()
+
+            self.hide_images()
+            if accept:
+                self.select_tile(index)
+
+    def select_initial(self, indices):
+        print_temporary("Selecting images...")
+        for i, index in enumerate(indices):
+            if i > 0:
+                # Avoid sending initial requests simultaneously.
+                time.sleep(random.uniform(0.5, 1))
+            self.select_tile(index)
+        clear_temporary()
+
+    def select_tile(self, index: int):
+        self.num_pending += 1
+        tile = self.solver.select_tile(index)
+
+        def add_to_queue():
+            self.image_queue.put((index, tile.image))
+
+        def target():
+            time.sleep(tile.delay)
+            add_to_queue()
+
+        if tile.delay > 0:
+            Thread(target=target, daemon=True).start()
+        else:
+            target()
+
+
+class MultiCaptchaCli(SolverCli):
+    def __init__(self, cli: "Cli", solver: MultiCaptchaSolver):
+        super().__init__(cli, solver)
+
+    def run(self) -> Solution:
+        result = self.solver.first_challenge()
+        while not isinstance(result, Solution):
+            if not isinstance(result, ImageGridChallenge):
+                raise TypeError("Unexpected type: {}".format(type(result)))
+            indices = self.handle_challenge(result)
+            result = self.solver.select_indices(indices)
+        return result
+
+    def handle_challenge(self, challenge: ImageGridChallenge) -> List[int]:
+        self.cli.handle_challenge(challenge)
+        num_rows = challenge.dimensions.rows
+        num_columns = challenge.dimensions.columns
+        num_tiles = challenge.dimensions.count
+
+        image = challenge.image
+        draw_lines(image, challenge.dimensions)
+        draw_indices(image, challenge.dimensions)
+        self.show_image(image)
+
+        print("Take a look at the grid of tiles that just appeared. ", end="")
+        print("({} rows, {} columns)".format(num_rows, num_columns))
+        print("Which tiles should be selected?")
+        print("(Top-left is 1; bottom-right is {}.)".format(num_tiles))
+        indices = read_indices(
+            "Enter numbers separated by spaces: ",
+            num_tiles,
+        )
+        print()
+        self.hide_images()
+        return indices
+
+
+class Cli:
+    def __init__(self, rc: ReCaptcha):
+        self.rc = rc
+        self._first = True
+
+    def run(self) -> str:
+        result = self.rc.first_solver()
+        while not isinstance(result, str):
+            solution = self.run_solver(result)
+            result = self.rc.send_solution(solution)
+        return result
+
+    def run_solver(self, solver: Solver) -> Solution:
+        return {
+            DynamicSolver: DynamicCli,
+            MultiCaptchaSolver: MultiCaptchaCli,
+        }[type(solver)](self, solver).run()
+
+    def show_goal(self, goal: ChallengeGoal):
+        plain = goal.plain
+        if plain:
+            print("CHALLENGE OBJECTIVE: {}".format(plain))
+            return
+        print("WARNING: Could not determine challenge objective.")
+        print("Challenge information: {}".format(goal.fallback))
+
+    def handle_challenge(self, challenge: ImageGridChallenge):
+        if not self._first:
+            print("You must solve another challenge.")
+            print()
+        self._first = False
+        self.show_goal(challenge.goal)
diff --git a/lib/librecaptcha/errors.py b/lib/librecaptcha/errors.py
new file mode 100644
index 00000000..514766d7
--- /dev/null
+++ b/lib/librecaptcha/errors.py
@@ -0,0 +1,100 @@
+# Copyright (C) 2019, 2021 taylor.fish <contact@taylor.fish>
+#
+# This file is part of librecaptcha.
+#
+# librecaptcha is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# librecaptcha is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with librecaptcha.  If not, see <https://www.gnu.org/licenses/>.
+
+GUI_MISSING_MESSAGE = """\
+Error: Could not load the GUI. Is PyGObject installed?
+Try (re)installing librecaptcha[gtk] with pip.
+For more details, add the --debug option.
+"""[:-1]
+
+CHALLENGE_BLOCKED_MESSAGE = """\
+Error: Unsupported challenge type: {}
+Requests are most likely being blocked; see the previously displayed messages.
+"""[:-1]
+
+UNKNOWN_CHALLENGE_MESSAGE = """\
+Error: Unsupported challenge type: {}
+See the previously displayed messages for more information.
+"""[:-1]
+
+
+class UserError(Exception):
+    """A user-facing exception for an expected error condition (e.g., bad
+    user-supplied data). When librecaptcha is run as a program, exceptions of
+    this type are shown without a traceback unless --debug is passed.
+    """
+    def __init__(self, message):
+        super().__init__(message)
+
+    @property
+    def message(self):
+        return self.args[0]
+
+    @property
+    def show_by_default(self) -> bool:
+        """Whether the exception message should be shown to the user by
+        default. Certain exception types may want to set this to ``False`` if a
+        detailed message has already been displayed to the user.
+        """
+        return True
+
+
+class UserExit(UserError):
+    """When librecaptcha is run as a program, throwing this exception causes
+    the program to terminate. The exception message is not shown by default.
+    """
+    def __init__(self, message="Program terminated."):
+        super().__init__(message)
+
+
+class GtkImportError(ImportError):
+    def __str__(self) -> str:
+        return GUI_MISSING_MESSAGE
+
+
+class SiteUrlParseError(ValueError):
+    pass
+
+
+class UnsupportedChallengeError(Exception):
+    def __init__(self, challenge_type: str):
+        self.challenge_type = challenge_type
+
+    def __str__(self):
+        return "Error: Unsupported challenge type: {}".format(
+            self.challenge_type,
+        )
+
+
+class ChallengeBlockedError(UnsupportedChallengeError):
+    def __str__(self) -> str:
+        return CHALLENGE_BLOCKED_MESSAGE.format(self.challenge_type)
+
+    @property
+    def show_by_default(self) -> bool:
+        # A detailed message is already shown in `librecaptcha.get_token()`.
+        return False
+
+
+class UnknownChallengeError(UnsupportedChallengeError):
+    def __str__(self) -> str:
+        return UNKNOWN_CHALLENGE_MESSAGE.format(self.challenge_type)
+
+    @property
+    def show_by_default(self) -> bool:
+        # A detailed message is already shown in `librecaptcha.get_token()`.
+        return False
diff --git a/lib/librecaptcha/extract_strings.py b/lib/librecaptcha/extract_strings.py
new file mode 100644
index 00000000..ccfe0657
--- /dev/null
+++ b/lib/librecaptcha/extract_strings.py
@@ -0,0 +1,113 @@
+# Copyright (C) 2017, 2019, 2021 taylor.fish <contact@taylor.fish>
+#
+# This file is part of librecaptcha.
+#
+# librecaptcha is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# librecaptcha is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with librecaptcha.  If not, see <https://www.gnu.org/licenses/>.
+
+from .typing import List
+import requests
+
+import json
+import os
+import os.path
+import re
+import sys
+
+SHOW_WARNINGS = False
+
+
+def load_javascript(url: str, user_agent: str) -> str:
+    print("Downloading <{}>...".format(url), file=sys.stderr)
+    r = requests.get(url, headers={
+        "User-Agent": user_agent,
+    })
+    return r.text
+
+
+def extract_strings_slimit(javascript: str) -> List[str]:
+    from slimit.parser import Parser
+    from slimit import ast
+
+    if SHOW_WARNINGS:
+        parser = Parser()
+    else:
+        # File descriptor hackiness to silence warnings
+        null_fd = os.open(os.devnull, os.O_RDWR)
+        old_fd = os.dup(2)
+        try:
+            os.dup2(null_fd, 2)
+            parser = Parser()
+        finally:
+            os.dup2(old_fd, 2)
+            os.close(null_fd)
+            os.close(old_fd)
+
+    # Hack to work around https://github.com/rspivak/slimit/issues/52
+    KEYWORDS = r"(?:catch|delete|return|throw)"
+    javascript = re.sub(rf"(\.\s*{KEYWORDS})\b", r"\1_", javascript)
+    javascript = re.sub(rf"\b({KEYWORDS})(\s*:)", r"'\1'\2", javascript)
+    parsed = parser.parse(javascript)
+    strings = []
+
+    def add_strings(tree, strings):
+        if tree is None:
+            return
+        if not isinstance(tree, (ast.Node, list, tuple)):
+            raise TypeError("Unexpected item: {!r}".format(tree))
+        if isinstance(tree, ast.String):
+            strings.append(tree.value[1:-1])
+
+        children = tree
+        if isinstance(tree, ast.Node):
+            children = tree.children()
+        for child in children:
+            add_strings(child, strings)
+
+    add_strings(parsed, strings)
+    return strings
+
+
+def extract_strings(javascript: str) -> List[str]:
+    print("Extracting strings...", file=sys.stderr)
+    try:
+        import esprima
+    except ImportError:
+        return extract_strings_slimit(javascript)
+
+    strings = []
+
+    def handle_node(node, *args):
+        if node.type == "Literal" and isinstance(node.value, str):
+            strings.append(node.value)
+
+    esprima.parseScript(javascript, delegate=handle_node)
+    return strings
+
+
+def extract_and_save(
+    url: str,
+    path: str,
+    version: str,
+    rc_version: str,
+    user_agent: str,
+) -> List[str]:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w") as f:
+        print("{}/{}".format(version, rc_version), file=f)
+        js = load_javascript(url, user_agent)
+        strings = extract_strings(js)
+        strings_json = json.dumps(strings)
+        print('Saving strings to "{}"...'.format(path), file=sys.stderr)
+        f.write(strings_json)
+        return strings
diff --git a/lib/librecaptcha/gui.py b/lib/librecaptcha/gui.py
new file mode 100644
index 00000000..47b8181e
--- /dev/null
+++ b/lib/librecaptcha/gui.py
@@ -0,0 +1,787 @@
+# Copyright (C) 2019 cyclopsian
+# Copyright (C) 2019, 2021 taylor.fish <contact@taylor.fish>
+#
+# This file is part of librecaptcha.
+#
+# librecaptcha is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# librecaptcha is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with librecaptcha.  If not, see <https://www.gnu.org/licenses/>.
+
+from .errors import UserExit, GtkImportError
+from .recaptcha import ChallengeGoal, GridDimensions, ImageGridChallenge
+from .recaptcha import DynamicSolver, MultiCaptchaSolver, Solver
+from .recaptcha import ReCaptcha, Solution
+from .typing import Callable, Iterable, List
+from PIL import Image
+
+from collections import namedtuple
+from typing import Any, Optional, Union
+import html
+import re
+import sys
+import threading
+
+try:
+    import gi
+    gi.require_version("Gtk", "3.0")
+    from gi.repository import Gtk, Gdk, GdkPixbuf, GLib
+except ImportError as e:
+    raise GtkImportError from e
+
+
+def tiles_from_image(
+    image: Image.Image,
+    dimensions: GridDimensions,
+) -> Iterable[Image.Image]:
+    tile_width = image.width // dimensions.columns
+    tile_height = image.height // dimensions.rows
+    for row in range(0, dimensions.rows):
+        for column in range(0, dimensions.columns):
+            left = tile_width * column
+            top = tile_height * row
+            right = left + tile_width
+            bottom = top + tile_height
+            yield image.crop((left, top, right, bottom))
+
+
+def image_to_gdk_pixbuf(image: Image.Image):
+    width, height = image.size
+    image_bytes = GLib.Bytes(image.tobytes())
+    has_alpha = (image.mode == "RGBA")
+    bpp = 4 if has_alpha else 3
+    return GdkPixbuf.Pixbuf.new_from_bytes(
+        image_bytes, GdkPixbuf.Colorspace.RGB,
+        has_alpha, 8, width, height, width * bpp,
+    )
+
+
+CSS = """\
+grid {
+    margin-top: 1px;
+    margin-left: 1px;
+}
+
+.challenge-button {
+    margin: 0;
+    padding: 0;
+    border-radius: 0;
+    box-shadow: none;
+    -gtk-icon-shadow: none;
+    border-width: 1px;
+    margin-top: -1px;
+    margin-left: -1px;
+}
+
+.challenge-check, .challenge-header {
+    margin-left: 1px;
+    margin-top: 1px;
+    color: @theme_selected_fg_color;
+    background-image: linear-gradient(
+        @theme_selected_bg_color,
+        @theme_selected_bg_color
+    );
+}
+
+.challenge-header {
+    padding: 12px;
+}
+
+.challenge-check {
+    border-radius: 50%;
+}
+"""
+
+
+def load_css():
+    global CSS
+    if CSS is None:
+        return
+
+    css_provider = Gtk.CssProvider.new()
+    css_provider.load_from_data(CSS.encode())
+    CSS = None
+    Gtk.StyleContext.add_provider_for_screen(
+        Gdk.Screen.get_default(), css_provider,
+        Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
+    )
+
+
+Dispatch = Callable[[Any], None]
+
+
+class DynamicTile:
+    def __init__(self, dispatch: Dispatch):
+        self.dispatch = dispatch
+        self.pres: Optional["DynamicTilePres"] = None
+        self.box = Gtk.Box.new(Gtk.Orientation.VERTICAL, 0)
+        self.inner = None
+        self.inner_size = (0, 0)  # (width, height)
+
+    @property
+    def widget(self):
+        return self.box
+
+    def update(self, pres: "DynamicTilePres"):
+        if pres.same(self.pres):
+            return
+        if self.inner is not None:
+            self.box.remove(self.inner)
+        self.make_inner(pres.image)
+        self.box.show_all()
+        self.pres = pres
+
+    def make_inner(self, image: Image.Image):
+        if image is None:
+            self.make_spinner()
+            return
+
+        button = Gtk.Button.new()
+        button.get_style_context().add_class("challenge-button")
+        button.add(Gtk.Image.new_from_pixbuf(image_to_gdk_pixbuf(image)))
+        button.connect("clicked", lambda _: self.pres.on_click(self.dispatch))
+
+        def on_size_allocate(obj, size):
+            self.inner_size = (size.width, size.height)
+        button.connect("size-allocate", on_size_allocate)
+        self.set_inner(button)
+
+    def make_spinner(self):
+        width, height = (max(n, 32) for n in self.inner_size)
+        spinner = Gtk.Spinner.new()
+        spinner.set_size_request(32, 32)
+        left = (width - 32) // 2
+        top = (height - 32) // 2
+        spinner.set_margin_top(top)
+        spinner.set_margin_start(left)
+        spinner.set_margin_bottom(height - top - 32)
+        spinner.set_margin_end(width - left - 32)
+        self.set_inner(spinner)
+        spinner.start()
+        return spinner
+
+    def set_inner(self, widget):
+        self.inner = widget
+        self.box.add(self.inner)
+
+
+class MultiCaptchaTile:
+    def __init__(self, dispatch: Dispatch):
+        self.dispatch = dispatch
+        self.pres: Optional["MultiCaptchaTilePres"] = None
+
+        self.image = Gtk.Image.new()
+        self.check = self.make_check()
+        self.fixed = Gtk.Fixed.new()
+        self.fixed.put(self.image, 0, 0)
+        self.fixed.put(self.check, 0, 0)
+
+        self.button = Gtk.ToggleButton.new()
+        self.button.get_style_context().add_class("challenge-button")
+        self.button.add(self.fixed)
+        self.toggle_id = None
+
+        self.pixbuf = None
+        self.small_pixbuf = None
+        self.button.show_all()
+
+    @property
+    def widget(self):
+        return self.button
+
+    def update(self, pres: "MultiCaptchaTilePres"):
+        if pres.same(self.pres):
+            return None
+
+        if self.pres is None:
+            def on_toggle(obj):
+                self._set_active(not obj.get_active())
+                self.pres.on_click(self.dispatch)
+            self.toggle_id = self.button.connect("toggled", on_toggle)
+
+        if (self.pres and self.pres.image) is not pres.image:
+            self.pixbuf = image_to_gdk_pixbuf(pres.image)
+            width = self.pixbuf.get_width()
+            height = self.pixbuf.get_height()
+            self.image.set_size_request(width, height)
+            self.small_pixbuf = self.pixbuf.scale_simple(
+                width * 0.9, height * 0.9, GdkPixbuf.InterpType.BILINEAR,
+            )
+
+        if pres.selected:
+            self.check.show()
+            self.image.set_from_pixbuf(self.small_pixbuf)
+        else:
+            self.check.hide()
+            self.image.set_from_pixbuf(self.pixbuf)
+
+        self._set_active(pres.selected)
+        self.pres = pres
+
+    def make_check(self):
+        check = Gtk.Image.new_from_icon_name(
+            "object-select-symbolic", Gtk.IconSize.DND,
+        )
+        check.set_pixel_size(24)
+        check.set_no_show_all(True)
+        check.get_style_context().add_class("challenge-check")
+        return check
+
+    def _set_active(self, selected: bool):
+        self.button.handler_block(self.toggle_id)
+        self.button.set_active(selected)
+        self.button.handler_unblock(self.toggle_id)
+
+
+class ChallengeTile:
+    def __init__(self, dispatch: Dispatch):
+        self.dispatch = dispatch
+        self.box = Gtk.Box.new(Gtk.Orientation.VERTICAL, 0)
+        self.tile = None
+
+    @property
+    def widget(self):
+        return self.box
+
+    def update(self, pres: "TilePres"):
+        tile_type = {
+            DynamicTilePres: DynamicTile,
+            MultiCaptchaTilePres: MultiCaptchaTile,
+        }[type(pres)]
+
+        if type(self.tile) is not tile_type:
+            if self.tile is not None:
+                self.box.remove(self.tile.widget)
+            self.tile = tile_type(self.dispatch)
+            self.box.add(self.tile.widget)
+            self.box.show_all()
+        self.tile.update(pres)
+
+
+class ImageGridChallengeDialog:
+    def __init__(self, dispatch: Dispatch):
+        self.dispatch = dispatch
+        self.pres: Optional["ImageGridChallengePres"] = None
+
+        self.dialog = Gtk.Dialog.new()
+        self.dialog.set_resizable(False)
+        self.dialog.set_title("librecaptcha")
+        self.dialog.set_icon_name("view-refresh-symbolic")
+
+        self.verify = self.dialog.add_button("", Gtk.ResponseType.OK)
+        self.verify.get_style_context().add_class("suggested-action")
+
+        def on_click(obj):
+            # This will get reset in `self.update()`, but it prevents multiple
+            # clicks from taking effect if the UI temporarily pauses.
+            self.verify.set_sensitive(False)
+        self.verify.connect("clicked", on_click)
+
+        self.header = Gtk.Label.new("")
+        self.header.set_xalign(0)
+        self.header.get_style_context().add_class("challenge-header")
+
+        self.content = self.dialog.get_content_area()
+        self.content.set_spacing(6)
+        for dir in ["start", "end", "top", "bottom"]:
+            getattr(self.content, "set_margin_" + dir)(6)
+        self.content.pack_start(self.header, False, False, 0)
+
+        self.grid = None
+        self.tiles = []
+        self.dialog.show_all()
+
+    def run(self) -> bool:
+        """Returns ``True`` on success, or ``False`` if the dialog was closed
+        without activating the default button.
+        """
+        return self.dialog.run() == Gtk.ResponseType.OK
+
+    def destroy(self):
+        self.dialog.destroy()
+
+    def update(self, pres: "ImageGridChallengePres"):
+        if pres.same(self.pres):
+            return
+
+        dimensions = pres.dimensions
+        if dimensions != (self.pres and self.pres.dimensions):
+            if self.grid is not None:
+                self.content.remove(self.grid)
+            self.grid = self.make_grid(dimensions)
+            self.grid.show_all()
+            self.content.pack_start(self.grid, True, True, 0)
+
+        if not pres.same_goal(self.pres):
+            self.header.set_markup(pres.goal)
+
+        if not pres.same_verify_label(self.pres):
+            self.verify.set_label(pres.verify_label)
+        self.verify.set_sensitive(pres.is_verify_enabled)
+
+        for tile, tile_pres in zip(self.tiles, pres.tiles):
+            tile.update(tile_pres)
+        self.pres = pres
+
+    def make_grid(self, dimensions: GridDimensions):
+        grid = Gtk.Grid.new()
+        self.tiles = []
+        for row in range(0, dimensions.rows):
+            for column in range(0, dimensions.columns):
+                tile = ChallengeTile(self.dispatch)
+                grid.attach(tile.widget, column, row, 1, 1)
+                self.tiles.append(tile)
+        return grid
+
+
+def format_goal(goal: ChallengeGoal) -> str:
+    if goal.raw is None:
+        return goal.fallback
+    match = re.fullmatch(r"(.*)<strong>(.*)</strong>(.*)", goal.raw)
+    if not match:
+        return html.escape(goal.raw)
+    groups = match.groups()
+    return '{}<span size="xx-large">{}</span>{}'.format(
+        *map(html.escape, [
+            groups[0] and groups[0] + "\n",
+            groups[1],
+            groups[2],
+        ]),
+    )
+
+
+def format_goal_with_note(goal: ChallengeGoal, note: str) -> str:
+    return "{}\n{}".format(format_goal(goal), note)
+
+
+# Messages
+Start = namedtuple("Start", [])
+FinishChallenge = namedtuple("FinishChallenge", [])
+SelectTile = namedtuple("SelectTile", [
+    "index",  # int
+])
+ReplaceTile = namedtuple("ReplaceTile", [
+    "index",  # int
+    "image",  # Image.Image
+])
+SetState = namedtuple("SetState", [
+    "state",  # State
+])
+SetNextChallenge = namedtuple("NextChallenge", [
+    "challenge",  # ImageGridChallenge
+])
+
+
+def gtk_run(f: Callable[[], Any]):
+    old_excepthook = sys.excepthook
+
+    def excepthook(*args, **kwargs):
+        old_excepthook(*args, **kwargs)
+        sys.exit(1)
+
+    try:
+        sys.excepthook = excepthook
+        return f()
+    finally:
+        sys.excepthook = old_excepthook
+
+
+class Gui:
+    def __init__(self, rc: ReCaptcha):
+        self.store = Store(self.final_dispatch, rc)
+        self.view = ImageGridChallengeDialog(self.dispatch)
+        self.update_pending = False
+
+    @property
+    def dispatch(self) -> Dispatch:
+        return self.store.dispatch
+
+    @property
+    def state(self) -> Optional["State"]:
+        return self.store.state
+
+    def final_dispatch(self, msg):
+        self.store.state = reduce_state(self.state, msg)
+        if not self.update_pending:
+            self.update_pending = True
+            GLib.idle_add(self._update)
+
+    def _update(self):
+        self.update_pending = False
+        pres = self.pres
+        if pres is not None:
+            self.view.update(pres)
+        return False
+
+    def run(self) -> str:
+        load_css()
+        self.dispatch(Start())
+        try:
+            while self.token is None:
+                if not gtk_run(self.view.run):
+                    raise UserExit
+                self.dispatch(FinishChallenge())
+        finally:
+            self.view.destroy()
+            while Gtk.events_pending():
+                Gtk.main_iteration()
+        return self.token
+
+    @property
+    def pres(self) -> Optional["ImageGridChallengePres"]:
+        return pres(self.state)
+
+    @property
+    def token(self) -> Optional[str]:
+        if isinstance(self.state, str):
+            return self.state
+        return None
+
+
+class Store:
+    state: Optional["State"]
+    dispatch: Dispatch
+
+    def __init__(self, final_dispatch: Dispatch, rc: ReCaptcha):
+        self.state = None
+        middleware = WarningMiddleware(self, final_dispatch)
+        middleware = SolverMiddleware(self, middleware.dispatch, rc)
+        self.dispatch = middleware.dispatch
+
+
+def pres(state: "State") -> Optional["ImageGridChallengePres"]:
+    return {
+        DynamicState: DynamicPres,
+        MultiCaptchaState: MultiCaptchaPres,
+    }.get(type(state), lambda _: None)(state)
+
+
+def state_from_solver(solver: Solver) -> "SolverState":
+    return {
+        DynamicSolver: DynamicState,
+        MultiCaptchaSolver: MultiCaptchaState,
+    }[type(solver)].from_new_solver(solver)
+
+
+# Returns the new state after applying `msg`.
+def reduce_state(state: "State", msg) -> "State":
+    if type(msg) is SetState:
+        return msg.state
+    if type(state) in SOLVER_STATE_TYPES:
+        return state.reduce(msg)
+    return state
+
+
+class SolverMiddleware:
+    def __init__(self, store: Store, next: Dispatch, rc: ReCaptcha):
+        self.store = store
+        self.next = next
+        self.rc = rc
+        self.solver = None
+        self._select_tile_lock = threading.Lock()
+
+    def dispatch(self, msg):
+        if type(msg) is Start:
+            self.solver = self.rc.first_solver()
+            self.next(SetState(state_from_solver(self.solver)))
+        elif isinstance(self.solver, DynamicSolver):
+            self.dispatch_dynamic(msg)
+        elif isinstance(self.solver, MultiCaptchaSolver):
+            self.dispatch_multicaptcha(msg)
+        else:
+            self.next(msg)
+
+    def dispatch_dynamic(self, msg):
+        if type(msg) is FinishChallenge:
+            if self.store.state.num_waiting <= 0:
+                self.send_solution(self.solver.finish())
+        elif type(msg) is SelectTile:
+            self.dynamic_select_tile(msg)
+        else:
+            self.next(msg)
+
+    def dynamic_select_tile(self, msg: SelectTile):
+        def select_tile():
+            with self._select_tile_lock:
+                tile = self.solver.select_tile(msg.index)
+
+            def replace():
+                self.next(ReplaceTile(index=msg.index, image=tile.image))
+                return False
+            GLib.timeout_add(round(tile.delay * 1000), replace)
+
+        self.next(ReplaceTile(index=msg.index, image=None))
+        if self.store.state.num_waiting <= 0:
+            raise RuntimeError("num_waiting should be greater than 0")
+        threading.Thread(target=select_tile, daemon=True).start()
+
+    def dispatch_multicaptcha(self, msg):
+        if type(msg) is FinishChallenge:
+            self.multicaptcha_finish()
+        else:
+            self.next(msg)
+
+    def multicaptcha_finish(self):
+        result = self.solver.select_indices(self.store.state.indices)
+        if isinstance(result, Solution):
+            self.send_solution(result)
+        elif isinstance(result, ImageGridChallenge):
+            self.next(SetNextChallenge(result))
+        else:
+            raise TypeError("Unexpected type: {}".format(type(result)))
+
+    def send_solution(self, solution: Solution):
+        self.solver = None
+        result = self.rc.send_solution(solution)
+        if not isinstance(result, str):
+            self.solver = result
+            result = state_from_solver(result)
+        self.next(SetState(result))
+
+
+class WarningMiddleware:
+    def __init__(self, store: Store, next: Dispatch):
+        self.next = next
+
+    def dispatch(self, msg):
+        if type(msg) is SetNextChallenge:
+            self.check_goal(msg.challenge.goal)
+        elif type(msg) is SetState:
+            if type(msg.state) in SOLVER_STATE_TYPES:
+                self.check_goal(msg.state.challenge.goal)
+        self.next(msg)
+
+    def check_goal(self, goal: ChallengeGoal):
+        if goal.raw is not None:
+            return
+        msg = "WARNING: Could not determine challenge objective in: {}"
+        print(msg.format(goal.fallback), file=sys.stderr)
+
+
+class DynamicState(namedtuple("DynamicState", [
+    "challenge",  # Challenge
+    "tile_images",  # List[Optional[Image.Image]]
+    "num_waiting",  # int
+])):
+    @classmethod
+    def from_new_solver(cls, solver: Solver):
+        challenge = solver.get_challenge()
+        tiles = list(tiles_from_image(challenge.image, challenge.dimensions))
+        return cls(
+            challenge=challenge,
+            tile_images=tiles,
+            num_waiting=0,
+        )
+
+    def replace_tile(
+        self,
+        index: int,
+        image: Optional[Image.Image],
+    ) -> "DynamicState":
+        old_image = self.tile_images[index]
+        num_waiting = self.num_waiting
+        if (old_image is None) != (image is None):
+            num_waiting += 1 if image is None else -1
+
+        images = list(self.tile_images)
+        images[index] = image
+        return self._replace(tile_images=images, num_waiting=num_waiting)
+
+    def reduce(self, msg) -> "DynamicState":
+        if type(msg) is ReplaceTile:
+            return self.replace_tile(msg.index, msg.image)
+        return self
+
+
+class MultiCaptchaState(namedtuple("MultiCaptchaState", [
+    "challenge",  # Challenge
+    "tile_images",  # List[Image.Image]
+    "selected",  # List[bool]
+])):
+    @classmethod
+    def from_new_solver(cls, solver: Solver):
+        return cls.from_challenge(solver.first_challenge())
+
+    @classmethod
+    def from_challenge(cls, challenge: ImageGridChallenge):
+        tiles = list(tiles_from_image(challenge.image, challenge.dimensions))
+        return cls(
+            challenge=challenge,
+            tile_images=tiles,
+            selected=([False] * challenge.dimensions.count),
+        )
+
+    def toggle_tile(self, index: int) -> "MultiCaptchaState":
+        selected = list(self.selected)
+        selected[index] ^= True
+        return self._replace(selected=selected)
+
+    @property
+    def indices(self) -> List[int]:
+        return [i for i, selected in enumerate(self.selected) if selected]
+
+    @property
+    def any_selected(self) -> bool:
+        return any(self.selected)
+
+    def same_any_selected(self, other) -> bool:
+        return type(self) is type(other) and (
+            self.selected is other.selected or
+            self.any_selected is other.any_selected
+        )
+
+    def reduce(self, msg) -> "MultiCaptchaState":
+        if type(msg) is SelectTile:
+            return self.toggle_tile(msg.index)
+        if type(msg) is SetNextChallenge:
+            return self.from_challenge(msg.challenge)
+        return self
+
+
+SOLVER_STATE_TYPES = (MultiCaptchaState, DynamicState)
+SolverState = Union[SOLVER_STATE_TYPES]
+State = Union[SolverState, str, None]
+
+
+class ImageGridChallengePres:
+    def __init__(self, state: SolverState):
+        self.state = state
+
+    def same(self, other) -> bool:
+        return (
+            type(self) is type(other) and
+            self.state is other.state
+        )
+
+    @property
+    def dimensions(self) -> GridDimensions:
+        return self.state.challenge.dimensions
+
+    @property
+    def goal(self) -> str:
+        raise NotImplementedError
+
+    def same_goal(self, other) -> bool:
+        raise NotImplementedError
+
+    @property
+    def verify_label(self) -> str:
+        return "Ver_ify"
+
+    def same_verify_label(self, other) -> bool:
+        return type(self) is type(other)
+
+    @property
+    def is_verify_enabled(self) -> bool:
+        return True
+
+
+class DynamicPres(ImageGridChallengePres):
+    def __init__(self, state: DynamicState):
+        super().__init__(state)
+
+    @property
+    def goal(self) -> str:
+        note = "Click verify once there are none left."
+        return format_goal_with_note(self.state.challenge.goal, note)
+
+    # This method is more efficient than comparing `self.goal` and `other.goal`
+    # as it avoids formatting the goal strings.
+    def same_goal(self, other) -> bool:
+        return (
+            type(self) is type(other) and
+            self.state.challenge.goal is other.state.challenge.goal
+        )
+
+    @property
+    def is_verify_enabled(self) -> bool:
+        return self.state.num_waiting <= 0
+
+    @property
+    def tiles(self) -> Iterable["DynamicTilePres"]:
+        for i, image in enumerate(self.state.tile_images):
+            yield DynamicTilePres(index=i, image=image)
+
+
+class MultiCaptchaPres(ImageGridChallengePres):
+    def __init__(self, state: MultiCaptchaState):
+        super().__init__(state)
+
+    @property
+    def goal(self) -> str:
+        note = "If there are none, click skip."
+        if any(self.state.selected):
+            note = '<span alpha="30%">{}</span>'.format(note)
+        return format_goal_with_note(self.state.challenge.goal, note)
+
+    # This method is more efficient than comparing `self.goal` and `other.goal`
+    # as it avoids formatting the goal strings.
+    def same_goal(self, other) -> bool:
+        return (
+            type(self) is type(other) and
+            self.state.challenge.goal is other.state.challenge.goal and
+            self.state.same_any_selected(other.state)
+        )
+
+    @property
+    def verify_label(self) -> str:
+        if self.state.any_selected:
+            return "Ver_ify"
+        return "Sk_ip"
+
+    def same_verify_label(self, other) -> bool:
+        return (
+            type(self) is type(other) and
+            self.state.same_any_selected(other.state)
+        )
+
+    @property
+    def tiles(self) -> Iterable["MultiCaptchaTilePres"]:
+        iterable = enumerate(zip(self.state.tile_images, self.state.selected))
+        for i, (image, selected) in iterable:
+            yield MultiCaptchaTilePres(index=i, image=image, selected=selected)
+
+
+class TilePres:
+    index: int
+    image: Image.Image
+
+    def __init__(self, index: int, image: Image.Image):
+        self.index = index
+        self.image = image
+
+    def same(self, other) -> bool:
+        return (
+            type(self) is type(other) and
+            self.index == other.index and
+            self.image is other.image
+        )
+
+    def on_click(self, dispatch: Dispatch):
+        dispatch(SelectTile(index=self.index))
+
+
+class DynamicTilePres(TilePres):
+    pass
+
+
+class MultiCaptchaTilePres(TilePres):
+    selected: bool
+
+    def __init__(self, index: int, image: Image.Image, selected: bool):
+        super().__init__(index, image)
+        self.selected = selected
+
+    def same(self, other) -> bool:
+        return (
+            super().same(other) and
+            self.selected == other.selected
+        )
diff --git a/lib/librecaptcha/librecaptcha.py b/lib/librecaptcha/librecaptcha.py
new file mode 100644
index 00000000..f48588fa
--- /dev/null
+++ b/lib/librecaptcha/librecaptcha.py
@@ -0,0 +1,84 @@
+# Copyright (C) 2017, 2019, 2021 taylor.fish <contact@taylor.fish>
+#
+# This file is part of librecaptcha.
+#
+# librecaptcha is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# librecaptcha is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with librecaptcha.  If not, see <https://www.gnu.org/licenses/>.
+
+from . import cli
+from .errors import ChallengeBlockedError, UnknownChallengeError
+from .errors import GtkImportError
+from .recaptcha import ReCaptcha
+
+__version__ = "0.7.4-dev"
+
+GUI_MISSING_MESSAGE = """\
+Error: Could not load the GUI. Is PyGObject installed?
+Try (re)installing librecaptcha[gtk] with pip.
+For more details, add the --debug option.
+"""
+
+CHALLENGE_BLOCKED_MESSAGE = """\
+ERROR: Received challenge type "{}".
+
+This is usually an indication that reCAPTCHA requests from this network are
+being blocked.
+
+Try installing Tor (the full installation, not just the browser bundle) and
+running this program over Tor with the "torsocks" command.
+
+Alternatively, try waiting a while before requesting another challenge over
+this network.
+"""
+
+UNKNOWN_CHALLENGE_MESSAGE = """\
+ERROR: Received unrecognized challenge type "{}".
+Currently, the only supported challenge types are "dynamic" and "multicaptcha".
+Please file an issue if this problem persists.
+"""
+
+
+def _get_gui():
+    from . import gui
+    return gui
+
+
+def has_gui():
+    try:
+        _get_gui()
+    except GtkImportError:
+        return False
+    return True
+
+
+def get_token(
+    api_key: str,
+    site_url: str,
+    user_agent: str, *,
+    gui=False,
+    debug=False,
+) -> str:
+    ui = (_get_gui().Gui if gui else cli.Cli)(ReCaptcha(
+        api_key=api_key,
+        site_url=site_url,
+        user_agent=user_agent,
+        debug=debug,
+    ))
+    try:
+        return ui.run()
+    except ChallengeBlockedError as e:
+        print(CHALLENGE_BLOCKED_MESSAGE.format(e.challenge_type))
+        raise
+    except UnknownChallengeError as e:
+        print(UNKNOWN_CHALLENGE_MESSAGE.format(e.challenge_type))
+        raise
diff --git a/lib/librecaptcha/recaptcha.py b/lib/librecaptcha/recaptcha.py
new file mode 100644
index 00000000..85685e39
--- /dev/null
+++ b/lib/librecaptcha/recaptcha.py
@@ -0,0 +1,621 @@
+# Copyright (C) 2017, 2019, 2021 taylor.fish <contact@taylor.fish>
+#
+# This file is part of librecaptcha.
+#
+# librecaptcha is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# librecaptcha is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with librecaptcha.  If not, see <https://www.gnu.org/licenses/>.
+
+from .errors import ChallengeBlockedError, UnknownChallengeError
+from .errors import SiteUrlParseError
+from .extract_strings import extract_and_save
+from .typing import Dict, Iterable, List, Tuple
+
+import requests
+
+from collections import namedtuple
+from html.parser import HTMLParser
+from typing import Optional, Union
+from urllib.parse import urlparse
+import base64
+import io
+import json
+import os
+import os.path
+import re
+import sys
+import time
+
+BASE_URL = "https://www.google.com/recaptcha/api2/"
+API_JS_URL = "https://www.google.com/recaptcha/api.js"
+JS_URL_TEMPLATE = """\
+https://www.gstatic.com/recaptcha/releases/{}/recaptcha__{}.js
+"""[:-1]
+
+STRINGS_VERSION = "0.1.0"
+STRINGS_PATH = os.path.join(
+    os.path.expanduser("~"), ".cache", "librecaptcha", "cached-strings",
+)
+CHALLENGE_GOAL_TEXT = {
+    'en': 'select all',
+    'it': 'seleziona tutti'
+}
+
+DYNAMIC_SELECT_DELAY = 4.5  # seconds
+FIND_GOAL_SEARCH_DISTANCE = 10
+
+
+def get_testing_url(url: str) -> str:
+    return urlparse(url)._replace(
+        scheme="http",
+        netloc="localhost:55476",
+    ).geturl()
+
+
+if os.getenv("LIBRECAPTCHA_USE_TEST_SERVER"):
+    BASE_URL = get_testing_url(BASE_URL)
+    API_JS_URL = get_testing_url(API_JS_URL)
+    JS_URL_TEMPLATE = get_testing_url(JS_URL_TEMPLATE)
+
+
+def get_full_url(url: str) -> str:
+    return BASE_URL.rstrip("/") + "/" + url.lstrip("/")
+
+
+def get_rc_site_url(url: str) -> str:
+    parsed = urlparse(url)
+    if not parsed.hostname:
+        raise SiteUrlParseError("Error: Site URL has no hostname.")
+    if not parsed.scheme:
+        raise SiteUrlParseError("Error: Site URL has no scheme.")
+    if parsed.scheme not in ["http", "https"]:
+        raise SiteUrlParseError(
+            "Error: Site URL has invalid scheme: {}".format(parsed.scheme),
+        )
+    port = parsed.port
+    if port is None:
+        port = {"http": 80, "https": 443}[parsed.scheme]
+    return "{}://{}:{}".format(parsed.scheme, parsed.hostname, port)
+
+
+def rc_base64(string: str) -> str:
+    data = string
+    if isinstance(string, str):
+        data = string.encode()
+    return base64.b64encode(data, b"-_").decode().replace("=", ".")
+
+
+def load_rc_json(text: str):
+    return json.loads(text.split("\n", 1)[1])
+
+
+def get_meta(pmeta, probable_index: int):
+    if not isinstance(pmeta, list):
+        raise TypeError("pmeta is not a list: {!r}".format(pmeta))
+
+    def matches(meta):
+        return meta and isinstance(meta, list)
+
+    if probable_index < len(pmeta):
+        meta = pmeta[probable_index]
+        if matches(meta):
+            return meta
+
+    for child in pmeta:
+        if matches(child):
+            return child
+    raise RuntimeError("Could not find meta; pmeta: {!r}".format(pmeta))
+
+
+def get_rresp(uvresp):
+    if not isinstance(uvresp, list):
+        raise TypeError("uvresp is not a list: {!r}".format(uvresp))
+
+    for child in uvresp:
+        if child and isinstance(child, list) and child[0] == "rresp":
+            return child
+    return None
+
+
+def get_js_strings(user_agent: str, rc_version: str, lang : str = 'en') -> List[str]:
+    def get_json():
+        with open(STRINGS_PATH + '-' + lang) as f:
+            version, text = f.read().split("\n", 1)
+            if version != "{}/{}".format(STRINGS_VERSION, rc_version):
+                raise OSError("Incorrect version: {}".format(version))
+            return json.loads(text)
+
+    try:
+        return get_json()
+    except (OSError, ValueError, json.JSONDecodeError):
+        pass
+
+    result = extract_and_save(
+        url=JS_URL_TEMPLATE.format(rc_version, lang),
+        path=STRINGS_PATH + '-' + lang,
+        version=STRINGS_VERSION,
+        rc_version=rc_version,
+        user_agent=user_agent,
+    )
+    print(file=sys.stderr)
+    return result
+
+
+def get_rc_version(user_agent: str) -> str:
+    match = re.search(r"/recaptcha/releases/(.+?)/", requests.get(
+        API_JS_URL, headers={
+            "User-Agent": user_agent,
+        },
+    ).text)
+    if match is None:
+        raise RuntimeError("Could not extract version from api.js.")
+    return match.group(1)
+
+
+# def get_image(data: bytes) -> Image.Image:
+#     image = Image.open(io.BytesIO(data))
+#     if image.mode in ["RGB", "RGBA"]:
+#         return image
+#     return image.convert("RGB")
+
+
+def varint_encode(n: int, out: bytearray) -> bytes:
+    if n < 0:
+        raise ValueError("n must be nonnegative")
+    while True:
+        b = n & 127
+        n >>= 7
+        if n > 0:
+            out.append(b | 128)
+        else:
+            out.append(b)
+            break
+
+
+def protobuf_encode(fields: Iterable[Tuple[int, bytes]]) -> bytes:
+    result = bytearray()
+    for num, value in fields:
+        # Wire type of 2 indicates a length-delimited field.
+        varint_encode((num << 3) | 2, result)
+        varint_encode(len(value), result)
+        result += value
+    return bytes(result)
+
+
+def format_reload_protobuf(
+    rc_version: str,
+    token: str,
+    reason: str,
+    api_key: str,
+) -> bytes:
+    # Note: We're not sending fields 3, 5, and 16.
+    return protobuf_encode([
+        (1, rc_version.encode()),
+        (2, token.encode()),
+        (6, reason.encode()),
+        (14, api_key.encode()),
+    ])
+
+
+class GridDimensions(namedtuple("GridDimensions", [
+    "rows",  # int
+    "columns",  # int
+])):
+    @property
+    def count(self) -> int:
+        return self.rows * self.columns
+
+
+Solution = namedtuple("Solution", [
+    "response",
+])
+
+ImageGridChallenge = namedtuple("ImageGridChallenge", [
+    "goal",  # ChallengeGoal
+    "image",  # Image.Image
+    "dimensions",  # GridDimensions
+])
+
+DynamicTile = namedtuple("DynamicTile", [
+    "image",  # Image.Image
+    "delay",  # float
+])
+
+
+class DynamicSolver:
+    def __init__(self, recaptcha: "ReCaptcha", pmeta):
+        self.rc = recaptcha
+        self.selections = []
+        meta = get_meta(pmeta, 1)
+        self.meta = meta
+        self.tile_index_map = list(range(self.num_tiles))
+        self.last_request_map = [0] * self.num_tiles
+        self.latest_index = self.num_tiles - 1
+        self.challenge_retrieved = False
+
+    def get_challenge(self) -> ImageGridChallenge:
+        if self.challenge_retrieved:
+            raise RuntimeError("Challenge was already retrieved")
+        self.challenge_retrieved = True
+        goal = self.rc.get_challenge_goal(self.meta)
+        image = self._first_image()
+        return ImageGridChallenge(
+            goal=goal,
+            image=image,
+            dimensions=self.dimensions,
+        )
+
+    def select_tile(self, index: int) -> DynamicTile:
+        if not self.challenge_retrieved:
+            raise RuntimeError("Challenge must be retrieved first")
+        image = self._replace_tile(index)
+        delay = self.get_timeout(index)
+        return DynamicTile(image=image, delay=delay)
+
+    def finish(self) -> Solution:
+        if not self.challenge_retrieved:
+            raise RuntimeError("Challenge must be retrieved first")
+        return Solution(self.selections)
+
+    @property
+    def final_timeout(self):
+        return max(self.get_timeout(i) for i in range(self.num_tiles))
+
+    @property
+    def dimensions(self) -> GridDimensions:
+        return GridDimensions(rows=self.meta[3], columns=self.meta[4])
+
+    @property
+    def num_tiles(self):
+        return self.dimensions.count
+
+    def get_timeout(self, index: int):
+        elapsed = time.monotonic() - self.last_request_map[index]
+        duration = max(DYNAMIC_SELECT_DELAY - elapsed, 0)
+        return duration
+
+    def _first_image(self):
+        return self.rc.get("payload", params={
+            "p": None,
+            "k": None,
+        }).content
+
+    def _replace_tile(self, index: int):
+        real_index = self.tile_index_map[index]
+        self.selections.append(real_index)
+        r = self.rc.post("replaceimage", data={
+            "v": None,
+            "c": None,
+            "ds": "[{}]".format(real_index),
+        })
+
+        self.last_request_map[index] = time.monotonic()
+        data = load_rc_json(r.text)
+        self.latest_index += 1
+        self.tile_index_map[index] = self.latest_index
+
+        self.rc.current_token = data[1]
+        self.rc.current_p = data[5]
+        replacement_id = data[2][0]
+
+        # The server might not return any image, but it seems unlikely in
+        # practice. If it becomes a problem we can handle this case.
+        return self.rc.get("payload", params={
+            "p": None,
+            "k": None,
+            "id": replacement_id,
+        }).content
+
+
+class MultiCaptchaSolver:
+    def __init__(self, recaptcha: "ReCaptcha", pmeta):
+        """The current challenge."""
+        self.rc = recaptcha
+        self.selection_groups = []
+        self.challenge_type = None
+        self.id = "2"
+        self.metas = list(get_meta(pmeta, 5)[0])
+        self.challenge_index = -1
+
+    def first_challenge(self) -> ImageGridChallenge:
+        if self.challenge_index >= 0:
+            raise RuntimeError("Already retrieved first challenge")
+        return self._get_challenge(self._first_image())
+
+    def select_indices(self, indices) -> Union[ImageGridChallenge, Solution]:
+        if self.challenge_index < 0:
+            raise RuntimeError("First challenge wasn't retrieved")
+        self.selection_groups.append(list(sorted(indices)))
+        if not self.metas:
+            return Solution(self.selection_groups)
+        return self._get_challenge(self._replace_image())
+
+    def _get_challenge(self, image):
+        self.challenge_index += 1
+        meta = self.metas.pop(0)
+        dimensions = GridDimensions(rows=meta[3], columns=meta[4])
+        goal = self.rc.get_challenge_goal(meta)
+        return ImageGridChallenge(
+            goal=goal,
+            image=image,
+            dimensions=dimensions,
+        )
+
+    def _first_image(self):
+        return self.rc.get("payload", params={
+            "c": self.rc.current_token,
+            "k": self.rc.api_key,
+        }).content
+
+    def _replace_image(self):
+        selections = self.selection_groups[-1]
+        r = self.rc.post("replaceimage", data={
+            "v": None,
+            "c": self.rc.current_token,
+            "ds": json.dumps([selections], separators=",:"),
+        })
+
+        data = load_rc_json(r.text)
+        self.rc.current_token = data[1]
+
+        prev_p = self.rc.current_p
+        self.rc.current_p = data[5]
+
+        prev_id = self.id
+        self.id = (data[2] or [None])[0]
+
+        return self.rc.get("payload", params={
+            "p": prev_p,
+            "k": None,
+            "id": prev_id,
+        }).content
+
+
+Solver = Union[DynamicSolver, MultiCaptchaSolver]
+
+
+class ChallengeGoal(namedtuple("ChallengeGoal", [
+    "raw",  # Optional[str]
+    "meta",
+])):
+    @property
+    def plain(self) -> Optional[str]:
+        if self.raw is None:
+            return None
+        return self.raw.replace("<strong>", "").replace("</strong>", "")
+
+    @property
+    def fallback(self) -> str:
+        return json.dumps(self.meta)
+
+
+class ReCaptcha:
+    def __init__(self, api_key, site_url, user_agent, debug=False,
+                 make_requests=True, lang = 'en'):
+        self.api_key = api_key
+        self.site_url = get_rc_site_url(site_url)
+        self.debug = debug
+        self.co = rc_base64(self.site_url)
+
+        self.first_token = None
+        self.current_token = None
+        self.current_p = None
+        self.user_agent = user_agent
+
+        self.js_strings = None
+        self.rc_version = None
+
+        self.language = lang
+
+        if make_requests:
+            self.rc_version = get_rc_version(self.user_agent)
+            self.js_strings = get_js_strings(self.user_agent, self.rc_version, self.language)
+        self.solver_index = -1
+
+
+    def first_solver(self) -> Solver:
+        if self.solver_index >= 0:
+            raise RuntimeError("First solver was already retrieved")
+        self._request_first_token()
+        rresp = self._get_first_rresp()
+        return self._get_solver(rresp)
+
+    def send_solution(self, solution: Solution) -> Union[Solver, str]:
+        if self.solver_index < 0:
+            raise RuntimeError("First solver wasn't retrieved")
+        uvtoken, rresp = self._verify(solution.response)
+        if rresp is not None:
+            return self._get_solver(rresp)
+        if not uvtoken:
+            raise RuntimeError("Got neither uvtoken nor new rresp.")
+        return uvtoken
+
+    def debug_print(self, *args, **kwargs):
+        if not self.debug:
+            return
+        if len(args) == 1 and callable(args[0]):
+            args = (args[0](),)
+        print(*args, file=sys.stderr, **kwargs)
+
+    def get_challenge_goal(self, meta) -> ChallengeGoal:
+        raw = self.find_challenge_goal_text(meta[0])
+        return ChallengeGoal(raw=raw, meta=meta)
+
+    def find_challenge_goal_text(self, id: str, raw=False) -> str:
+        start = 0
+        matching_strings = []
+
+        def try_find():
+            nonlocal start
+            index = self.js_strings.index(id, start)
+            for i in range(FIND_GOAL_SEARCH_DISTANCE):
+                next_str = self.js_strings[index + i + 1]
+                if re.search(r"\b{}\b".format( CHALLENGE_GOAL_TEXT[ self.language] ) , next_str, re.I):
+                    matching_strings.append((i, index, next_str))
+            start = index + FIND_GOAL_SEARCH_DISTANCE + 1
+
+        try:
+            while True:
+                try_find()
+        except (ValueError, IndexError):
+            pass
+
+        try:
+            goal = min(matching_strings)[2]
+        except ValueError:
+            return None
+        return goal
+
+    def get_headers(self, headers: Optional[Dict[str, str]]) -> Dict[str, str]:
+        headers = headers or {}
+        updates = {}
+        if "User-Agent" not in headers:
+            updates["User-Agent"] = self.user_agent
+        if updates:
+            headers = dict(headers)
+            headers.update(updates)
+        return headers
+
+    def get(self, url, *, params=None, headers=None, allow_errors=None,
+            **kwargs):
+        if params is None:
+            params = {"k": None, "v": None}
+        if params.get("k", "") is None:
+            params["k"] = self.api_key
+        if params.get("v", "") is None:
+            params["v"] = self.rc_version
+        if params.get("p", "") is None:
+            params["p"] = self.current_p
+        headers = self.get_headers(headers)
+
+        r = requests.get(
+            get_full_url(url), params=params, headers=headers,
+            **kwargs,
+        )
+        self.debug_print(lambda: "[http] [get] {}".format(r.url))
+        if not (allow_errors is True or r.status_code in (allow_errors or {})):
+            r.raise_for_status()
+        return r
+
+    def post(self, url, *, params=None, data=None, headers=None,
+             allow_errors=None, no_debug_response=False, **kwargs):
+        if params is None:
+            params = {"k": None}
+        if data is None:
+            data = {"v": None}
+        if params.get("k", "") is None:
+            params["k"] = self.api_key
+        if isinstance(data, dict) and data.get("v", "") is None:
+            data["v"] = self.rc_version
+        if isinstance(data, dict) and data.get("c", "") is None:
+            data["c"] = self.current_token
+        headers = self.get_headers(headers)
+
+        r = requests.post(
+            get_full_url(url), params=params, data=data, headers=headers,
+            **kwargs,
+        )
+        self.debug_print(lambda: "[http] [post] {}".format(r.url))
+        self.debug_print(lambda: "[http] [post] [data] {!r}".format(data))
+        if not no_debug_response:
+            self.debug_print(
+                lambda: "[http] [post] [response] {}".format(r.text),
+            )
+        if not (allow_errors is True or r.status_code in (allow_errors or {})):
+            r.raise_for_status()
+        return r
+
+    def _request_first_token(self):
+        class Parser(HTMLParser):
+            def __init__(p_self):
+                p_self.token = None
+                super().__init__()
+
+            def handle_starttag(p_self, tag, attrs):
+                attrs = dict(attrs)
+                if attrs.get("id") == "recaptcha-token":
+                    p_self.token = attrs.get("value")
+
+        # Note: We're not sending "cb".
+        text = self.get("anchor", params={
+            "ar": "1",
+            "k": None,
+            "co": self.co,
+            "hl": "en",
+            "v": None,
+            "size": "normal",
+            "sa": "action",
+        }).text
+        parser = Parser()
+        parser.feed(text)
+
+        if not parser.token:
+            raise RuntimeError(
+                "Could not get first token. Response:\n{}".format(text),
+            )
+        self.current_token = parser.token
+
+    def _verify(self, response):
+        response_text = json.dumps({"response": response}, separators=",:")
+        response_b64 = rc_base64(response_text)
+
+        self.debug_print("Sending verify request...")
+        # Note: We're not sending "t", "ct", and "bg".
+        r = self.post("userverify", data={
+            "v": None,
+            "c": None,
+            "response": response_b64,
+        })
+
+        uvresp = load_rc_json(r.text)
+        self.debug_print(lambda: "Got verify response: {!r}".format(uvresp))
+        rresp = get_rresp(uvresp)
+        uvresp_token = uvresp[1]
+        return (uvresp_token, rresp)
+
+    def _get_first_rresp(self):
+        self.debug_print("Getting first rresp...")
+        r = self.post("reload", data=format_reload_protobuf(
+            rc_version=self.rc_version,
+            token=self.current_token,
+            reason="fi",
+            api_key=self.api_key,
+        ), headers={
+            "Content-Type": "application/x-protobuffer",
+        })
+        rresp = load_rc_json(r.text)
+        self.debug_print(lambda: "Got first rresp: {!r}".format(rresp))
+        return rresp
+
+    def _get_solver(self, rresp) -> Solver:
+        self.solver_index += 1
+        challenge_type = rresp[5]
+        self.debug_print(lambda: "Challenge type: {}".format(challenge_type))
+        pmeta = rresp[4]
+        self.debug_print(lambda: "pmeta: {}".format(pmeta))
+        self.current_token = rresp[1]
+        self.current_p = rresp[9]
+        self.debug_print(
+            lambda: "Current token: {}".format(self.current_token),
+        )
+
+        solver_class = {
+            "dynamic": DynamicSolver,
+            "multicaptcha": MultiCaptchaSolver,
+        }.get(challenge_type)
+
+        if solver_class is not None:
+            return solver_class(self, pmeta)
+
+        if challenge_type in ["default", "doscaptcha"]:
+            raise ChallengeBlockedError(challenge_type)
+        raise UnknownChallengeError(challenge_type)
diff --git a/lib/librecaptcha/typing.py b/lib/librecaptcha/typing.py
new file mode 100644
index 00000000..b2c1905e
--- /dev/null
+++ b/lib/librecaptcha/typing.py
@@ -0,0 +1,40 @@
+# Copyright (C) 2021 taylor.fish <contact@taylor.fish>
+#
+# This file is part of librecaptcha.
+#
+# librecaptcha is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# librecaptcha is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with librecaptcha.  If not, see <https://www.gnu.org/licenses/>.
+
+from collections.abc import Callable, Iterable
+import typing
+
+try:
+    list[int]
+except Exception:
+    List = typing.List
+    Dict = typing.Dict
+    Tuple = typing.Tuple
+else:
+    List = list
+    Dict = dict
+    Tuple = tuple
+
+try:
+    Callable[[], int]
+except Exception:
+    Callable = typing.Callable
+
+try:
+    Iterable[int]
+except Exception:
+    Iterable = typing.Iterable
diff --git a/lib/librecaptcha/user_agent_data.py b/lib/librecaptcha/user_agent_data.py
new file mode 100644
index 00000000..c8595f5b
--- /dev/null
+++ b/lib/librecaptcha/user_agent_data.py
@@ -0,0 +1,36 @@
+# This file was automatically generated by update_user_agents.py using data
+# from <https://techblog.willshouse.com/2012/01/03/most-common-user-agents/>.
+
+# flake8: noqa
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:85.0) Gecko/20100101 Firefox/85.0",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Safari/605.1.15",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.104 Safari/537.36",
+    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:85.0) Gecko/20100101 Firefox/85.0",
+    "Mozilla/5.0 (Windows NT 10.0; rv:78.0) Gecko/20100101 Firefox/78.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:86.0) Gecko/20100101 Firefox/86.0",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36",
+    "Mozilla/5.0 (X11; Linux x86_64; rv:85.0) Gecko/20100101 Firefox/85.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.2 Safari/605.1.15",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36 Edg/88.0.705.63",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.96 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.16; rv:85.0) Gecko/20100101 Firefox/85.0",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36 Edg/88.0.705.74",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:85.0) Gecko/20100101 Firefox/85.0",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Safari/605.1.15",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 11_2_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36 Edg/88.0.705.68",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36",
+    "Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 11_2_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 11_2_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.192 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.2 Safari/605.1.15",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36 OPR/73.0.3856.344"
+]
diff --git a/lib/librecaptcha/user_agents.py b/lib/librecaptcha/user_agents.py
new file mode 100644
index 00000000..0e484f2f
--- /dev/null
+++ b/lib/librecaptcha/user_agents.py
@@ -0,0 +1,23 @@
+# Copyright (C) 2017-2019 taylor.fish <contact@taylor.fish>
+#
+# This file is part of librecaptcha.
+#
+# librecaptcha is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# librecaptcha is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with librecaptcha.  If not, see <https://www.gnu.org/licenses/>.
+
+from .user_agent_data import USER_AGENTS
+import random
+
+
+def random_user_agent():
+    return random.choice(USER_AGENTS)
diff --git a/lib/sqlitedict.py b/lib/sqlitedict.py
index 2e0db32b..cfc1adf5 100644
--- a/lib/sqlitedict.py
+++ b/lib/sqlitedict.py
@@ -38,9 +38,6 @@ from threading import Thread
 
 __version__ = '1.7.0.dev0'
 
-import xbmc
-kodi_monitor = xbmc.Monitor()
-
 major_version = sys.version_info[0]
 if major_version < 3:  # py <= 2.x
     if sys.version_info[1] < 5:  # py <= 2.4
@@ -443,7 +440,7 @@ class SqliteMultithread(Thread):
         self._sqlitedict_thread_initialized = True
 
         res = None
-        while not kodi_monitor.abortRequested():
+        while True:
             req, arg, res, outer_stack = self.reqs.get()
             if req == '--close--':
                 assert res, ('--close-- without return queue', res)
diff --git a/platformcode/config.py b/platformcode/config.py
index 86412bf4..0716d42a 100644
--- a/platformcode/config.py
+++ b/platformcode/config.py
@@ -438,4 +438,8 @@ def verify_directories_created():
 
 
 def get_online_server_thumb(server):
-    return "https://raw.github.com/kodiondemand/media/master/resources/servers/" + server.lower().replace('_server','') + '.png'
\ No newline at end of file
+    return "https://raw.github.com/kodiondemand/media/master/resources/servers/" + server.lower().replace('_server','') + '.png'
+
+
+def get_language():
+    return get_localized_string(20001)
diff --git a/platformcode/launcher.py b/platformcode/launcher.py
index f999f9e5..5c254d85 100644
--- a/platformcode/launcher.py
+++ b/platformcode/launcher.py
@@ -222,6 +222,13 @@ def run(item=None):
             # Special action for findvideos, where the plugin looks for known urls
             elif item.action == "findvideos":
                 from core import servertools
+                from core import db
+                if db['OnPlay'].get('addon', False):
+                    item.autoplay = True
+                    db['OnPlay']['addon'] = False
+                    platformtools.fakeVideo()
+                db.close()
+
 
                 # First checks if channel has a "findvideos" function
                 if hasattr(channel, 'findvideos'):
@@ -292,9 +299,20 @@ def run(item=None):
 
                 platformtools.render_items(itemlist, item)
 
-            # For all other actions
+                # For all other actions
             else:
-                # import web_pdb; web_pdb.set_trace()
+                if item.channel == 'filmontv':
+                    reload = False
+                    from core import db
+                    if db['OnPlay'].get('addon', False):
+                        reload = True
+                    db['OnPlay']['addon'] = False
+                    db.close()
+                    if reload:
+                        platformtools.fakeVideo()
+                        import xbmc
+                        return xbmc.executebuiltin("Container.Update(" + sys.argv[0] + "?" + item.tourl() + ")")
+
                 logger.debug("Executing channel '%s' method" % item.action)
                 itemlist = getattr(channel, item.action)(item)
                 if config.get_setting('trakt_sync'):
@@ -468,12 +486,8 @@ def play_from_library(item):
     import xbmcgui, xbmcplugin, xbmc
     from time import sleep
 
-    # logger.debug("item: \n" + item.tostring('\n'))
-    # xbmc.Player().play(os.path.join(config.get_runtime_path(), "resources", "kod.mp4"))
     if not item.autoplay and not item.next_ep:
         platformtools.fakeVideo()
-    # from core.support import dbg;dbg()
-    # platformtools.prevent_busy(item)
 
 
     itemlist=[]
diff --git a/platformcode/platformtools.py b/platformcode/platformtools.py
index b3f76944..14fb7aad 100644
--- a/platformcode/platformtools.py
+++ b/platformcode/platformtools.py
@@ -408,7 +408,8 @@ def viewmodeMonitor():
                     if currentMode != defaultMode:
                         # logger.debug('viewmode changed: ' + currentModeName + '-' + str(currentMode) + ' - content: ' + content)
                         config.set_setting('view_mode_%s' % content, currentModeName + ', ' + str(currentMode))
-                        dialog_notification(config.get_localized_string(70153),
+                        if config.get_setting('viewchange_notify'):
+                            dialog_notification(config.get_localized_string(70153),
                                                         config.get_localized_string(70187) % (content, currentModeName),
                                                         sound=False)
         except:
@@ -1138,8 +1139,8 @@ def show_video_info(*args, **kwargs):
 
 
 def show_recaptcha(key, referer):
-    from platformcode.recaptcha import Recaptcha
-    return Recaptcha("Recaptcha.xml", config.get_runtime_path()).Start(key, referer)
+    from platformcode.recaptcha import Kodi
+    return Kodi(key, referer).run()
 
 
 def alert_no_disponible_server(server):
@@ -1489,39 +1490,27 @@ def play_torrent(item, xlistitem, mediaurl):
         selection = 0
 
     if selection >= 0:
-        prevent_busy()
+        prevent_busy(item)
 
         mediaurl = urllib.quote_plus(item.url)
         torr_client = torrent_options[selection][0]
 
         if torr_client in ['elementum'] and item.infoLabels['tmdb_id']:
             if item.contentType == 'episode' and "elementum" not in torr_client:
-                mediaurl += "&episode=%s&library=&season=%s&show=%s&tmdb=%s&type=episode" % (item.infoLabels['episode'], item.infoLabels['season'], item.infoLabels['tmdb_id'], item.infoLabels['tmdb_id'])
+                mediaurl += "&episode=%s&season=%s&show=%s&tmdb=%s&type=episode" % (item.infoLabels['episode'], item.infoLabels['season'], item.infoLabels['tmdb_id'], item.infoLabels['tmdb_id'])
             elif item.contentType == 'movie':
-                mediaurl += "&library=&tmdb=%s&type=movie" % (item.infoLabels['tmdb_id'])
+                mediaurl += "&tmdb=%s&type=movie" % (item.infoLabels['tmdb_id'])
 
         if torr_client in ['elementum'] and item.downloadFilename:
             torrent.elementum_download(item)
 
         else:
-            # xbmc.executebuiltin("PlayMedia(" + torrent_options[selection][1] % mediaurl + ")")
-            if (item.fromLibrary and item.play_from == 'window') or item.window:
-                xlistitem.setPath(torrent_options[selection][1] % mediaurl)
-                playlist = xbmc.PlayList(xbmc.PLAYLIST_VIDEO)
-                playlist.clear()
-                playlist.add(torrent_options[selection][1] % mediaurl, xlistitem)
-                xbmc_player.play(playlist, xlistitem)
-            else:
-                if not item.autoplay and item.channel != 'videolibrary': fakeVideo()
-                if xbmc.getCondVisibility("system.platform.android"): xbmc.sleep(3000)
-                xbmc.executebuiltin("PlayMedia(" + torrent_options[selection][1] % mediaurl + ")")
-
-            # torrent.mark_auto_as_watched(item)
-
-            # if not item.globalsearch:
-            #     while is_playing() and not xbmc.Monitor().abortRequested():
-            #         time.sleep(3)
-
+            import xbmcaddon
+            addon = xbmcaddon.Addon(id='plugin.video.elementum')
+            if addon.getSetting('download_storage') == '0':
+                addon.setSetting('download_storage', '1')
+                xbmc.sleep(3000)
+            xbmc.executebuiltin("PlayMedia(" + torrent_options[selection][1] % mediaurl + ")")
 
 def resume_playback(played_time):
     class ResumePlayback(xbmcgui.WindowXMLDialog):
@@ -1597,173 +1586,38 @@ def install_inputstream():
 
 
 def install_widevine():
-    platform = get_platform()
-    if platform['os'] != 'android':
-        from core.httptools import downloadpage
-        from xbmcaddon import Addon
-        from core import jsontools
-        from distutils.version import LooseVersion
-        path = xbmc.translatePath(Addon('inputstream.adaptive').getSetting('DECRYPTERPATH'))
-
-        # if Widevine CDM is not installed
-        if not os.path.exists(path) or not os.listdir(path):
-            select = dialog_yesno('Widevine CDM', config.get_localized_string(70808))
-            if select > 0:
-                if not 'arm' in platform['arch']:
-                    last_version = downloadpage('https://dl.google.com/widevine-cdm/versions.txt').data.split()[-1]
-                    download_widevine(last_version, platform, path)
-                else:
-                    json = downloadpage('https://dl.google.com/dl/edgedl/chromeos/recovery/recovery.json').data
-                    devices = jsontools.load(json)
-                    download_chromeos_image(devices, platform, path)
-
-        # if Widevine CDM is outdated
-        elif platform['os'] != 'android':
-            if not 'arm' in platform['arch']:
-                last_version = downloadpage('https://dl.google.com/widevine-cdm/versions.txt').data.split()[-1]
-                current_version = jsontools.load(open(os.path.join(path, 'manifest.json')).read())['version']
-                if LooseVersion(last_version) > LooseVersion(current_version):
-                    select = dialog_yesno(config.get_localized_string(70810),config.get_localized_string(70809))
-                    if select > 0: download_widevine(last_version, platform, path)
-            else:
-                devices = jsontools.load(downloadpage('https://dl.google.com/dl/edgedl/chromeos/recovery/recovery.json').data)
-                current_version = jsontools.load(open(os.path.join(path, 'config.json')).read())['version']
-                last_version = best_chromeos_image(devices)['version']
-                if LooseVersion(last_version) > LooseVersion(current_version):
-                    select = dialog_yesno(config.get_localized_string(70810),config.get_localized_string(70809))
-                    if select > 0:download_chromeos_image(devices, platform, path)
-
-
-def download_widevine(version, platform, path):
-    # for x86 architectures
-    from zipfile import ZipFile
-    from core import downloadtools
-    archiveName = 'https://dl.google.com/widevine-cdm/' + version + '-' + platform['os'] + '-' + platform['arch'] + '.zip'
-    fileName = config.get_temp_file('widevine.zip')
-    if not os.path.exists(archiveName):
-        if not os.path.exists(fileName):
-            downloadtools.downloadfile(archiveName, fileName, header='Download Widevine CDM')
-        zip_obj = ZipFile(fileName)
-        for filename in zip_obj.namelist():
-            zip_obj.extract(filename, path)
-        zip_obj.close()
-        os.remove(fileName)
-
-
-def download_chromeos_image(devices, platform, path):
-    # for arm architectures
-    from core import downloadtools
-    from core import jsontools
-    best = best_chromeos_image(devices)
-    archiveName = best['url']
-    version = best['version']
-
-    fileName = config.get_temp_file(archiveName.split('/')[-1])
-    if not os.path.exists(fileName):
-        downloadtools.downloadfile(archiveName, fileName, header='Download Widevine CDM')
-    from lib.arm_chromeos import ChromeOSImage
-    ChromeOSImage(fileName).extract_file(
-                filename='libwidevinecdm.so',
-                extract_path=os.path.join(path),
-                progress=dialog_progress(config.get_localized_string(70811),config.get_localized_string(70812)))
-    recovery_file = os.path.join(path, os.path.basename('https://dl.google.com/dl/edgedl/chromeos/recovery/recovery.json'))
-    config_file = os.path.join(path, 'config.json')
-    if not os.path.exists(path):
-        os.mkdir(path)
-    with open(recovery_file, 'w') as reco_file:
-        reco_file.write(jsontools.dump(devices, indent=4))
-        reco_file.close()
-    with open(config_file, 'w') as conf_file:
-        conf_file.write(jsontools.dump(best))
-        conf_file.close()
-    os.remove(fileName)
-
-def best_chromeos_image(devices):
-    best = None
-    for device in devices:
-        # Select ARM hardware only
-        for arm_hwid in ['BIG','BLAZE','BOB','DRUWL','DUMO','ELM','EXPRESSO','FIEVEL','HANA','JAQ','JERRY','KEVIN','KITTY','MICKEY','MIGHTY','MINNIE','PHASER','PHASER360','PI','PIT','RELM','SCARLET','SKATE','SNOW','SPEEDY','SPRING','TIGER']:
-            if arm_hwid in device['hwidmatch']:
-                hwid = arm_hwid
-                break  # We found an ARM device, rejoice !
-        else:
-            continue  # Not ARM, skip this device
-
-        device['hwid'] = hwid
-
-        # Select the first ARM device
-        if best is None:
-            best = device
-            continue  # Go to the next device
-
-        # Skip identical hwid
-        if hwid == best['hwid']:
-            continue
-
-        # Select the newest version
-        from distutils.version import LooseVersion  # pylint: disable=import-error,no-name-in-module,useless-suppression
-        if LooseVersion(device['version']) > LooseVersion(best['version']):
-            logger.info('%s (%s) is newer than %s (%s)' % (device['hwid'], device['version'], best['hwid'], best['version']))
-            best = device
-
-        # Select the smallest image (disk space requirement)
-        elif LooseVersion(device['version']) == LooseVersion(best['version']):
-            if int(device['filesize']) + int(device['zipfilesize']) < int(best['filesize']) + int(best['zipfilesize']):
-                logger.info('%s (%d) is smaller than %s (%d)' % (device['hwid'], int(device['filesize']) + int(device['zipfilesize']), best['hwid'], int(best['filesize']) + int(best['zipfilesize'])))
-                best = device
-    return best
-
-def get_platform():
-    import platform
-    build = xbmc.getInfoLabel("System.BuildVersion")
-    kodi_version = int(build.split()[0][:2])
-    ret = {
-        "auto_arch": sys.maxsize > 2 ** 32 and "64-bit" or "32-bit",
-        "arch": sys.maxsize > 2 ** 32 and "x64" or "ia32",
-        "os": "",
-        "version": platform.release(),
-        "kodi": kodi_version,
-        "build": build
-    }
+    # Not necessary on Android devices
     if xbmc.getCondVisibility("system.platform.android"):
-        ret["os"] = "android"
-        if "arm" in platform.machine() or "aarch" in platform.machine():
-            ret["arch"] = "arm"
-            if "64" in platform.machine() and ret["auto_arch"] == "64-bit":
-                ret["arch"] = "arm64"
-    elif xbmc.getCondVisibility("system.platform.linux"):
-        ret["os"] = "linux"
-        if "aarch" in platform.machine() or "arm64" in platform.machine():
-            if xbmc.getCondVisibility("system.platform.linux.raspberrypi"):
-                ret["arch"] = "armv7"
-            elif ret["auto_arch"] == "32-bit":
-                ret["arch"] = "armv7"
-            elif ret["auto_arch"] == "64-bit":
-                ret["arch"] = "arm64"
-            elif platform.architecture()[0].startswith("32"):
-                ret["arch"] = "arm"
-            else:
-                ret["arch"] = "arm64"
-        elif "armv7" in platform.machine():
-            ret["arch"] = "armv7"
-        elif "arm" in platform.machine():
-            ret["arch"] = "arm"
-    elif xbmc.getCondVisibility("system.platform.xbox"):
-        ret["os"] = "win"
-        ret["arch"] = "x64"
-    elif xbmc.getCondVisibility("system.platform.windows"):
-        ret["os"] = "win"
-        if platform.machine().endswith('64'):
-            ret["arch"] = "x64"
-    elif xbmc.getCondVisibility("system.platform.osx"):
-        ret["os"] = "mac"
-        ret["arch"] = "x64"
-    elif xbmc.getCondVisibility("system.platform.ios"):
-        ret["os"] = "ios"
-        ret["arch"] = "arm"
+        return
 
-    return ret
+    # For all other devices use InputSeream Helper to install or update Widevine
+    from core import filetools
+    from xbmcaddon import Addon
+    addonName = 'script.module.inputstreamhelper'
 
+    def isHelper():
+        # If InputStream Helper is not installed requires installation
+        ret = False
+        if filetools.exists(xbmc.translatePath('special://home/addons/{}'.format(addonName))):
+            ret = True
+        else:
+            xbmc.executebuiltin('InstallAddon({})'.format(addonName), wait=True)
+            try:
+                addon = Addon(id=addonName)
+                ret = True
+            except:
+                pass
+        return ret
+
+    # If InputStream Helper is installed, install or update Widevine
+    if isHelper():
+        addon = Addon(id=addonName)
+        path = filetools.join(addon.getAddonInfo('Path'), 'lib')
+        sys.path.append(path)
+        from inputstreamhelper import Helper
+        helper = Helper('mpd', drm='widevine')
+        if not helper._check_widevine():
+            helper.install_widevine()
 
 
 def get_played_time(item):
@@ -1831,7 +1685,9 @@ def prevent_busy(item=None):
 
 
 def fakeVideo():
-    xbmcplugin.setResolvedUrl(int(sys.argv[1]), True, xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "resources", "kod.mp4")))
+    xbmcplugin.setResolvedUrl(int(sys.argv[1]), True,
+                              xbmcgui.ListItem(path=os.path.join(config.get_runtime_path(), "resources", "kod.mp4")))
+    sleep = 200
     while not is_playing():
-        xbmc.sleep(10)
-    xbmc.Player().stop()
\ No newline at end of file
+        xbmc.sleep(sleep)
+    xbmc.Player().stop()
diff --git a/platformcode/recaptcha.py b/platformcode/recaptcha.py
index d7265d43..154ae631 100644
--- a/platformcode/recaptcha.py
+++ b/platformcode/recaptcha.py
@@ -1,77 +1,211 @@
 # -*- coding: utf-8 -*-
+import sys
+import time
+from threading import Thread
 
-from builtins import range
 import xbmcgui
 from core import httptools
-from core import scrapertools
-from platformcode import config
-from platformcode import platformtools
+from core import filetools
+from platformcode import config, platformtools
+from platformcode import logger
+from lib.librecaptcha.recaptcha import ReCaptcha, Solver, DynamicSolver, MultiCaptchaSolver, Solution, \
+    ImageGridChallenge
 
 lang = 'it'
+temp_dir = config.get_temp_file('reCAPTCHA/')
+tiles_pos = (75+390, 90+40)
+grid_width = 450
+tiles_texture_focus = 'white.png'
+tiles_texture_checked = 'Controls/check_mark.png'
+cur_tmp = 0
 
-class Recaptcha(xbmcgui.WindowXMLDialog):
-    def Start(self, key, referer):
-        self.referer = referer
-        self.key = key
-        self.headers = {'Referer': self.referer}
+TITLE = 10
+PANEL = 11
+IMAGE = 12
+CONTROL = 1
 
-        api_js = httptools.downloadpage("https://www.google.com/recaptcha/api.js?hl=" + lang).data
-        version = scrapertools.find_single_match(api_js, 'po.src\s*=\s*\'(.*?)\';').split("/")[5]
-        self.url = "https://www.google.com/recaptcha/api/fallback?k=" + self.key + "&hl=" + lang + "&v=" + version + "&t=2&ff=true"
-        self.doModal()
-        # Reload
-        if self.result == {}:
-            self.result = Recaptcha("Recaptcha.xml", config.get_runtime_path()).Start(self.key, self.referer)
+OK = 21
+CANCEL = 22
+# RELOAD = 23
 
-        return self.result
 
-    def update_window(self):
-        data = httptools.downloadpage(self.url, headers=self.headers).data
-        self.message = scrapertools.find_single_match(data,
-                                                      '<div class="rc-imageselect-desc[a-z-]*">(.*?)(?:</label>|</div>)').replace(
-            "<strong>", "[B]").replace("</strong>", "[/B]")
-        self.token = scrapertools.find_single_match(data, 'name="c" value="([^"]+)"')
-        self.image = "https://www.google.com/recaptcha/api2/payload?k=%s&c=%s" % (self.key, self.token)
-        self.result = {}
-        self.getControl(10020).setImage(self.image)
-        self.getControl(10000).setText(self.message)
-        self.setFocusId(10005)
+def get_temp():
+    global cur_tmp
+    cur_tmp += 1
+    if not filetools.isdir(temp_dir):
+        filetools.mkdir(temp_dir)
+    return temp_dir + str(cur_tmp) + '.png'
 
+
+class Kodi:
+    def __init__(self, key, referer):
+        if sys.version_info[0] < 3:
+            self.rc = None
+            platformtools.dialog_ok('reCAPTCHA', 'Il sito sta mostrando la schermata "Non sono un robot".\nQuesta schermata tuttavia è superabile solo da kodi 19')
+        else:
+            prog = platformtools.dialog_progress('Caricamento reCAPTCHA', 'Il sito sta mostrando la schermata "Non sono un robot"')
+            filetools.rmdirtree(temp_dir)
+            self.rc = ReCaptcha(
+                api_key=key,
+                site_url=referer,
+                user_agent=httptools.get_user_agent(),
+                lang=lang
+            )
+            prog.close()
+
+    def run(self):
+        if not self.rc:
+            return None
+        result = self.rc.first_solver()
+        while not isinstance(result, str) and result is not False:
+            solution = self.run_solver(result)
+            if solution:
+                result = self.rc.send_solution(solution)
+                logger.debug(result)
+            else:
+                return False
+        platformtools.dialog_notification("Captcha corretto", "Verifica conclusa")
+        return result
+
+    def run_solver(self, solver: Solver) -> Solution:
+        selected_solver = {
+            DynamicSolver: DynamicKodi,
+            MultiCaptchaSolver: MultiCaptchaKodi,
+        }[type(solver)]("Recaptcha.xml", config.get_runtime_path())
+        selected_solver.solver = solver
+        return selected_solver.run()
+
+
+class SolverKodi(xbmcgui.WindowXMLDialog):
     def __init__(self, *args, **kwargs):
-        self.mensaje = kwargs.get("mensaje")
-        self.imagen = kwargs.get("imagen")
+        self.goal = ""
+        self.closed = False
+        self.result = None
+        self.image_path = ''
+        self.indices = {}
+        self.num_rows = 3
+        self.num_columns = 3
+        self.num_tiles = 9
+        logger.debug()
+
+    def show_image(self, image, goal):
+        self.image_path = get_temp()
+        filetools.write(self.image_path, image)
+        self.goal = goal.replace('<strong>', '[B]').replace('</strong>', '[/B]')
+        self.doModal()
 
     def onInit(self):
-        #### Kodi 18 compatibility ####
-        if config.get_platform(True)['num_version'] < 18:
-            self.setCoordinateResolution(2)
-        self.update_window()
+        logger.debug(self.image_path)
+        items=[]
+        self.getControl(IMAGE).setImage(self.image_path, False)
+        self.getControl(TITLE).setLabel(self.goal)
+
+        for x in range(self.num_tiles):
+            item = xbmcgui.ListItem('')
+            item.setProperty('selected', 'false')
+            items.append(item)
+        self.getControl(PANEL).reset()
+        self.getControl(PANEL).addItems(items)
+
+
+class MultiCaptchaKodi(SolverKodi):
+    """
+    multicaptcha challenges present you with one large image split into a grid of tiles and ask you to select the tiles that contain a given object.
+    Occasionally, the image will not contain the object, but rather something that looks similar.
+    It is possible to select no tiles in this case, but reCAPTCHA may have been fooled by the similar-looking object and would reject a selection of no tiles.
+    """
+    def run(self):
+        result = self.solver.first_challenge()
+        while not isinstance(result, Solution):
+            if not isinstance(result, ImageGridChallenge):
+                raise TypeError("Unexpected type: {}".format(type(result)))
+            indices = self.handle_challenge(result)
+            if self.closed:
+                return False
+            result = self.solver.select_indices(indices)
+        return result
+
+    def handle_challenge(self, challenge: ImageGridChallenge):
+        goal = challenge.goal.plain
+        self.num_rows = challenge.dimensions.rows
+        self.num_columns = challenge.dimensions.columns
+        logger.debug('RIGHE',self.num_rows, 'COLONNE',self.num_columns)
+
+        self.num_tiles = challenge.dimensions.count
+        image = challenge.image
+        self.show_image(image, goal)
+        if self.closed:
+            return False
+        return self.result
 
     def onClick(self, control):
-        if control == 10003:
-            self.result = None
+        if control == CANCEL:
+            self.closed = True
             self.close()
 
-        elif control == 10004:
-            self.result = {}
+        # elif control == RELOAD:
+        #     self.closed = True
+        #     self.close()
+
+        elif control == OK:
+            self.result = [int(k) for k in range(self.num_tiles) if self.indices.get(k, False)]
             self.close()
-
-        elif control == 10002:
-            self.result = [int(k) for k in range(9) if self.result.get(k, False)]
-            post = {
-                "c": self.token,
-                "response": self.result
-            }
-
-            data = httptools.downloadpage(self.url, post=post, headers=self.headers).data
-            from platformcode import logger
-            logger.debug(data)
-            self.result = scrapertools.find_single_match(data, '<div class="fbc-verification-token">.*?>([^<]+)<')
-            if self.result:
-                platformtools.dialog_notification("Captcha corretto", "Verifica conclusa")
-                self.close()
-            else:
-                self.result = {}
-                self.close()
         else:
-            self.result[control - 10005] = not self.result.get(control - 10005, False)
+            item = self.getControl(PANEL)
+            index = item.getSelectedPosition()
+            selected = True if item.getSelectedItem().getProperty('selected') == 'false' else False
+            item.getSelectedItem().setProperty('selected', str(selected).lower())
+            self.indices[index] = selected
+
+
+class DynamicKodi(SolverKodi):
+    """
+    dynamic challenges present you with a grid of different images and ask you to select the images that match the given description.
+    Each time you click an image, a new one takes its place. Usually, three images from the initial set match the description,
+    and at least one of the replacement images does as well.
+    """
+    def run(self):
+        challenge = self.solver.get_challenge()
+        image = challenge.image
+        goal = challenge.goal.raw
+        self.num_rows = challenge.dimensions.rows
+        self.num_columns = challenge.dimensions.columns
+        self.num_tiles = challenge.dimensions.count
+        logger.debug('RIGHE',self.num_rows, 'COLONNE',self.num_columns)
+
+        self.show_image(image, goal)
+        if self.closed:
+            return False
+        return self.result
+
+    def changeTile(self, item, path, delay):
+        cur_delay = delay
+        while cur_delay > 0:
+            # todo: show time
+            item.setLabel('{:.1f}'.format(cur_delay))
+            time.sleep(0.1)
+            cur_delay -= 0.1
+        item.setLabel('')
+        item.setArt({'image': path})
+
+    def onClick(self, control):
+        if control == CANCEL:
+            self.closed = True
+            self.close()
+
+        # elif control == RELOAD:
+        #     self.result = None
+        #     self.close()
+
+        elif control == OK:
+            self.result = self.solver.finish()
+            self.close()
+        else:
+            panel = self.getControl(PANEL)
+            item = panel.getSelectedItem()
+            if not item.getLabel():
+                index = panel.getSelectedPosition()
+                tile = self.solver.select_tile(index)
+                path = get_temp()
+                filetools.write(path, tile.image)
+                Thread(target=self.changeTile, args=(item, path, tile.delay)).start()
diff --git a/platformcode/updater.py b/platformcode/updater.py
index 9c6a1367..8f3c1cea 100644
--- a/platformcode/updater.py
+++ b/platformcode/updater.py
@@ -306,7 +306,7 @@ def updateFromZip(message=config.get_localized_string(80050)):
 
 def refreshLang():
     from platformcode import config
-    language = config.get_localized_string(20001)
+    language = config.get_language()
     if language == 'eng':
         xbmc.executebuiltin("SetGUILanguage(resource.language.it_it)")
         xbmc.executebuiltin("SetGUILanguage(resource.language.en_en)")
diff --git a/platformcode/xbmc_videolibrary.py b/platformcode/xbmc_videolibrary.py
index 23345dbc..21776e75 100644
--- a/platformcode/xbmc_videolibrary.py
+++ b/platformcode/xbmc_videolibrary.py
@@ -34,6 +34,7 @@ def mark_auto_as_watched(item):
         sync = False
         next_episode = None
         show_server = True
+        mark_time = 0
 
         percentage = float(config.get_setting("watched_setting")) / 100
         time_from_end = config.get_setting('next_ep_seconds')
@@ -85,7 +86,7 @@ def mark_auto_as_watched(item):
                 break
 
         # if item.options['continue']:
-        if actual_time < mark_time:
+        if actual_time < mark_time and mark_time:
             item.played_time = actual_time
         else: item.played_time = 0
         platformtools.set_played_time(item)
diff --git a/resources/kod.mp4 b/resources/kod.mp4
index a06928ae..66b7c091 100644
Binary files a/resources/kod.mp4 and b/resources/kod.mp4 differ
diff --git a/resources/language/resource.language.en_gb/strings.po b/resources/language/resource.language.en_gb/strings.po
index 7a276cd0..794753ad 100644
--- a/resources/language/resource.language.en_gb/strings.po
+++ b/resources/language/resource.language.en_gb/strings.po
@@ -4857,7 +4857,7 @@ msgid "Insert page number"
 msgstr ""
 
 msgctxt "#70514"
-msgid ""
+msgid "Notify current view saves"
 msgstr ""
 
 msgctxt "#70515"
diff --git a/resources/language/resource.language.it_it/strings.po b/resources/language/resource.language.it_it/strings.po
index e5e3e7c2..bf8b7ccf 100644
--- a/resources/language/resource.language.it_it/strings.po
+++ b/resources/language/resource.language.it_it/strings.po
@@ -4856,8 +4856,8 @@ msgid "Insert page number"
 msgstr "Inserisci numero di pagina"
 
 msgctxt "#70514"
-msgid ""
-msgstr ""
+msgid "Notify current view saves"
+msgstr "Notifica i salvataggi della vista attuale"
 
 msgctxt "#70515"
 msgid "Completed %s"
diff --git a/resources/settings.xml b/resources/settings.xml
index 6152bcec..6975de39 100644
--- a/resources/settings.xml
+++ b/resources/settings.xml
@@ -136,6 +136,7 @@
         <setting id="enable_library_menu" label="30131" type="bool" default="true"/>
         <setting label="30000" type="lsep"/>
         <setting id="touch_view" label='30002' type="bool" default="false"/>
+        <setting id="viewchange_notify" label='70514' type="bool" default="true"/>
         <!-- View Mode (hidden)-->
         <setting id="skin_name" label='Skin Name' type="text" default="skin.estuary" visible="false"/>
         <setting id="view_mode_home" type="action" label="70009" default= "Default, 0" visible="false"/>
diff --git a/resources/skins/Default/720p/Recaptcha.xml b/resources/skins/Default/720p/Recaptcha.xml
index e25be3f5..3660ffcc 100644
--- a/resources/skins/Default/720p/Recaptcha.xml
+++ b/resources/skins/Default/720p/Recaptcha.xml
@@ -1,223 +1,245 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version='1.0' encoding='utf-8'?>
 <window>
     <allowoverlays>false</allowoverlays>
-    <animation type="WindowOpen" reversible="false">
-      <effect type="zoom" start="80" end="100" center="640,225" delay="160" tween="back" time="240" />
-      <effect type="fade" delay="160" end="100" time="240" />
+    <defaultcontrol>11</defaultcontrol>
+    <animation type='WindowOpen' reversible='false'>
+        <effect type='zoom' start='80' end='100' center='640,225' delay='160' tween='back' time='240' />
+        <effect type='fade' delay='160' end='100' time='240' />
     </animation>
-    <animation type="WindowClose" reversible="false">
-      <effect type="zoom" start="100" end="80" center="640,225" easing="in" tween="back" time="240" />
-      <effect type="fade" start="100" end="0" time="240" />
+    <animation type='WindowClose' reversible='false'>
+        <effect type='zoom' start='100' end='80' center='640,225' easing='in' tween='back' time='240' />
+        <effect type='fade' start='100' end='0' time='240' />
     </animation>
     <controls>
-      <control type="group" id="10001">
-        <top>40</top>
-        <left>390</left>
-        <width>600</width>
-        <height>640</height>
-        <control type="image">
-			<width>510</width>
-			<height>640</height>
-            <left>45</left>
-			<texture>Controls/dialog-bg-solid.png</texture>
+        <control type='group'>
+            <top>40</top>
+            <left>398</left>
+            <width>484</width>
+            <height>640</height>
+            <control type='image'>
+                <width>100%</width>
+                <height>100%</height>
+                <texture colordiffuse='FF232323'>white.png</texture>
+            </control>
+            <control type='image' id='12'>
+                <description>Main Captcha Image</description>
+                <top>90</top>
+                <left>20</left>
+                <width>444</width>
+                <height>444</height>
+            </control>
+            <control type='label' id='10'>
+                <top>20</top>
+                <left>20</left>
+                <height>60</height>
+                <width>444</width>
+                <font>font13</font>
+                <textcolor>FFFFFFFF</textcolor>
+                <wrapmultiline>true</wrapmultiline>
+                <align>center</align>
+                <aligny>center</aligny>
+                <label></label>
+            </control>
+            <control type='panel' id='11'>
+                <left>20</left>
+                <top>90</top>
+                <ondown>21</ondown>
+                <itemlayout height='148' width='148' condition='Integer.IsEqual(Container(11).NumItems, 9)'>
+                    <control type='image'>
+                        <description>Override Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture>$INFO[ListItem.Art(image)]</texture>
+                    </control>
+                    <control type='image'>
+                        <description>Focused</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture colordiffuse='FFFFFFFF' border='2'>selection.png</texture>
+                    </control>
+                    <control type='image'>
+                        <visible>!String.IsEmpty(ListItem.Label)</visible>
+                        <description>Hide Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture colordiffuse='88000000'>white.png</texture>
+                    </control>
+                    <control type='label'>
+                        <description>Remaining Time</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <font>font13</font>
+                        <textcolor>FFFFFFFF</textcolor>
+                        <label>[B]$INFO[Listitem.Label][/B]</label>
+                        <aligny>center</aligny>
+                        <align>center</align>
+                    </control>
+                    <control type='image'>
+                        <visible>String.IsEqual(ListItem.Property(selected), true)</visible>
+                        <description>Selected Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture>Controls/check_mark.png</texture>
+                    </control>
+                </itemlayout>
+                <itemlayout height='111' width='111'>
+                    <control type='image'>
+                        <description>Override Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture>$INFO[ListItem.Art(image)]</texture>
+                    </control>
+                    <control type='image'>
+                        <description>Focused</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture colordiffuse='FFFFFFFF' border='2'>selection.png</texture>
+                    </control>
+                    <control type='image'>
+                        <visible>!String.IsEmpty(ListItem.Label)</visible>
+                        <description>Hide Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture colordiffuse='88000000'>white.png</texture>
+                    </control>
+                    <control type='label'>
+                        <description>Remaining Time</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <font>font13</font>
+                        <textcolor>FFFFFFFF</textcolor>
+                        <label>[B]$INFO[Listitem.Label][/B]</label>
+                        <aligny>center</aligny>
+                        <align>center</align>
+                    </control>
+                    <control type='image'>
+                        <visible>String.IsEqual(ListItem.Property(selected), true)</visible>
+                        <description>Selected Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture>Controls/check_mark.png</texture>
+                    </control>
+                </itemlayout>
+                <focusedlayout height='148' width='148' condition='Integer.IsEqual(Container(11).NumItems, 9)'>
+                    <control type='image'>
+                        <description>Override Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture>$INFO[ListItem.Art(image)]</texture>
+                    </control>
+                    <control type='image'>
+                        <description>Focused</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture colordiffuse='FF0082C2' border='2'>selection.png</texture>
+                    </control>
+                    <control type='image'>
+                        <description>Focused</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture colordiffuse='550082C2'>white.png</texture>
+                    </control>
+                    <control type='image'>
+                        <visible>!String.IsEmpty(ListItem.Label)</visible>
+                        <description>Hide Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture colordiffuse='88000000'>white.png</texture>
+                    </control>
+                    <control type='label'>
+                        <description>Remaining Time</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <font>font13</font>
+                        <textcolor>FFFFFFFF</textcolor>
+                        <label>[B]$INFO[Listitem.Label][/B]</label>
+                        <aligny>center</aligny>
+                        <align>center</align>
+                    </control>
+                    <control type='image'>
+                        <visible>String.IsEqual(ListItem.Property(selected), true)</visible>
+                        <description>Selected Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture>Controls/check_mark.png</texture>
+                    </control>
+                </focusedlayout>
+                <focusedlayout height='111' width='111'>
+                    <control type='image'>
+                        <description>Override Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture>$INFO[ListItem.Art(image)]</texture>
+                    </control>
+                    <control type='image'>
+                        <description>Focused</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture colordiffuse='880082C2' border='2'>selection.png</texture>
+                    </control>
+                    <control type='image'>
+                        <description>Focused</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture colordiffuse='550082C2'>white.png</texture>
+                    </control>
+                    <control type='image'>
+                        <visible>!String.IsEmpty(ListItem.Label)</visible>
+                        <description>Hide Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture colordiffuse='88000000'>white.png</texture>
+                    </control>
+                    <control type='label'>
+                        <description>Remaining Time</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <font>font13</font>
+                        <textcolor>FFFFFFFF</textcolor>
+                        <label>[B]$INFO[Listitem.Label][/B]</label>
+                        <aligny>center</aligny>
+                        <align>center</align>
+                    </control>
+                    <control type='image'>
+                        <visible>String.IsEqual(ListItem.Property(selected), true)</visible>
+                        <description>Selected Image</description>
+                        <width>100%</width>
+                        <height>100%</height>
+                        <texture>Controls/check_mark.png</texture>
+                    </control>
+                </focusedlayout>
+            </control>
+            <control type='grouplist'>
+                <top>565</top>
+                <left>20</left>
+                <orientation>horizontal</orientation>
+                <control type='button' id='21'>
+                    <width>222</width>
+                    <height>50</height>
+                    <onup>11</onup>
+                    <textwidth>110</textwidth>
+                    <textcolor>FFFFFFFF</textcolor>
+                    <focusedcolor>FFFFFFFF</focusedcolor>
+                    <texturefocus colordiffuse='FF0082C2'>white.png</texturefocus>
+                    <texturenofocus colordiffuse='000082C2'>white.png</texturenofocus>
+                    <align>center</align>
+                    <aligny>center</aligny>
+                    <label>$ADDON[plugin.video.kod 70007]</label>
+                </control>
+                <control type='button' id='22'>
+                    <width>222</width>
+                    <height>50</height>
+                    <onup>11</onup>
+                    <textwidth>110</textwidth>
+                    <textcolor>FFFFFFFF</textcolor>
+                    <focusedcolor>FFFFFFFF</focusedcolor>
+                    <texturefocus colordiffuse='FF0082C2'>white.png</texturefocus>
+                    <texturenofocus colordiffuse='000082C2'>white.png</texturenofocus>
+                    <align>center</align>
+                    <aligny>center</aligny>
+                    <label>$ADDON[plugin.video.kod 707433]</label>
+                </control>
+            </control>
         </control>
-		<control type="textbox" id="10000">
-          <top>30</top>
-          <left>20</left>
-          <height>60</height>
-          <width>560</width>
-          <font>font13</font>
-          <textcolor>FFFFFFFF</textcolor>
-          <wrapmultiline>true</wrapmultiline>
-          <align>center</align>
-          <label></label>
-        </control>
-        <control type="button" id="10002">
-            <top>565</top>
-            <left>75</left>
-            <width>150</width>
-            <height>50</height>
-            <textwidth>110</textwidth>
-            <textcolor>FFFFFFFF</textcolor>
-            <focusedcolor>FFFFFFFF</focusedcolor>
-            <texturefocus colordiffuse="FF0082C2">white.png</texturefocus>
-            <texturenofocus colordiffuse="000082C2">white.png</texturenofocus>
-            <align>center</align>
-            <aligny>center</aligny>
-            <label>$ADDON[plugin.video.kod 70007]</label>
-            <onup>10011</onup>
-			<ondown>10005</ondown>
-			<onleft>10004</onleft>
-			<onright>10003</onright>
-        </control>
-        <control type="button" id="10003">
-            <top>565</top>
-            <left>225</left>
-            <width>150</width>
-            <height>50</height>
-            <textwidth>110</textwidth>
-            <textcolor>FFFFFFFF</textcolor>
-            <focusedcolor>FFFFFFFF</focusedcolor>
-            <texturefocus colordiffuse="FF0082C2">white.png</texturefocus>
-            <texturenofocus colordiffuse="000082C2">white.png</texturenofocus>
-            <align>center</align>
-            <aligny>center</aligny>
-            <label>$ADDON[plugin.video.kod 707433]</label>
-            <onup>10012</onup>
-			<ondown>10006</ondown>
-			<onleft>10002</onleft>
-			<onright>10004</onright>
-        </control>
-        <control type="button" id="10004">
-            <top>565</top>
-            <left>375</left>
-            <width>150</width>
-            <height>50</height>
-            <textwidth>110</textwidth>
-            <textcolor>FFFFFFFF</textcolor>
-            <focusedcolor>FFFFFFFF</focusedcolor>
-            <texturefocus colordiffuse="FF0082C2">white.png</texturefocus>
-            <texturenofocus colordiffuse="000082C2">white.png</texturenofocus>
-            <align>center</align>
-            <aligny>center</aligny>
-            <label>$ADDON[plugin.video.kod 70008]</label>
-            <onup>10013</onup>
-			<ondown>10007</ondown>
-			<onleft>10003</onleft>
-			<onright>10002</onright>
-        </control>
-        <control type="image" id="10020">
-            <top>90</top>
-            <left>75</left>
-            <width>450</width>
-            <height>450</height>
-        </control>
-        <control type="togglebutton" id="10005">
-            <top>90</top>
-            <left>75</left>
-            <width>150</width>
-            <height>150</height>
-            <texturefocus colordiffuse="AA232323">white.png</texturefocus>
-            <texturenofocus colordiffuse="00232323">white.png</texturenofocus>
-		    <alttexturefocus colordiffuse="FF0082C2">Controls/check_mark.png</alttexturefocus>
-		    <alttexturenofocus colordiffuse="FFFFFFFF">Controls/check_mark.png</alttexturenofocus>
-			<onup>10002</onup>
-			<ondown>10008</ondown>
-			<onleft>10007</onleft>
-			<onright>10006</onright>
-		</control>
-        <control type="togglebutton" id="10006">
-            <top>90</top>
-            <left>225</left>
-            <width>150</width>
-            <height>150</height>
-            <texturefocus colordiffuse="AA232323">white.png</texturefocus>
-            <texturenofocus colordiffuse="00232323">white.png</texturenofocus>
-		    <alttexturefocus colordiffuse="FF0082C2">Controls/check_mark.png</alttexturefocus>
-		    <alttexturenofocus colordiffuse="FFFFFFFF">Controls/check_mark.png</alttexturenofocus>
-			<onup>10003</onup>
-			<ondown>10009</ondown>
-			<onleft>10005</onleft>
-			<onright>10007</onright>
-		</control>
-        <control type="togglebutton" id="10007">
-            <top>90</top>
-            <left>375</left>
-            <width>150</width>
-            <height>150</height>
-            <texturefocus colordiffuse="AA232323">white.png</texturefocus>
-            <texturenofocus colordiffuse="00232323">white.png</texturenofocus>
-		    <alttexturefocus colordiffuse="FF0082C2">Controls/check_mark.png</alttexturefocus>
-		    <alttexturenofocus colordiffuse="FFFFFFFF">Controls/check_mark.png</alttexturenofocus>
-			<onup>10004</onup>
-			<ondown>10010</ondown>
-			<onleft>10006</onleft>
-			<onright>10005</onright>
-		</control>
-        <control type="togglebutton" id="10008">
-            <top>240</top>
-            <left>75</left>
-            <width>150</width>
-            <height>150</height>
-            <texturefocus colordiffuse="AA232323">white.png</texturefocus>
-            <texturenofocus colordiffuse="00232323">white.png</texturenofocus>
-		    <alttexturefocus colordiffuse="FF0082C2">Controls/check_mark.png</alttexturefocus>
-		    <alttexturenofocus colordiffuse="FFFFFFFF">Controls/check_mark.png</alttexturenofocus>
-			<onup>10005</onup>
-			<ondown>10011</ondown>
-			<onleft>10010</onleft>
-			<onright>10009</onright>
-		</control>
-        <control type="togglebutton" id="10009">
-            <top>240</top>
-            <left>225</left>
-            <width>150</width>
-            <height>150</height>
-            <texturefocus colordiffuse="AA232323">white.png</texturefocus>
-            <texturenofocus colordiffuse="00232323">white.png</texturenofocus>
-		    <alttexturefocus colordiffuse="FF0082C2">Controls/check_mark.png</alttexturefocus>
-		    <alttexturenofocus colordiffuse="FFFFFFFF">Controls/check_mark.png</alttexturenofocus>
-			<onup>10006</onup>
-			<ondown>10012</ondown>
-			<onleft>10008</onleft>
-			<onright>10010</onright>
-		</control>
-        <control type="togglebutton" id="10010">
-            <top>240</top>
-            <left>375</left>
-            <width>150</width>
-            <height>150</height>
-            <texturefocus colordiffuse="AA232323">white.png</texturefocus>
-            <texturenofocus colordiffuse="00232323">white.png</texturenofocus>
-		    <alttexturefocus colordiffuse="FF0082C2">Controls/check_mark.png</alttexturefocus>
-		    <alttexturenofocus colordiffuse="FFFFFFFF">Controls/check_mark.png</alttexturenofocus>
-			<onup>10007</onup>
-			<ondown>10013</ondown>
-			<onleft>10009</onleft>
-			<onright>10008</onright>
-		</control>
-        <control type="togglebutton" id="10011">
-            <top>390</top>
-            <left>75</left>
-            <width>150</width>
-            <height>150</height>
-            <texturefocus colordiffuse="AA232323">white.png</texturefocus>
-            <texturenofocus colordiffuse="00232323">white.png</texturenofocus>
-		    <alttexturefocus colordiffuse="FF0082C2">Controls/check_mark.png</alttexturefocus>
-		    <alttexturenofocus colordiffuse="FFFFFFFF">Controls/check_mark.png</alttexturenofocus>
-			<onup>10008</onup>
-			<ondown>10002</ondown>
-			<onleft>10013</onleft>
-			<onright>10012</onright>
-		</control>
-        <control type="togglebutton" id="10012">
-            <top>390</top>
-            <left>225</left>
-            <width>150</width>
-            <height>150</height>
-            <texturefocus colordiffuse="AA232323">white.png</texturefocus>
-            <texturenofocus colordiffuse="00232323">white.png</texturenofocus>
-		    <alttexturefocus colordiffuse="FF0082C2">Controls/check_mark.png</alttexturefocus>
-		    <alttexturenofocus colordiffuse="FFFFFFFF">Controls/check_mark.png</alttexturenofocus>
-			<onup>10009</onup>
-			<ondown>10003</ondown>
-			<onleft>10011</onleft>
-			<onright>10013</onright>
-		</control>
-        <control type="togglebutton" id="10013">
-            <top>390</top>
-            <left>375</left>
-            <width>150</width>
-            <height>150</height>
-            <texturefocus colordiffuse="AA232323">white.png</texturefocus>
-            <texturenofocus colordiffuse="00232323">white.png</texturenofocus>
-		    <alttexturefocus colordiffuse="FF0082C2">Controls/check_mark.png</alttexturefocus>
-		    <alttexturenofocus colordiffuse="FFFFFFFF">Controls/check_mark.png</alttexturenofocus>
-			<onup>10010</onup>
-			<ondown>10004</ondown>
-			<onleft>10012</onleft>
-			<onright>10011</onright>
-		</control>
-	  </control>
     </controls>
 </window>
\ No newline at end of file
diff --git a/resources/skins/Default/media/selection.png b/resources/skins/Default/media/selection.png
new file mode 100644
index 00000000..7fd32258
Binary files /dev/null and b/resources/skins/Default/media/selection.png differ
diff --git a/servers/maxstream.json b/servers/maxstream.json
index 30ed5e50..a42d9381 100644
--- a/servers/maxstream.json
+++ b/servers/maxstream.json
@@ -4,12 +4,8 @@
     "ignore_urls": [],
     "patterns": [
       {
-        "pattern": "(https?://maxstream.video/uprot/[a-zA-Z0-9]+)",
+        "pattern": "(https?://maxstream.video/(?:[^/]+/)?([a-zA-Z0-9]+))",
         "url": "\\1"
-      },
-      {
-        "pattern": "https?://maxstream.video/(?:e/|embed-|cast/)?([a-z0-9]+)",
-        "url": "http://maxstream.video/\\1"
       }
     ]
   },
diff --git a/servers/maxstream.py b/servers/maxstream.py
index 3f939d7c..df23441b 100644
--- a/servers/maxstream.py
+++ b/servers/maxstream.py
@@ -1,99 +1,114 @@
-# -*- coding: utf-8 -*-
-# --------------------------------------------------------
-# Conector MaxStream
-# --------------------------------------------------------
-import ast, sys
+# sorry for obfuscation, it's for making a little more difficult for maxstream owner to counter this
 
-import requests
-
-from core import httptools, scrapertools, support
-from lib import jsunpack
-from platformcode import logger, config, platformtools
-if sys.version_info[0] >= 3:
-    import urllib.parse as urlparse
-else:
-    import urlparse
-
-
-def test_video_exists(page_url):
-    logger.debug("(page_url='%s')" % page_url)
-
-    global data
-    if 'uprot/' in page_url:
-        id = httptools.downloadpage(page_url, follow_redirects=False, cloudscraper=True).headers.get('location').split('/')[-1]
-    else:
-        id = page_url.split('/')[-1]
-    page_url = requests.head('http://lozioangie.altervista.org/max_anticaptcha.php?id=' + id).headers.get('location')
-    data = httptools.downloadpage(page_url, cloudscraper=True).data
-
-    if scrapertools.find_single_match(data, '(?<!none);[^>]*>file was deleted'):
-        return False, config.get_localized_string(70449) % "MaxStream"
-
-    return True, ""
-
-
-def get_video_url(page_url, premium=False, user="", password="", video_password=""):
-    logger.debug("url=" + page_url)
-    video_urls = []
-    global data
-    if 'captcha' in data:
-        httptools.set_cookies(requests.get('http://lozioangie.altervista.org/maxcookie.php').json())
-        data = httptools.downloadpage(page_url, cloudscraper=True).data
-
-    # sitekey = scrapertools.find_multiple_matches(data, """data-sitekey=['"] *([^"']+)""")
-    # if sitekey: sitekey = sitekey[-1]
-    # captcha = platformtools.show_recaptcha(sitekey, page_url) if sitekey else ''
-    #
-    # possibleParam = scrapertools.find_multiple_matches(data,
-    #                                                    r"""<input.*?(?:name=["']([^'"]+).*?value=["']([^'"]*)['"]>|>)""")
-    # if possibleParam:
-    #     post = {param[0]: param[1] for param in possibleParam if param[0]}
-    #     if captcha: post['g-recaptcha-response'] = captcha
-    #     if post:
-    #         data = httptools.downloadpage(page_url, post=post, follow_redirects=True, verify=False).data
-    # else:
-    #     platformtools.dialog_ok(config.get_localized_string(20000), config.get_localized_string(707434))
-    #     return []
-
-    packed = support.match(data, patron=r"(eval\(function\(p,a,c,k,e,d\).*?)\s*</script").match
-    if packed:
-        data = jsunpack.unpack(packed)
-    url = scrapertools.find_single_match(data, 'src:\s*"([^"]+)')
-    if url:
-        video_urls.append(['m3u8 [MaxStream]', url])
-    return video_urls
-    # support.dbg()
-    # possible_cast_url = support.match('http://maxstream.video/?op=page&tmpl=../../download1', patron='<a[^<]+href="(?:https://maxstream\.video/)?([^".?]+/)"').matches
-    # for cast_url in possible_cast_url:
-    #     data = httptools.downloadpage('http://maxstream.video/' + cast_url + page_url.split('/')[-1]).data
-    #     url_video = ''
-    #
-    #     lastIndexStart = data.rfind('<script>')
-    #     lastIndexEnd = data.rfind('</script>')
-    #
-    #     script = data[ (lastIndexStart + len('<script>')):lastIndexEnd ]
-    #
-    #     match = scrapertools.find_single_match(script, r'(\[[^\]]+\])[^\{]*\{[^\(]+\(parseInt\(value\)\s?-\s?([0-9]+)')
-    #     if match:
-    #         char_codes = ast.literal_eval(match[0])
-    #         hidden_js = "".join([chr(c - int(match[1])) for c in char_codes])
-    #
-    #         newurl = scrapertools.find_single_match(hidden_js, r'\$.get\(\'([^\']+)').replace('https://', 'http://')
-    #         castpage = httptools.downloadpage(newurl, headers={'x-requested-with': 'XMLHttpRequest', 'Referer': page_url}).data
-    #         url_video = scrapertools.find_single_match(castpage, r"cc\.cast\('(http[s]?.[^']+)'")
-    #     else:
-    #         logger.debug('Something wrong: no url found before that :(')
-    #
-    #     if url_video and url_video.split('/')[-1] == page_url.split('/')[-1]:
-    #         import random, string
-    #         parse = urlparse.urlparse(url_video)
-    #         video_urls = [['mp4 [MaxStream]', url_video]]
-    #         try:
-    #             r1 = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(19))
-    #             r2 = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(19))
-    #             r3 = ''.join(random.choice(string.ascii_letters + string.digits) for i in range(19))
-    #             video_urls.append(['m3u8 [MaxStream]', '{}://{}/hls/{},{},{},{},.urlset/master.m3u8'.format(parse.scheme, parse.netloc, parse.path.split('/')[1], r1, r2, r3)])
-    #             # video_urls.append(['m3u8 [MaxStream]', '{}://{}/hls/{},wpsc2hllm5g5fkjvslq,4jcc2hllm5gzykkkgha,fmca2hllm5jtpb7cj5q,.urlset/master.m3u8'.format(parse.scheme, parse.netloc, parse.path.split('/')[1])])
-    #         except:
-    #             logger.debug('Something wrong: Impossible get HLS stream')
-    #         return video_urls
+import ast ,sys
+import base64 
+if sys .version_info [0 ]>=3 :
+    import urllib .parse as urlparse 
+else :
+    import urlparse 
+from core import httptools ,scrapertools ,support 
+from lib import jsunpack 
+from platformcode import logger ,config ,platformtools 
+def decode (OOO000OOOO0OOOOOO ):
+ OOO0OOOO0O00OOOOO =[]
+ OOO000000OOO000OO =__name__ 
+ OOO000OOOO0OOOOOO =base64 .urlsafe_b64decode (OOO000OOOO0OOOOOO ).decode ()
+ for OOO0OO0O000OOO0OO in range (len (OOO000OOOO0OOOOOO )):
+  OO0OOOO0O0O0OO000 =OOO000000OOO000OO [OOO0OO0O000OOO0OO %len (OOO000000OOO000OO )]
+  O0OO0O0O00OOOOOO0 =chr ((256 +ord (OOO000OOOO0OOOOOO [OOO0OO0O000OOO0OO ])-ord (OO0OOOO0O0O0OO000 ))%256 )
+  OOO0OOOO0O00OOOOO .append (O0OO0O0O00OOOOOO0 )
+ return "".join (OOO0OOOO0O00OOOOO )
+headers ={decode ('w4jDmMOXw6jCksKzw5rCk8Obw5U='):decode ('w4DDlMOsw5_DkcOew5RdwqLCj8KowpPCnMK-w47Dj8Oiw6vCoMKSwrfDk8OWw6XCncOWw4XCmMKkwqXCm8KFwqLDncOjw5HDl8ONw4rDlMK-wpfDocKQwq3CpsKrwqDCmMKXwo3Cm8KwwrrDisKywr7Cn07DmcOKw6PDmMKUwrnDisOEw5jDosKOwpLCucONw6TDosKbw5LCkMKxwqTCosKiwpPClcKhwqrCl8KgwqfCl8KiwpN7w5zDg8Ohw5_DmcKSwrjDgsOTw5TDl8ObwqXCmsKlwqpcwqDClw==')}
+def test_video_exists (page_url ):
+    logger .debug (page_url )
+    global data ,new_url 
+    new_url =httptools .downloadpage (page_url ,follow_redirects =False ,cloudscraper =True ,alfa_s =True ).headers .get (decode ('w5_DlMOVw5fDmcObw6LCnA=='),page_url )
+    data =httptools .downloadpage (new_url ,cloudscraper =True ,alfa_s =True ).data 
+    if scrapertools .find_single_match (data ,decode ('wpvCpMKuwpfDk8Ohw6HCk8KWwpzDk8ORwrLDj8KPwp_Dk8Ocw5HDl8KWw5zDk8OmTsORw4bDpMOYw6jDl8OJ')):
+        return False ,config .get_localized_string (70449 )%decode ('w4DDhsOqw4nDmcOkw5jCj8Oa')
+    return True ,""
+def get_video_url (page_url ,premium =False ,user ="",password ="",video_password =""):
+    global data ,new_url ,code 
+    page_url =new_url 
+    logger .debug (decode ('w6jDl8OewrM=')+page_url )
+    code =scrapertools .find_single_match (data ,decode ('wpvCpMKsw57DmcOmw6PCocKnwpDCp8Ogw5XDqsOYw5XDn8OYw4bDn8Kkw5vDm8OXwpPDnMKQw5zCosOww6DDhsOOw5LCsMKHw5vDmsKHwpLDqcKPw5nDlsOdwrDClsKbwo3CvMOLwpXDgsKdwp8='))
+    O0OO00OOOOOOO00O0 =httptools .downloadpage (decode ('w5vDmcOmw6bDmMKswqJdw5rDgsOww6bDqMOkw4rDgsOawqHDm8Obw5rDisOhwqLCk8Oaw4PDncOXwqE=')+code +decode ('wqHDjcOmw6PDkQ=='),cloudscraper =True ,alfa_s =True ,headers =headers ).data 
+    O0000000O00O0O000 =httptools .downloadpage (decode ('w5vDmcOmw6bDmMKswqJdw5rDgsOww6bDqMOkw4rDgsOawqHDm8Obw5rDisOhwqLCk8Oaw4PDncOXwqHDk8KYw5vDnsOnw5LCp8Oqw57DmcOmwpnCm8OJw6zDoMOg'),cloudscraper =True ,alfa_s =True ,headers =headers ).data 
+    O0OOOOO0O0OOO00OO =scrapertools .find_multiple_matches (O0OO00OOOOOOO00O0 ,decode ('w5fDhsOmw5fCksOlw5zCosOSw4zDncOswrHDjcKMwoPDisKTwo_CmsORw4PClMKawovCmMKK'))
+    if O0OOOOO0O0OOO00OO :
+        O0OOOOO0O0OOO00OO =O0OOOOO0O0OOO00OO [-1 ]
+        OOOO00O00OO000O00 =platformtools .show_recaptcha (O0OOOOO0O0OOO00OO ,new_url )
+        if not OOOO00O00OO000O00 :
+            platformtools .play_canceled =True 
+            return []
+        OOOO0O0O0000O00OO =scrapertools .find_multiple_matches (data ,decode ('wq_DjsOgw6bDmsOmwqFYwqzCicK3wq3DosOTw5LDhsKqw47Ch8KZw5PCjcONw5FVwo_CvsKjwpzCosKcwqTDl8OOw5_DmsOXwrPDgMKUwprCi8KVwrzDlsKawpbDj8KPworDiMKawofDj8K0w6HCsMKc'))
+        if OOOO0O0O0000O00OO :
+            O00OO000000000000 ={O0000O000OOOO00O0 [0 ]:O0000O000OOOO00O0 [1 ]for O0000O000OOOO00O0 in OOOO0O0O0000O00OO if O0000O000OOOO00O0 [0 ]}
+            if OOOO00O00OO000O00 :O00OO000000000000 [decode ('w5rCksOkw5vDiMOTw6PCosOQw4nDmcKgw6bDl8OYw5HDnMOhw5jDlw==')]=OOOO00O00OO000O00 
+            if O00OO000000000000 :
+                data =httptools .downloadpage (page_url ,post =O00OO000000000000 ,follow_redirects =True ,cloudscraper =True ,alfa_s =True ,headers =headers ).data 
+        else :
+            platformtools .dialog_ok (config .get_localized_string (20000 ),config .get_localized_string (707434 ))
+            return []
+    try :
+        O0O0O00000000OOOO =method_1 (O0OO00OOOOOOO00O0 )
+        O0OO000OO0000O00O =method_1 (O0000000O00O0O000 )
+        if not O0O0O00000000OOOO or O0O0O00000000OOOO [0 ][1 ].split (decode ('wp8='))[0 ]==O0OO000OO0000O00O [0 ][1 ].split (decode ('wp8='))[0 ]:
+            O0O0O00000000OOOO =method_1 (data )
+            O0OO000OO0000O00O =method_1 (httptools .downloadpage (decode ('w5vDmcOmw6bDmMKswqJdw5rDgsOww6bDqMOkw4rDgsOawqHDm8Obw5rDisOhwqLCj8Kgw5vDqcOnw6HCp8OZw5rDlMOmw5A='),cloudscraper =True ,alfa_s =True ).data )
+    except :
+        O0O0O00000000OOOO =[]
+        O0OO000OO0000O00O =[]
+        pass
+    if not O0O0O00000000OOOO or (O0OO000OO0000O00O and O0O0O00000000OOOO[0][1].split(decode ('wp8='))[0] == O0OO000OO0000O00O[0][1].split(decode ('wp8='))[0]):
+        O0O0O00000000OOOO =method_2 ()
+    if not O0O0O00000000OOOO :
+        O0O0O00000000OOOO =method_3 ()
+    return O0O0O00000000OOOO 
+def method_1 (O0O000OO00OOO0OOO ):
+    OOOOO0O00OOOO0OOO =support .match (O0O000OO00OOO0OOO ,patron =decode ('wpvDisOow5fDkcOOwpvClMOiw4_Dm8Onw53DocOTwr3ClcOjwpHDk8Kiw4jCnsOeWsOSwo3DnMOPwp3CoMKPwqDClsOPw5jCnMKywpTDpcOWwqDDlsORw6w=')).matches 
+    if OOOOO0O00OOOO0OOO and len (OOOOO0O00OOOO0OOO )==1 :
+        O0O0O00O00OO0O0O0 =jsunpack .unpack (OOOOO0O00OOOO0OOO [0 ])
+        O0OOO0OOO00O000OO =scrapertools .find_single_match (O0O0O00O00OO0O0O0 ,decode ('w6bDl8OVwrDDgcOlwp1QwpXCvMOWwpXDkcKdwo4='))
+        if O0OOO0OOO00O000OO :
+            return [[decode ('w6DCmMOnwq7ChcONw4DCj8OlwrTDrMOlw5nDk8OSwr4='),O0OOO0OOO00O000OO ]]
+    return []
+def method_2 ():
+    global data ,new_url ,code 
+    O000O0O000O0OOO0O =support .match (data ,patron =decode ('wq_DhsONw5TCocOPwp7ClsOfw4bDnsKwwpbCmsKkwpvDlcOnw5nDosOpwp_CocKiwpvDjsOZw6vDp8Omw5fDhsOOw4nCocObw5vDmsOKw6HColfCrMKJw5PDkcKWwqDCpMK-wpjCosKO')).matches 
+    for OOOO0O00OO0OOO00O in O000O0O000O0OOO0O :
+        if OOOO0O00OO0OOO00O ==decode ('w5vDmcOmw6bDmMKswqJd'):
+            continue 
+        data =httptools .downloadpage (decode ('w5vDmcOmw6bCn8KhwqLCm8OOw5nDq8Onw6bDl8OGw47Cm8Opw47DlsObw5TCoQ==')+OOOO0O00OO0OOO00O +code ,cloudscraper =True ,alfa_s =True ).data 
+        OO00OO00O00000O0O =""
+        O0OOO0O00O0000O00 =data .rfind (decode ('wq_DmMOVw6jDjsOiw6ds'))
+        O00OO0O0000O000OO =data .rfind (decode ('wq_ClMOlw5nDl8Obw6PCosKr'))
+        O000OOO0O0000OOO0 =data [(O0OOO0O00O0000O00 +len (decode ('wq_DmMOVw6jDjsOiw6ds'))):O00OO0O0000O000OO ]
+        O0O0O000O00O0OOO0 =scrapertools .find_single_match (O000OOO0O0000OOO0 ,decode ('wpvDgcONw5HDg8OOw5DCi8KYwr3DlcKcw4_DkMOBw5zDisKdw4HDrcORw4PDjsKbwovCmMK9wqDDo8OVw6TDmMOGwrbDocOZw47CnsObw5PDn8Kjw5LCvcKhw4_Dp8KxwpLCvcOgwrLCjcONwqbCksKrw5BZwpY='))
+        if O0O0O000O00O0OOO0 :
+            O000OOOO0OO0OO000 =ast .literal_eval (O0O0O000O00O0OOO0 [0 ])
+            O0O0O0OO0O00O00OO ="".join ([chr (OO000O00OOO0O00O0 -int (O0O0O000O00O0OOO0 [1 ]))for OO000O00OOO0O00O0 in O000OOOO0OO0OO000 ])
+            O0OOOO0O00O00OOO0 =scrapertools .find_single_match (O0O0O0OO0O00O00OO ,decode ('w4_CicKgw53DisOmw49Ww4nCiMKgw47DksOOwozCvsKYwpw=')).replace (decode ('w5vDmcOmw6bDmMKswqJd'),decode ('w5vDmcOmw6bCn8KhwqI='))
+            OO0O00OOOO0OO0O00 =httptools .downloadpage (O0OOOO0O00O00OOO0 ,headers ={decode ('w6vCksOkw5vDlsOnw5jCocOhw4bDnMKgw6vDm8OZw4k='):decode ('w4vCssK-wr7DmcOmw6PCgMOSw5LDrcOYw6fDpg=='),decode ('w4XDisOYw5vDl8OXw6U='):new_url },cloudscraper =True ,alfa_s =True ).data 
+            OO00OO00O00000O0O =scrapertools .find_single_match (OO0O00OOOO0OO0O00 ,decode ('w5bDiMOOwqTDiMOTw6bCosOJwonCn8Kbw5zDpsOZw5HDiMOmw4LCscKkw4DDkMKawovCmMKKwp8='))
+        else :
+            logger .debug (decode ('w4bDlMOfw5vDmcOaw5zCnMOUwoHDr8Olw6PDoMOMwpvCjcOhw5TCksOrw5fDnsKTwpTDnMOWw6bDl8KUw5TDisOHw5zDpcOKwpLDqsONw5PDp07Cp8KJ'))
+        if OO00OO00O00000O0O and OO00OO00O00000O0O .split (decode ('wqI='))[-1 ]==code :
+            import random ,string 
+            O0000000O00OOOOO0 =urlparse .urlparse (OO00OO00O00000O0O )
+            O00O0O0O0OOOO0O0O =[[decode ('w6DDlcKmwpbDgMK_w5TCpsOAw5XDqsOYw5XDn8OC'),OO00OO00O00000O0O ]]
+            try :
+                O000O000O0O000OO0 ="".join (random .choice (string .ascii_letters +string .digits )for O00OO0O000O0OO0OO in range (19 ))
+                OOO000O0O0O000OO0 ="".join (random .choice (string .ascii_letters +string .digits )for O0OO000O0OO0O0000 in range (19 ))
+                O0O0O0O000O0OO00O ="".join (random .choice (string .ascii_letters +string .digits )for OOOOOOO00OOOO0O0O in range (19 ))
+                O00O0O0O0OOOO0O0O .append ([decode ('w6DCmMOnwq7ChcONw4DCj8OlwrTDrMOlw5nDk8OSwr4='),decode ('w67DosKswqXClMOtw7Bdw5XDjcOrwqLDr8OvwpHDnMOqwp_DoMOvwqLDoMOvwp9cw6LDk8Okw6bDmcOmwpTDjsOOw6bDmcOXw6jCk8OfwqbCo8Kl').format (O0000000O00OOOOO0 .scheme ,O0000000O00OOOOO0 .netloc ,O0000000O00OOOOO0 .path .split (decode ('wqI='))[1 ],O000O000O0O000OO0 ,OOO000O0O0O000OO0 ,O0O0O0O000O0OO00O )])
+            except :
+                logger .debug (decode ('w4bDlMOfw5vDmcOaw5zCnMOUwoHDr8Olw6PDoMOMwpvCjcK8w5LDosOlw5jDpcOcwpDDmcOGwpjDmsOZw6bChcKpwrnDhsKFw6XDqsOXw5fDlMKb'))
+    return []
+def method_3 ():
+    httptools .set_cookies ({decode ('w6HDhsOfw5s='):decode ('w5fDnA=='),decode ('w6nDhsOew6vDig=='):decode ('wqQ='),decode ('w5fDlMOfw5fDjsOg'):decode ('w6DDhsOqw6nDmcOkw5jCj8Oawo_DrsOcw5jDl8OU')},False )
+    OOOO0OOOO0000OOO0 =httptools .downloadpage (decode ('w5vDmcOmw6bDmMKswqJdw5rDgsOww6bDqMOkw4rDgsOawqHDm8Obw5rDisOhwqLCksOcw5jDpsOfw6PDk8OJwpDDlsOhw5jDm8Oaw4rDmMOlwpPDksOZwqbDo8Ocw6LCpMOJw6bDn8Ki')+base64 .b64encode (decode ('wqjClcKiw7LDoMOv').format (code ).encode ()).decode (),timeout =10 ,cloudscraper =True ,alfa_s =True ,headers ={decode ('w4vCksOEw5vDlsOnw5jCocOhw4bDnMKgw4vDm8OZw4k='):decode ('w4vCssK-wr7DmcOmw6PCgMOSw5LDrcOYw6fDpg=='),decode ('w4XDisOYw5vDl8OXw6U='):decode ('w5vDmcOmw6bDmMKswqJdw5rDgsOww6bDqMOkw4rDgsOawqHDm8Obw5rDisOhwqLCksKc')+code }).data 
+    OO0OOO000O0O000O0 =scrapertools .find_single_match (OOOO0OOOO0000OOO0 ,decode ('wrfDlMOpw6TDkcOhw5TCksKNwqnDocOaw5zCksKpw4bDk8Ocw5PDm8Oqw47DocOhXMKXwqDCtMOUwpTDmsOXw4bDk8KwwozCmsORw4PCmcOQWcKW'))
+    if OO0OOO000O0O000O0 :
+        return [[decode ('w6DDlcKmwpbDgMK_w5TCpsOAw5XDqsOYw5XDn8OC'),OO0OOO000O0O000O0 ]]
+    return []
diff --git a/servers/torrent.py b/servers/torrent.py
index 51fb8603..672b03e5 100755
--- a/servers/torrent.py
+++ b/servers/torrent.py
@@ -4,9 +4,9 @@ import re, os, sys, time, requests, xbmc, xbmcaddon
 
 from core import filetools, httptools, jsontools
 from core.support import info, match
-from platformcode import config, platformtools
+from platformcode import config, platformtools, logger
 from lib.guessit import guessit
-from torrentool.api import Torrent
+from lib.torrentool.api import Torrent
 
 if sys.version_info[0] >= 3:
     import urllib.parse as urllib
@@ -92,13 +92,15 @@ def elementum_download(item):
             while not filetools.isfile(filetools.join(elementum_setting.getSetting('torrents_path'), TorrentName + '.torrent')):
                 time.sleep(1)
 
-            monitor_update(TorrentPath, TorrentName)
+        monitor_update(TorrentPath, TorrentName)
 
 
 def elementum_monitor():
+    # from core.support import dbg;dbg()
     path = xbmc.translatePath(config.get_setting('downloadlistpath'))
     elementum_setting, elementum_host, TorrentPath = setting()
     # active_torrent = filetools.listdir(TorrentPath)
+    # logger.debug('ELEMENTUM:', elementum_setting, elementum_host, TorrentPath)
 
     if elementum_setting:
         # check if command file exist
@@ -113,10 +115,11 @@ def elementum_monitor():
 
         if len(Monitor) > 0:
             try:
-                data = requests.get(elementum_host + '/list').json()
+                data = requests.get(elementum_host + '/list', timeout=2).json()
             except:
                 data = ''
             if data:
+                # from core.support import dbg;dbg()
                 for it in data:
                     progress = round(it['progress'], 2)
                     status = it['status']
@@ -143,6 +146,7 @@ def monitor_update(TorrentPath, value, remove=False):
     json = jsontools.load(open(monitor, "r").read())
     Monitor = json['monitor']
     info = Torrent.from_file(filetools.join(TorrentPath, value + '.torrent'))
+    logger.debug('ELEMENTUM MONITOR', Monitor)
     path = xbmc.translatePath(config.get_setting('downloadlistpath'))
 
     if not value in Monitor:
@@ -174,13 +178,14 @@ def set_elementum(SET=False):
     backup_setting = json['settings']
     write = False
     if SET:
+        elementum_setting.setSetting('download_storage', '0')  
         if elementum_setting.getSetting('logger_silent') == False or not 'logger_silent' in backup_setting:
             elementum_setting.setSetting('logger_silent', 'true')
             backup_setting['logger_silent'] = 'false'
 
-        if elementum_setting.getSetting('download_storage') != 0 or not 'download_storage' in backup_setting:
-            backup_setting['download_storage'] = elementum_setting.getSetting('download_storage')           # Backup Setting
-            elementum_setting.setSetting('download_storage', '0')                                    # Set Setting
+        # if elementum_setting.getSetting('download_storage') != 0 or not 'download_storage' in backup_setting:
+        #     backup_setting['download_storage'] = elementum_setting.getSetting('download_storage')           # Backup Setting
+        #     elementum_setting.setSetting('download_storage', '0')                                    # Set Setting
 
         if elementum_setting.getSetting('download_path') != config.get_setting('downloadpath') or not 'download_path' in backup_setting:
             backup_setting['download_path'] = elementum_setting.getSetting('download_path')              # Backup Setting
@@ -189,7 +194,8 @@ def set_elementum(SET=False):
 
     elif backup_setting:
         elementum_setting.setSetting('logger_silent', backup_setting['logger_silent'])
-        elementum_setting.setSetting('download_storage', backup_setting['download_storage'])
+        elementum_setting.setSetting('download_storage', '1')
+        # elementum_setting.setSetting('download_storage', backup_setting['download_storage'])
         elementum_setting.setSetting('download_path', backup_setting['download_path'])
         json['settings'] = {}
         write = True
diff --git a/service.py b/service.py
index 922feb36..ce7332c0 100644
--- a/service.py
+++ b/service.py
@@ -400,7 +400,16 @@ class AddonMonitor(xbmc.Monitor):
             self.settings_pre = config.get_all_settings_addon()
 
     def onNotification(self, sender, method, data):
-        if method == 'VideoLibrary.OnUpdate':
+        # logger.debug('METHOD', method, sender, data)
+        if method == 'Playlist.OnAdd':
+            from core import db
+            db['OnPlay']['addon'] = True
+            db.close()
+        elif method == 'Player.OnStop':
+            from core import db
+            db['OnPlay']['addon'] = False
+            db.close()
+        elif method == 'VideoLibrary.OnUpdate':
             xbmc_videolibrary.set_watched_on_kod(data)
             logger.debug('AGGIORNO')
 
@@ -538,7 +547,7 @@ if __name__ == "__main__":
             break
 
         if monitor.waitForAbort(1):  # every second
-            join_threads()
             # db need to be closed when not used, it will cause freezes
             db.close()
+            join_threads()
             break
diff --git a/specials/globalsearch.py b/specials/globalsearch.py
index d5eb8e97..cd17612a 100644
--- a/specials/globalsearch.py
+++ b/specials/globalsearch.py
@@ -8,6 +8,7 @@ from core import channeltools, servertools, scrapertools
 from platformcode import platformtools, config, logger
 from platformcode.launcher import run
 from threading import Thread
+from specials.search import save_search
 
 if sys.version_info[0] >= 3:
     PY3 = True
@@ -28,10 +29,12 @@ def busy(state):
     if state: xbmc.executebuiltin('ActivateWindow(busydialognocancel)')
     else: xbmc.executebuiltin('Dialog.Close(busydialognocancel)')
 
+
 def set_workers():
     workers = config.get_setting('thread_number') if config.get_setting('thread_number') > 0 else None
     return workers
 
+
 def Search(*args):
     xbmc.executebuiltin('Dialog.Close(all)')
     w = SearchWindow('GlobalSearch.xml', config.get_runtime_path())
@@ -119,9 +122,12 @@ class SearchWindow(xbmcgui.WindowXML):
                 if not self.item.text: self.item.text = platformtools.dialog_input(default=last_search, heading='')
                 if self.item.text:
                     channeltools.set_channel_setting('Last_searched', self.item.text, 'search')
-                    from specials.search import save_search
-                    save_search(self.item.text)
-
+                    if self.item.mode == 'all':
+                        save_search(self.item.text)
+        else:
+            if self.item.context:
+                del self.item.context  # needed for preventing same content twice in saved search
+            save_search(self.item.__dict__)
 
     def getActionsThread(self):
         logger.debug()
@@ -186,7 +192,7 @@ class SearchWindow(xbmcgui.WindowXML):
             rating = str(result.get('vote_average', ''))
 
             new_item = Item(channel='globalsearch',
-                            action=True,
+                            action="Search",
                             title=title,
                             thumbnail=thumbnail,
                             fanart=fanart,
@@ -246,8 +252,8 @@ class SearchWindow(xbmcgui.WindowXML):
             discovery = {'url': 'person/%s/combined_credits' % cast_id, 'page': '1', 'sort_by': 'primary_release_date.desc', 'language': def_lang}
             self.persons.append(discovery)
 
-            new_item = Item(channel='search',
-                            action=True,
+            new_item = Item(channel='globalsearch',
+                            action="Search",
                             title=name,
                             thumbnail=thumb,
                             mode='search')
@@ -641,7 +647,7 @@ class SearchWindow(xbmcgui.WindowXML):
                 self.page -= 1
                 self.actors()
             elif search == 'persons':
-                item = self.item.clone(mode='person_', discovery=self.persons[pos])
+                item = Item().fromurl(self.RESULTS.getSelectedItem().getProperty('item')).clone(mode='person_', discovery=self.persons[pos], text=True, folder=False)
                 Search(item, self.thActions)
                 if close_action:
                     self.close()
@@ -649,7 +655,9 @@ class SearchWindow(xbmcgui.WindowXML):
                 item = Item().fromurl(self.RESULTS.getSelectedItem().getProperty('item'))
                 if self.item.mode == 'movie': item.contentTitle = self.RESULTS.getSelectedItem().getLabel()
                 else: item.contentSerieName = self.RESULTS.getSelectedItem().getLabel()
+                item.folder = False
 
+                logger.debug(item)
                 Search(item, self.thActions)
                 if close_action:
                     self.close()
@@ -790,7 +798,6 @@ class SearchWindow(xbmcgui.WindowXML):
             busy(False)
         self.close()
 
-
     def context(self):
         focus = self.getFocusId()
         if focus == EPISODESLIST:  # context on episode
diff --git a/specials/search.py b/specials/search.py
index bbf94837..9b961ac1 100644
--- a/specials/search.py
+++ b/specials/search.py
@@ -77,21 +77,9 @@ def sub_menu(item):
 def saved_search(item):
     logger.debug()
 
-    itemlist = list()
-    saved_searches_list = get_saved_searches()
+    itemlist = get_saved_searches()
 
-
-    for saved_search_text in saved_searches_list:
-        itemlist.append(
-            Item(channel=item.channel if not config.get_setting('new_search') else 'globalsearch',
-                 action="new_search" if not config.get_setting('new_search') else 'Search',
-                 title=typo(saved_search_text.split('{}')[0], 'bold'),
-                 search_text=saved_search_text.split('{}')[0],
-                 text=saved_search_text.split('{}')[0],
-                 mode='all',
-                 thumbnail=get_thumb('search.png')))
-
-    if len(saved_searches_list) > 0:
+    if len(itemlist) > 0:
         itemlist.append(
             Item(channel=item.channel,
                  action="clear_saved_searches",
@@ -807,11 +795,9 @@ def save_search(text):
     if text:
         saved_searches_limit = config.get_setting("saved_searches_limit")
 
-        current_saved_searches_list = config.get_setting("saved_searches_list", "search")
-        if current_saved_searches_list is None:
+        saved_searches_list = config.get_setting("saved_searches_list", "search")
+        if not saved_searches_list:
             saved_searches_list = []
-        else:
-            saved_searches_list = list(current_saved_searches_list)
 
         if text in saved_searches_list:
             saved_searches_list.remove(text)
@@ -824,13 +810,25 @@ def save_search(text):
 def clear_saved_searches(item):
     config.set_setting("saved_searches_list", list(), "search")
     platformtools.dialog_ok(config.get_localized_string(60423), config.get_localized_string(60424))
+    platformtools.itemlist_refresh()
 
 
 def get_saved_searches():
     current_saved_searches_list = config.get_setting("saved_searches_list", "search")
-    if current_saved_searches_list is None:
-        saved_searches_list = []
-    else:
-        saved_searches_list = list(current_saved_searches_list)
+    if not current_saved_searches_list:
+        current_saved_searches_list = []
+    saved_searches_list = []
+    for saved_search_item in current_saved_searches_list:
+        if type(saved_search_item) == str:
+            saved_searches_list.append(
+                Item(channel='search' if not config.get_setting('new_search') else 'globalsearch',
+                     action="new_search" if not config.get_setting('new_search') else 'Search',
+                     title=typo(saved_search_item.split('{}')[0], 'bold'),
+                     search_text=saved_search_item.split('{}')[0],
+                     text=saved_search_item.split('{}')[0],
+                     mode='all',
+                     thumbnail=get_thumb('search.png')))
+        else:
+            saved_searches_list.append(Item().fromjson(json.dumps(saved_search_item)))
 
     return saved_searches_list
diff --git a/specials/videolibrary.py b/specials/videolibrary.py
index 982c161c..b53f4ed5 100644
--- a/specials/videolibrary.py
+++ b/specials/videolibrary.py
@@ -485,7 +485,8 @@ def findvideos(item):
             except ImportError: from urlparse import urlsplit
             try:
                 if urlsplit(item_json.url).netloc.split('.')[0] in channel.host:
-                    item_json.url = channel.host + urlsplit(item_json.url).path
+                    spurl = urlsplit(item_json.url)
+                    item_json.url = channel.host + spurl.path + ('?' + spurl.query if spurl.query else '')
             except: pass
 
             try: