incremental tmp

the heat
whoops, missed dev flag
2021-03-09 03:09:52 +01:00 · 2020-08-12 17:02:54 +02:00 · 2020-08-12 17:01:06 +02:00 · 2020-08-12 16:09:53 +02:00 · 2020-08-08 03:46:57 +02:00 · 2020-07-26 03:12:35 +02:00
289 changed files with 152095 additions and 1221 deletions
@@ -1,3 +1,200 @@
+2.6.5.3217
+
+subscene, addic7ed
+- either of those providers might impose a reCAPTCHA verification. In order to use those providers, please create an account at an AntiCaptcha service ([anti-captcha.com](http://getcaptchasolution.com/kkvviom7nh) or [deathbycaptcha.com](http://deathbycaptcha.com)), add funds, then supply your credentials/apikey in the configuration
+
+Changelog
+- core: also extract (missing) embedded subtitles when SearchAllRecentlyAddedMissing is running
+- core: core: clarify detecting streams (in logs)
+- core: UnRAR: set binary to executable, even if not checked out from git; might fix #693
+- core: bazarr-backport: morpheus65535/bazarr#703: use proper language code detection instead of a wild guess; should fix bad existing subtitle detection
+- core: bazarr-backport: morpheus65535/bazarr#660: fix BOM encoding stuff
+- core: bazarr-backport: morpheus65535/bazarr#656 further generalize formats; skip release group match if format match failed
+- core: fix stream detection when using mediainfo (#711)
+- config/core: make periodic SZ-internal subtitle maintenance interval configurable
+- providers: add BSPlayer Subtitles
+- providers: add ScrewZira (Hebrew)
+
+2.6.5.3183
+
+subscene, addic7ed
+- either of those providers might impose a reCAPTCHA verification. In order to use those providers, please create an account at an AntiCaptcha service ([anti-captcha.com](http://getcaptchasolution.com/kkvviom7nh) or [deathbycaptcha.com](http://deathbycaptcha.com)), add funds, then supply your credentials/apikey in the configuration
+
+Changelog
+- core: don't fall back to default providers if none enabled
+- core: don't process any further if stream info is missing
+- core: support using mediainfo for retrieving MP4 MOV_TEXT subtitle stream titles (PMS bug)
+- core: fix embedded subtitle extraction in some cases (#681, #680)
+- core: scanning: add additional INFO logging for undetected languages
+- core: bazarr-backport: remove existing subtitle file, to support MergerFS
+- core: bazarr-backport: generic 10 minute throttling if uncaught exception occurs
+- providers: addic7ed: fix recaptcha solving; fix show ID retrieval (#681)
+- providers: addic7ed: add timeout on authentication error
+- providers: addic7ed: fix shows with dots in them (Mayans M.C.)
+- providers: addic7ed: fix detection of completed subtitle for non-english users (#686)
+- providers: addic7ed: add more timeouts in the login process
+- providers: argenteam: bazarr-backport: use new url; fixes
+
+
+2.6.5.3152
+
+subscene, addic7ed
+- either of those providers might impose a reCAPTCHA verification. In order to use those providers, please create an account at an AntiCaptcha service ([anti-captcha.com](http://getcaptchasolution.com/kkvviom7nh) or [deathbycaptcha.com](http://deathbycaptcha.com)), add funds, then supply your credentials/apikey in the configuration
+
+Changelog
+- core: fix core issue possibly impacting results on OpenSubtitles in certain conditions
+- core: fix default values of opensubtitles-skip-wrong-fps, use_https; fix #676
+- core: fix for determining whether to search under certain circumstances; fixes #666
+- core: #664 fix missing language processing of multiple videos refreshed at once
+- core: #661 fix match strictness when determining preexisting external subtitles
+- providers: titlovi: New implementation of Titlovi using API (thanks @viking1304)
+
+
+2.6.5.3124
+
+subscene, addic7ed and titlovi
+- either of those providers might impose a reCAPTCHA verification. In order to use those providers, please create an account at an AntiCaptcha service ([anti-captcha.com](http://getcaptchasolution.com/kkvviom7nh) or [deathbycaptcha.com](http://deathbycaptcha.com)), add funds, then supply your credentials/apikey in the configuration
+
+Changelog
+- core: http: fallback to default DNS when normal resolving fails; fixes #657
+- core: extract embedded/menu: fix detection of unknown streams; don't use unknown streams if a known language was previously found
+- core: language: use replacement map from bazarr
+- providers: titlovi: fix matching
+- providers: subscene: fix unknown language code error when "empty" result is returned
+- providers: subscene: add support for pt-BR (based on Diaoul/subliminal@b22cf08)
+- providers: subscene: explicitly set account filters for languages
+- providers: subscene: limit alternative searches to 3; set throttle to 8
+- providers: subscene: move login/cookies to initialization sequence
+- submod: generic: en: fix ";='s
+
+
+2.6.5.3109
+
+subscene, addic7ed and titlovi
+- either of those providers might impose a reCAPTCHA verification. In order to use those providers, please create an account at an AntiCaptcha service ([anti-captcha.com](http://getcaptchasolution.com/kkvviom7nh) or [deathbycaptcha.com](http://deathbycaptcha.com)), add funds, then supply your credentials/apikey in the configuration
+
+Changelog
+- providers: add Napisy24 (polish)
+- providers: subscene: reduce provider load by possibly half
+- providers: subscene: support logging in (username/password are now required)
+- providers: subscene: fallback to non year results if none found with year
+
+
+2.6.5.3099
+
+subscene, addic7ed and titlovi
+- either of those providers might impose a reCAPTCHA verification. In order to use those providers, please create an account at an AntiCaptcha service ([anti-captcha.com](http://getcaptchasolution.com/kkvviom7nh) or [deathbycaptcha.com](http://deathbycaptcha.com)), add funds, then supply your credentials/apikey in the configuration
+
+Changelog
+- core: allow system DNS again by putting "system" as the DNS
+- providers: subscene: fix again (subscene, contact us please, so we can end this)
+
+
+2.6.5.3092
+
+subscene, addic7ed and titlovi
+- either of those providers might impose a reCAPTCHA verification. In order to use those providers, please create an account at an AntiCaptcha service ([anti-captcha.com](http://getcaptchasolution.com/kkvviom7nh) or [deathbycaptcha.com](http://deathbycaptcha.com)), add funds, then supply your credentials/apikey in the configuration
+
+Changelog
+- providers: subscene: fix endpoint (hopefully for longer now)
+- providers: subscene: don't search for season packs (broken for now; relieves 50% of server load on provider)
+- providers: subscene: don't calculate video fn for now
+- providers: argenteam: backport fixes from bazarr
+- subtitle: try decoding with utf-16 by default as well (zho/farsi)
+- submod: HI: remove music tags by default
+- core: compat (bazarr): add env var SZ_KEEP_ENCODING to keep encoding of subtitles
+
+
+2.6.5.3074
+
+Changelog
+- core: cf: bypass cf 95% of the time without captchas
+- core: fix breaking line endings of certain languages (chinese, UTF-16); fixes #646
+- core: update pysubs2 to 0.2.3
+
+
+2.6.5.3062
+
+Changelog
+- core: cf: optimize
+- core: http: don't query DNS with IPs. thanks @fgump (fixes sonarr/radarr)
+
+
+2.6.5.3041
+
+Changelog
+- core: only reference guessed title if there actually is one
+- core: cf: optimize
+- core/config: add setting for one existing language to be enough, fixes #491
+- core/compat: dns: support nameservers via ENV[dns_resolvers]; don't fall back to default DNS when configured custom DNS failed
+- providers: titlovi: prevent repeated captcha solving for CF
+
+
+2.6.5.3017
+
+Changelog
+- core: SRT parsing: handle (bad) ASS color tag in SRT
+- core: auto extract embedded: only use one unknown sub for first language
+- core: better embedded streams language detection
+- core: optimizations
+- core: extract embedded: fix is_unknown check
+- core: don't raise exception when subtitle not found inside archive
+- core: search external subtitles: fix condition
+- core: better plex transcoder path detection
+- core: use Log.Warn instead of Log.Warning (#619, #629, #633)
+- core: also check for "plex transcoder.exe" in case of windows (fixes #619)
+- core: auto extract: use mbcs encoding for paths on windows 
+- core: Fix issue scandir not returning the name of the file inside Docker images on ARM systems. (thanks @giejay)
+- core: also clean PYTHONHOME when calling external notification app
+- core: update certifi to 2019.3.9
+- core: scan_video: add series/title as alternative by scanning filename itself without parent folders
+- core: add generic solution for solving captchas using anti captcha services
+- core: increase cache time to 180d (was: 30d)
+- core: guess_matches: handle multiple title matches; fixes bazarr#403
+- windows: fix compatibility issues with plex transcoder
+- compat: use lowercase paths on subtitle detection
+- providers: addic7ed: re-enable (using paid anti captch service)
+- providers: assrt: assume undefined Chinese flavor as Simplified (chs/zho-Hans)
+- providers: subscene: make it work again by bypassing cf
+- providers: subscene: don't fail on missing cover
+- providers: titlovi: re-enable (might need paid anti captch service)
+- providers: opensubtitles: fix only_foreign handling
+- providers: opensubtitles: show subtitles with possibly mismatched series when manually listing subs
+- menu: list subtitles: show subtitles with bad season/episode values as well
+- refiners: omdb: fix imdb ids with spaces
+
+
+2.6.4.2911
+- core: improve file cache (windows especially); use fixed-length cache filenames; fixes #600
+- core: don't log "Checking connections ..." when sonarr/radarr not activated
+- core: make logging for scanning/parsing/preparing videos more clear
+- core: extract embedded: continue searching for embbedded subs after undefined language is found (thanks @jippo015)
+- compat: core: don't assume hints["title"] exists
+- compat: providers: podnapisi: loosen lxml requirement
+- providers: addic7ed: fix not using user credentials; fixes #605
+- providers: titlovi: fix provider (thanks @viking1304)
+- providers: subscene: fix provider
+- providers: opensubtitles: improve token logging
+- providers: podnapisi: fix searching for Marvel series
+- submod: HI: correctly remove uppercase at start of a sentence when lead by a crocodile (>>)
+- submod: HI: correctly remove lowercase inside brackets when HI matched as well
+- submod: HI: remove multiple HI_before_colon_caps before one colon
+- submod: common: also match music symbols after a crocodile; move crocodile removal up the chain
+
+
+2.6.4.2881
+- core: extract embedded: fix automatic extraction not actually writing the subtitles to disk under certain circumstances; fixes #598
+- core: sonarr/radarr: don't block the main thread while checking connectivity; fixes #597
+- providers: hosszupuska: fix inconsistent series naming (thanks @morpheus133)
+- providers: opensubtitles: add advanced setting to optionally not skip subtitles with wrong FPS; fixes #578
+
+
+2.6.4.2864
+- core: scanning: don't fail on metadata subtitles with bad language code; fixes #596
+- providers: legendastv, napiprojekt, subscenter, tvsubtitles: fix "No language to search for" issue; fixes #596
+- menu: fix "ignore list list"
+- menu: advanced: add skip next search all recently missing subtitles entry
+

 2.6.4.2859
 - core: fix thread.lock error (only affected the history menu, not the actual functionality)
@@ -21,20 +21,21 @@ import support
 import interface
 sys.modules["interface"] = interface

-from subzero.constants import OS_PLEX_USERAGENT, PERSONAL_MEDIA_IDENTIFIER
+from subzero.constants import OS_PLEX_USERAGENT
 from interface.menu import *
 from support.plex_media import media_to_videos, get_media_item_ids
+from support.extract import agent_extract_embedded
 from support.scanning import scan_videos
-from support.storage import save_subtitles, store_subtitle_info, get_subtitle_storage
+from support.storage import save_subtitles, store_subtitle_info
 from support.items import is_wanted
 from support.config import config
 from support.lib import get_intent
-from support.helpers import track_usage, get_title_for_video_metadata, get_identifier, cast_bool, \
-    audio_streams_match_languages
+from support.helpers import track_usage, get_title_for_video_metadata, get_identifier, cast_bool
 from support.history import get_history
 from support.data import dispatch_migrate
 from support.activities import activity
 from support.download import download_best_subtitles
+from support.localmedia import find_subtitles


 def Start():
@@ -96,53 +97,7 @@ def Start():

 def update_local_media(videos, ignore_parts_cleanup=None):
    for video in videos:
-        support.localmedia.find_subtitles(video["plex_part"], ignore_parts_cleanup=ignore_parts_cleanup)
-
-
-def agent_extract_embedded(video_part_map):
-    try:
-        subtitle_storage = get_subtitle_storage()
-
-        to_extract = []
-        item_count = 0
-
-        for scanned_video, part_info in video_part_map.iteritems():
-            plexapi_item = scanned_video.plexapi_metadata["item"]
-            stored_subs = subtitle_storage.load_or_new(plexapi_item)
-            valid_langs_in_media = audio_streams_match_languages(scanned_video, config.get_lang_list(ordered=True))
-
-            if not config.lang_list.difference(valid_langs_in_media):
-                Log.Debug("Skipping embedded subtitle extraction for %s, audio streams are in correct language(s)",
-                          plexapi_item.rating_key)
-                continue
-
-            for plexapi_part in get_all_parts(plexapi_item):
-                item_count = item_count + 1
-                for requested_language in config.lang_list:
-                    embedded_subs = stored_subs.get_by_provider(plexapi_part.id, requested_language, "embedded")
-                    current = stored_subs.get_any(plexapi_part.id, requested_language) or \
-                        requested_language in scanned_video.external_subtitle_languages
-
-                    if not embedded_subs:
-                        stream_data = get_embedded_subtitle_streams(plexapi_part, requested_language=requested_language)
-
-                        if stream_data:
-                            stream = stream_data[0]["stream"]
-
-                            to_extract.append(({scanned_video: part_info}, plexapi_part, str(stream.index),
-                                               str(requested_language), not current))
-
-                            if not cast_bool(Prefs["subtitles.search_after_autoextract"]):
-                                scanned_video.subtitle_languages.update({requested_language})
-                    else:
-                        Log.Debug("Skipping embedded subtitle extraction for %s, already got %r from %s",
-                                  plexapi_item.rating_key, requested_language, embedded_subs[0].id)
-        if to_extract:
-            Log.Info("Triggering extraction of %d embedded subtitles of %d items", len(to_extract), item_count)
-            Thread.Create(multi_extract_embedded, stream_list=to_extract, refresh=True, with_mods=True,
-                          single_thread=not config.advanced.auto_extract_multithread)
-    except:
-        Log.Error("Something went wrong when auto-extracting subtitles, continuing: %s", traceback.format_exc())
+        find_subtitles(video["plex_part"], ignore_parts_cleanup=ignore_parts_cleanup)


 class SubZeroAgent(object):
@@ -224,7 +179,7 @@ class SubZeroAgent(object):
                if config.plex_transcoder:
                    agent_extract_embedded(scanned_video_part_map)
                else:
-                    Log.Warning("Plex Transcoder not found, can't auto extract")
+                    Log.Warn("Plex Transcoder not found, can't auto extract")

            # clear missing subtitles menu data
            if not scheduler.is_task_running("MissingSubtitles"):
@@ -307,7 +262,8 @@ class SubZeroAgent(object):


 class SubZeroSubtitlesAgentMovies(SubZeroAgent, Agent.Movies):
-    contributes_to = ['com.plexapp.agents.imdb', 'com.plexapp.agents.xbmcnfo', 'com.plexapp.agents.themoviedb', 'com.plexapp.agents.hama']
+    contributes_to = ['com.plexapp.agents.imdb', 'com.plexapp.agents.xbmcnfo', 'com.plexapp.agents.themoviedb',
+                      'com.plexapp.agents.hama',  'tv.plex.agents.movie']
    score_prefs_key = "subtitles.search.minimumMovieScore2"
    agent_type_verbose = "Movies"

@@ -7,14 +7,16 @@ from subzero.language import Language

 from sub_mod import SubtitleModificationsMenu
 from menu_helpers import debounce, SubFolderObjectContainer, default_thumb, add_incl_excl_options, get_item_task_data, \
-    set_refresh_menu_state, route, extract_embedded_sub
+    set_refresh_menu_state, route
+from support.extract import extract_embedded_sub

 from refresh_item import RefreshItem
 from subzero.constants import PREFIX
 from support.config import config, TEXT_SUBTITLE_EXTS
-from support.helpers import timestamp, df, get_language, display_language, get_language_from_stream, is_stream_forced
+from support.helpers import timestamp, df, get_language, display_language, get_language_from_stream
 from support.items import get_item_kind_from_rating_key, get_item, get_current_sub, get_item_title, save_stored_sub
-from support.plex_media import get_plex_metadata, get_part, get_embedded_subtitle_streams
+from support.plex_media import get_plex_metadata, get_part, get_embedded_subtitle_streams, is_stream_forced, \
+    update_stream_info
 from support.scanning import scan_videos
 from support.scheduler import scheduler
 from support.storage import get_subtitle_storage
@@ -118,6 +120,8 @@ def ItemDetailsMenu(rating_key, title=None, base_title=None, item_title=None, ra
            if not os.path.exists(part.file):
                continue

+            update_stream_info(part)
+
            part_id = str(part.id)
            part_index += 1

@@ -580,6 +584,8 @@ def ListAvailableSubsForItemMenu(rating_key=None, part_id=None, title=None, item
            bl_addon = "Blacklisted "

        wrong_fps_addon = ""
+        wrong_series_addon = ""
+        wrong_season_ep_addon = ""
        if subtitle.wrong_fps:
            if plex_part:
                wrong_fps_addon = _(" (wrong FPS, sub: %(subtitle_fps)s, media: %(media_fps)s)",
@@ -589,15 +595,24 @@ def ListAvailableSubsForItemMenu(rating_key=None, part_id=None, title=None, item
                wrong_fps_addon = _(" (wrong FPS, sub: %(subtitle_fps)s, media: unknown, low impact mode)",
                                    subtitle_fps=subtitle.fps)

+        if subtitle.wrong_series:
+            wrong_series_addon = _(" (possibly wrong series)")
+
+        if subtitle.wrong_season_ep:
+            wrong_season_ep_addon = _(" (possibly wrong season/episode)")
+
        oc.add(DirectoryObject(
            key=Callback(TriggerDownloadSubtitle, rating_key=rating_key, randomize=timestamp(), item_title=item_title,
                         subtitle_id=str(subtitle.id), language=language),
-            title=_(u"%(blacklisted_state)s%(current_state)s: %(provider_name)s, score: %(score)s%(wrong_fps_state)s",
+            title=_(u"%(blacklisted_state)s%(current_state)s: %(provider_name)s, score: %(score)s%(wrong_fps_state)s"
+                    u"%(wrong_series_state)s%(wrong_season_ep_state)s",
                    blacklisted_state=bl_addon,
                    current_state=_("Available") if current_id != subtitle.id else _("Current"),
                    provider_name=_(subtitle.provider_name),
                    score=subtitle.score,
-                    wrong_fps_state=wrong_fps_addon),
+                    wrong_fps_state=wrong_fps_addon,
+                    wrong_series_state=wrong_series_addon,
+                    wrong_season_ep_state=wrong_season_ep_addon),
            summary=_(u"Release: %(release_info)s, Matches: %(matches)s",
                      release_info=subtitle.release_info,
                      matches=", ".join(subtitle.matches)),
@@ -659,29 +674,28 @@ def ListEmbeddedSubsForItemMenu(**kwargs):
            stream = stream_data["stream"]
            is_forced = stream_data["is_forced"]

-            if language:
-                oc.add(DirectoryObject(
-                    key=Callback(TriggerExtractEmbeddedSubForItemMenu, randomize=timestamp(),
-                                 stream_index=str(stream.index), language=language, with_mods=True, **kwargs),
-                    title=_(u"Extract stream %(stream_index)s, %(language)s%(unknown_state)s%(forced_state)s"
-                            u"%(stream_title)s with default mods",
-                            stream_index=stream.index,
-                            language=display_language(language),
-                            unknown_state=_(" (unknown)") if is_unknown else "",
-                            forced_state=_(" (forced)") if is_forced else "",
-                            stream_title=" (\"%s\")" % stream.title if stream.title else ""),
-                ))
-                oc.add(DirectoryObject(
-                    key=Callback(TriggerExtractEmbeddedSubForItemMenu, randomize=timestamp(),
-                                 stream_index=str(stream.index), language=language, **kwargs),
-                    title=_(u"Extract stream %(stream_index)s, %(language)s%(unknown_state)s%(forced_state)s"
-                            u"%(stream_title)s",
-                            stream_index=stream.index,
-                            language=display_language(language),
-                            unknown_state=_(" (unknown)") if is_unknown else "",
-                            forced_state=_(" (forced)") if is_forced else "",
-                            stream_title=" (\"%s\")" % stream.title if stream.title else ""),
-                ))
+            oc.add(DirectoryObject(
+                key=Callback(TriggerExtractEmbeddedSubForItemMenu, randomize=timestamp(),
+                             stream_index=str(stream.index), language=language, with_mods=True, **kwargs),
+                title=_(u"Extract stream %(stream_index)s, %(language)s%(unknown_state)s%(forced_state)s"
+                        u"%(stream_title)s with default mods",
+                        stream_index=stream.index,
+                        language=display_language(language),
+                        unknown_state=_(" (unknown)") if is_unknown else "",
+                        forced_state=_(" (forced)") if is_forced else "",
+                        stream_title=" (\"%s\")" % stream.title if stream.title else ""),
+            ))
+            oc.add(DirectoryObject(
+                key=Callback(TriggerExtractEmbeddedSubForItemMenu, randomize=timestamp(),
+                             stream_index=str(stream.index), language=language, **kwargs),
+                title=_(u"Extract stream %(stream_index)s, %(language)s%(unknown_state)s%(forced_state)s"
+                        u"%(stream_title)s",
+                        stream_index=stream.index,
+                        language=display_language(language),
+                        unknown_state=_(" (unknown)") if is_unknown else "",
+                        forced_state=_(" (forced)") if is_forced else "",
+                        stream_title=" (\"%s\")" % stream.title if stream.title else ""),
+            ))
    return oc


@@ -12,19 +12,16 @@ from requests import HTTPError
 from item_details import ItemDetailsMenu
 from refresh_item import RefreshItem
 from menu_helpers import add_incl_excl_options, dig_tree, set_refresh_menu_state, \
-    default_thumb, debounce, ObjectContainer, SubFolderObjectContainer, route, \
-    extract_embedded_sub
+    default_thumb, debounce, ObjectContainer, SubFolderObjectContainer, route
 from main import fatality, InclExclMenu
 from advanced import DispatchRestart
 from subzero.constants import ART, PREFIX, DEPENDENCY_MODULE_NAMES
-from support.plex_media import get_all_parts, get_embedded_subtitle_streams
+from support.extract import season_extract_embedded
 from support.scheduler import scheduler
 from support.config import config
 from support.helpers import timestamp, df, display_language
 from support.ignore import get_decision_list
-from support.items import get_all_items, get_items_info, get_item_kind_from_rating_key, get_item, MI_KEY, \
-    get_item_title, get_item_thumb
-from support.storage import get_subtitle_storage
+from support.items import get_all_items, get_items_info, get_item_kind_from_rating_key, get_item, get_item_title
 from support.i18n import _

 # init GUI
@@ -174,53 +171,6 @@ def SeasonExtractEmbedded(**kwargs):
    return MetadataMenu(randomize=timestamp(), title=item_title, **kwargs)


-def multi_extract_embedded(stream_list, refresh=False, with_mods=False, single_thread=True, extract_mode="a",
-                           history_storage=None):
-    def execute():
-        for video_part_map, plexapi_part, stream_index, language, set_current in stream_list:
-            plexapi_item = video_part_map.keys()[0].plexapi_metadata["item"]
-
-            extract_embedded_sub(rating_key=plexapi_item.rating_key, part_id=plexapi_part.id,
-                                 plex_item=plexapi_item, part=plexapi_part, scanned_videos=video_part_map,
-                                 stream_index=stream_index, set_current=set_current,
-                                 language=language, with_mods=with_mods, refresh=refresh, extract_mode=extract_mode,
-                                 history_storage=history_storage)
-
-    if single_thread:
-        with Thread.Lock(key="extract_embedded"):
-            execute()
-    else:
-        execute()
-
-
-def season_extract_embedded(rating_key, requested_language, with_mods=False, force=False):
-    # get stored subtitle info for item id
-    subtitle_storage = get_subtitle_storage()
-
-    try:
-        for data in get_all_items(key="children", value=rating_key, base="library/metadata"):
-            item = get_item(data[MI_KEY])
-            if item:
-                stored_subs = subtitle_storage.load_or_new(item)
-                for part in get_all_parts(item):
-                    embedded_subs = stored_subs.get_by_provider(part.id, requested_language, "embedded")
-                    current = stored_subs.get_any(part.id, requested_language)
-                    if not embedded_subs or force:
-                        stream_data = get_embedded_subtitle_streams(part, requested_language=requested_language)
-                        if stream_data:
-                            stream = stream_data[0]["stream"]
-
-                            set_current = not current or force
-                            refresh = not current
-
-                            extract_embedded_sub(rating_key=item.rating_key, part_id=part.id,
-                                                 stream_index=str(stream.index), set_current=set_current,
-                                                 refresh=refresh, language=requested_language, with_mods=with_mods,
-                                                 extract_mode="m")
-    finally:
-        subtitle_storage.destroy()
-
-
@route(PREFIX + '/ignore_list')
 def IgnoreListMenu():
    ref_list = get_decision_list()
@@ -278,37 +228,36 @@ def replace_item(obj, key, replace_value):

 def check_connections():
    # debug drone
-    if "sonarr" in config.refiner_settings or "radarr" in config.refiner_settings:
-        Log.Debug("Checking connections ...")
-        log_buffer = []
-        try:
-            from subliminal_patch.refiners.drone import SonarrClient, RadarrClient
-            log_buffer.append(["----- Connections -----"])
-            for key, cls in [("sonarr", SonarrClient), ("radarr", RadarrClient)]:
-                if key in config.refiner_settings:
-                    cname = key.capitalize()
-                    try:
-                        status = cls(**config.refiner_settings[key]).status(timeout=5)
-                    except HTTPError, e:
-                        if e.response.status_code == 401:
-                            log_buffer.append(("%s: NOT WORKING - BAD API KEY", cname))
-                        else:
-                            log_buffer.append(("%s: NOT WORKING - %s", cname, traceback.format_exc()))
-                    except:
-                        log_buffer.append(("%s: NOT WORKING - %s", cname, traceback.format_exc()))
+    Log.Debug("Checking connections ...")
+    log_buffer = []
+    try:
+        from subliminal_patch.refiners.drone import SonarrClient, RadarrClient
+        log_buffer.append(["----- Connections -----"])
+        for key, cls in [("sonarr", SonarrClient), ("radarr", RadarrClient)]:
+            if key in config.refiner_settings:
+                cname = key.capitalize()
+                try:
+                    status = cls(**config.refiner_settings[key]).status(timeout=5)
+                except HTTPError, e:
+                    if e.response.status_code == 401:
+                        log_buffer.append(("%s: NOT WORKING - BAD API KEY", cname))
                    else:
-                        if status and status["version"]:
-                            log_buffer.append(("%s: OK - %s", cname, status["version"]))
-                        else:
-                            log_buffer.append(("%s: NOT WORKING - %s", cname))
-        except:
-            log_buffer.append(("Something went really wrong when evaluating Sonarr/Radarr: %s", traceback.format_exc()))
-        finally:
-            Core.log.setLevel(logging.DEBUG)
-            for entry in log_buffer:
-                Log.Debug(*entry)
+                        log_buffer.append(("%s: NOT WORKING - %s", cname, traceback.format_exc()))
+                except:
+                    log_buffer.append(("%s: NOT WORKING - %s", cname, traceback.format_exc()))
+                else:
+                    if status and status["version"]:
+                        log_buffer.append(("%s: OK - %s", cname, status["version"]))
+                    else:
+                        log_buffer.append(("%s: NOT WORKING - %s", cname))
+    except:
+        log_buffer.append(("Something went really wrong when evaluating Sonarr/Radarr: %s", traceback.format_exc()))
+    finally:
+        Core.log.setLevel(logging.DEBUG)
+        for entry in log_buffer:
+            Log.Debug(*entry)

-            Core.log.setLevel(logging.getLevelName(Prefs["log_level"]))
+        Core.log.setLevel(logging.getLevelName(Prefs["log_level"]))


@route(PREFIX + '/ValidatePrefs', enforce_route=True)
@@ -368,7 +317,8 @@ def ValidatePrefs():
            "enable_channel", "permissions_ok", "missing_permissions", "fs_encoding",
            "subtitle_destination_folder", "include", "include_exclude_paths", "include_exclude_sz_files",
            "new_style_cache", "dbm_supported", "lang_list", "providers", "normal_subs", "forced_only", "forced_also",
-            "plex_transcoder", "refiner_settings", "unrar", "adv_cfg_path", "use_custom_dns"]:
+            "plex_transcoder", "refiner_settings", "unrar", "adv_cfg_path", "use_custom_dns",
+            "has_anticaptcha", "anticaptcha_cls", "mediainfo_bin"]:

        value = getattr(config, attr)
        if isinstance(value, dict):
@@ -376,6 +326,9 @@ def ValidatePrefs():
            Log.Debug("config.%s: %s", attr, d)
            continue

+        if attr in ("api_key",):
+            value = "xxxxxxxxxxxxxxxxxxxxxxxxx"
+
        Log.Debug("config.%s: %s", attr, value)

    for attr in ["plugin_log_path", "server_log_path"]:
@@ -397,7 +350,8 @@ def ValidatePrefs():
            "subtitles.save.filesystem", ]:
        Log.Debug("Pref.%s: %s", attr, Prefs[attr])

-    Thread.Create(check_connections)
+    if "sonarr" in config.refiner_settings or "radarr" in config.refiner_settings:
+        Thread.Create(check_connections)

    # fixme: check existance of and os access of logs
    Log.Debug("----- Environment -----")
@@ -1,28 +1,16 @@
 # coding=utf-8
-import traceback
 import types
 import datetime
-import subprocess
-import os
-import operator

-from func import enable_channel_wrapper, route_wrapper, register_route_function
-from subzero.language import Language
+from func import enable_channel_wrapper, route_wrapper
 from support.i18n import is_localized_string, _
-from support.items import get_kind, get_item_thumb, get_item, get_item_kind_from_item, refresh_item
-from support.helpers import get_video_display_title, pad_title, display_language, quote_args, is_stream_forced, \
-    get_title_for_video_metadata
-from support.history import get_history
+from support.items import get_item_thumb
+from support.helpers import get_video_display_title, pad_title
 from support.ignore import get_decision_list
 from support.lib import get_intent
 from support.config import config
 from subzero.constants import ICON_SUB, ICON
-from support.plex_media import get_part, get_plex_metadata
 from support.scheduler import scheduler
-from support.scanning import scan_videos
-from support.storage import save_subtitles
-
-from subliminal_patch.subtitle import ModifiedSubtitle

 default_thumb = R(ICON_SUB)
 main_icon = ICON if not config.is_development else "icon-dev.jpg"
@@ -155,82 +143,6 @@ def debounce(func):
    return func


-def extract_embedded_sub(**kwargs):
-    rating_key = kwargs["rating_key"]
-    part_id = kwargs.pop("part_id")
-    stream_index = kwargs.pop("stream_index")
-    with_mods = kwargs.pop("with_mods", False)
-    language = Language.fromietf(kwargs.pop("language"))
-    refresh = kwargs.pop("refresh", True)
-    set_current = kwargs.pop("set_current", True)
-
-    plex_item = kwargs.pop("plex_item", get_item(rating_key))
-    item_type = get_item_kind_from_item(plex_item)
-    part = kwargs.pop("part", get_part(plex_item, part_id))
-    scanned_videos = kwargs.pop("scanned_videos", None)
-    extract_mode = kwargs.pop("extract_mode", "a")
-
-    any_successful = False
-
-    if part:
-        if not scanned_videos:
-            metadata = get_plex_metadata(rating_key, part_id, item_type, plex_item=plex_item)
-            scanned_videos = scan_videos([metadata], ignore_all=True, skip_hashing=True)
-
-        for stream in part.streams:
-            # subtitle stream
-            if str(stream.index) == stream_index:
-                is_forced = is_stream_forced(stream)
-                bn = os.path.basename(part.file)
-
-                set_refresh_menu_state(_(u"Extracting subtitle %(stream_index)s of %(filename)s",
-                                         stream_index=stream_index,
-                                         filename=bn))
-                Log.Info(u"Extracting stream %s (%s) of %s", stream_index, str(language), bn)
-
-                out_codec = stream.codec if stream.codec != "mov_text" else "srt"
-
-                args = [
-                    config.plex_transcoder, "-i", part.file, "-map", "0:%s" % stream_index, "-f", out_codec, "-"
-                ]
-                output = None
-                try:
-                    output = subprocess.check_output(quote_args(args), stderr=subprocess.PIPE, shell=True)
-                except:
-                    Log.Error("Extraction failed: %s", traceback.format_exc())
-
-                if output:
-                    subtitle = ModifiedSubtitle(language, mods=config.default_mods if with_mods else None)
-                    subtitle.content = output
-                    subtitle.provider_name = "embedded"
-                    subtitle.id = "stream_%s" % stream_index
-                    subtitle.score = 0
-                    subtitle.set_encoding("utf-8")
-
-                    # fixme: speedup video; only video.name is needed
-                    video = scanned_videos.keys()[0]
-                    save_successful = save_subtitles(scanned_videos, {video: [subtitle]}, mode="m",
-                                                     set_current=set_current)
-                    set_refresh_menu_state(None)
-
-                    if save_successful and refresh:
-                        refresh_item(rating_key)
-
-                    # add item to history
-                    item_title = get_title_for_video_metadata(video.plexapi_metadata,
-                                                              add_section_title=False, add_episode_title=True)
-
-                    history = get_history()
-                    history.add(item_title, video.id, section_title=video.plexapi_metadata["section"],
-                                thumb=video.plexapi_metadata["super_thumb"],
-                                subtitle=subtitle, mode=extract_mode)
-                    history.destroy()
-
-                    any_successful = True
-
-    return any_successful
-
-
 class SZObjectContainer(ObjectContainer):
    def __init__(self, *args, **kwargs):
        skip_pin_lock = kwargs.pop("skip_pin_lock", False)
@@ -19,6 +19,10 @@ sys.modules["support.i18n"] = i18n

 helpers._ = i18n._

+import history
+
+sys.modules["support.history"] = history
+
 import plex_media
 sys.modules["support.plex_media"] = plex_media

@@ -49,6 +53,10 @@ import missing_subtitles

 sys.modules["support.missing_subtitles"] = missing_subtitles

+import extract
+
+sys.modules["support.extract"] = extract
+
 import tasks

 sys.modules["support.tasks"] = tasks
@@ -57,10 +65,6 @@ import ignore

 sys.modules["support.ignore"] = ignore

-import history
-
-sys.modules["support.history"] = history
-
 import data

 sys.modules["support.data"] = data
@@ -1,5 +1,6 @@
 # coding=utf-8
 import copy
+import json
 import os
 import re
 import inspect
@@ -7,12 +8,17 @@ import sys
 import rarfile
 import jstyleson
 import datetime
+import stat
+import traceback
+import socket
+import requests

 import subliminal
 import subliminal_patch
 import subzero.constants
 import lib
-from subliminal.exceptions import ServiceUnavailable, DownloadLimitExceeded, AuthenticationError
+from subliminal.exceptions import ServiceUnavailable, DownloadLimitExceeded, AuthenticationError, \
+    DownloadLimitPerDayExceeded
 from subliminal_patch.core import is_windows_special_path
 from whichdb import whichdb

@@ -21,6 +27,7 @@ from subzero.language import Language
 from subliminal.cli import MutexLock
 from subzero.lib.io import FileIO, get_viable_encoding
 from subzero.lib.dict import Dicked
+from subzero.lib.which import find_executable
 from subzero.util import get_root_path
 from subzero.constants import PLUGIN_NAME, PLUGIN_IDENTIFIER, MOVIE, SHOW, MEDIA_TYPE_TO_STRING
 from subzero.prefs import get_user_prefs, update_user_prefs
@@ -57,14 +64,22 @@ def int_or_default(s, default):
        return default


-VALID_THROTTLE_EXCEPTIONS = (TooManyRequests, DownloadLimitExceeded, ServiceUnavailable, APIThrottled)
+VALID_THROTTLE_EXCEPTIONS = (TooManyRequests, DownloadLimitExceeded, DownloadLimitPerDayExceeded,
+                             ServiceUnavailable, APIThrottled, requests.Timeout, requests.ReadTimeout, socket.timeout)
+
+def_timeout = (datetime.timedelta(minutes=20), "20 minutes")

 PROVIDER_THROTTLE_MAP = {
    "default": {
        TooManyRequests: (datetime.timedelta(hours=1), "1 hour"),
        DownloadLimitExceeded: (datetime.timedelta(hours=3), "3 hours"),
+        DownloadLimitPerDayExceeded: (datetime.timedelta(hours=4), "4 hours"),
        ServiceUnavailable: (datetime.timedelta(minutes=20), "20 minutes"),
        APIThrottled: (datetime.timedelta(minutes=10), "10 minutes"),
+        AuthenticationError: (datetime.timedelta(hours=2), "2 hours"),
+        requests.Timeout: def_timeout,
+        socket.timeout: def_timeout,
+        requests.ReadTimeout: def_timeout,
    },
    "opensubtitles": {
        TooManyRequests: (datetime.timedelta(hours=3), "3 hours"),
@@ -74,12 +89,13 @@ PROVIDER_THROTTLE_MAP = {
    "addic7ed": {
        DownloadLimitExceeded: (datetime.timedelta(hours=3), "3 hours"),
        TooManyRequests: (datetime.timedelta(minutes=5), "5 minutes"),
+        AuthenticationError: (datetime.timedelta(hours=24), "24 hours"),
    }
 }


 class Config(object):
-    config_version = 2
+    config_version = 3
    libraries_root = None
    plugin_info = ""
    version = None
@@ -143,11 +159,16 @@ class Config(object):
    refiner_settings = None
    exact_filenames = False
    only_one = False
+    any_language_is_enough = False
    embedded_auto_extract = False
    ietf_as_alpha3 = False
    unrar = None
    adv_cfg_path = None
-    use_custom_dns = False
+    use_custom_dns = None
+    anticaptcha_token = None
+    anticaptcha_cls = None
+    has_anticaptcha = False
+    mediainfo_bin = None

    store_recently_played_amount = 40

@@ -172,6 +193,8 @@ class Config(object):
        self.data_items_path = os.path.join(self.data_path, "DataItems")
        self.universal_plex_token = self.get_universal_plex_token()
        self.plex_token = os.environ.get("PLEXTOKEN", self.universal_plex_token)
+        self.new_style_cache = cast_bool(Prefs['new_style_cache'])
+        self.pack_cache_dir = self.get_pack_cache_dir()
        try:
            self.migrate_prefs()
        except:
@@ -180,12 +203,15 @@ class Config(object):
        subzero.constants.DEFAULT_TIMEOUT = lib.DEFAULT_TIMEOUT = self.pms_request_timeout = \
            min(cast_int(Prefs['pms_request_timeout'], 15), 45)
        self.low_impact_mode = cast_bool(Prefs['low_impact_mode'])
-        self.new_style_cache = cast_bool(Prefs['new_style_cache'])
-        self.pack_cache_dir = self.get_pack_cache_dir()
        self.advanced = self.get_advanced_config()
        self.debug_i18n = self.advanced.debug_i18n

        os.environ["SZ_USER_AGENT"] = self.get_user_agent()
+        os.environ["ANTICAPTCHA_ACCOUNT_KEY"] = self.anticaptcha_token = str(Prefs["anticaptcha.api_key"]) or ""
+        acs = str(Prefs["anticaptcha.service"])
+        if acs and acs != "none":
+            os.environ["ANTICAPTCHA_CLASS"] = self.anticaptcha_cls = acs
+        self.has_anticaptcha = self.anticaptcha_token and self.anticaptcha_cls

        self.setup_proxies()
        self.set_plugin_mode()
@@ -225,9 +251,12 @@ class Config(object):
        self.no_refresh = os.environ.get("SZ_NO_REFRESH", False)
        self.plex_transcoder = self.get_plex_transcoder()
        self.only_one = cast_bool(Prefs['subtitles.only_one'])
+        self.any_language_is_enough = Prefs['subtitles.any_language_is_enough']
        self.embedded_auto_extract = cast_bool(Prefs["subtitles.embedded.autoextract"])
        self.ietf_as_alpha3 = cast_bool(Prefs["subtitles.language.ietf_normalize"])
-        self.use_custom_dns = cast_bool(Prefs['use_custom_dns'])
+        self.use_custom_dns = self.parse_custom_dns()
+        if not self.advanced.dont_use_mediainfo_mp4:
+            self.mediainfo_bin = self.advanced.mediainfo_bin or find_executable("mediainfo")
        self.initialized = True

    def migrate_prefs(self):
@@ -256,6 +285,9 @@ class Config(object):

                if update_prefs:
                    update_user_prefs(update_prefs, Prefs, Log)
+            else:
+                Dict["config_version"] = self.config_version
+                Dict.Save()

    def migrate_prefs_to_1(self, user_prefs, **kwargs):
        update_prefs = {}
@@ -275,6 +307,15 @@ class Config(object):

        return update_prefs

+    def migrate_prefs_to_3(self, user_prefs, **kwargs):
+        if config.new_style_cache:
+            self.init_cache()
+            try:
+                subliminal.region.backend.clear()
+            except:
+                pass
+        return {}
+
    def init_libraries(self):
        try_executables = []
        custom_unrar = os.environ.get("SZ_UNRAR_TOOL")
@@ -300,6 +341,19 @@ class Config(object):
        for exe in try_executables:
            rarfile.UNRAR_TOOL = exe
            rarfile.ORIG_UNRAR_TOOL = exe
+            if os.path.isfile(exe) and not os.access(exe, os.X_OK):
+                st = os.stat(exe)
+                try:
+                    Log.Debug("setting generic executable permissions for %s", exe)
+                    # fixme: too broad?
+                    os.chmod(exe, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+                except:
+                    Log.Debug("failed setting generic executable permissions for %s: %s", exe, traceback.format_exc())
+                    try:
+                        Log.Debug("setting executable permissions for %s", exe)
+                        os.chmod(exe, st.st_mode | stat.S_IEXEC)
+                    except:
+                        Log.Debug("failed setting executable permissions for %s: %s", exe, traceback.format_exc())
            try:
                rarfile.custom_check([rarfile.UNRAR_TOOL], True)
            except:
@@ -317,9 +371,10 @@ class Config(object):

    def init_cache(self):
        if self.new_style_cache:
-            subliminal.region.configure('subzero.cache.file', expiration_time=datetime.timedelta(days=30),
+            subliminal.region.configure('subzero.cache.file', expiration_time=datetime.timedelta(days=180),
                                        arguments={'appname': "sz_cache",
-                                                   'app_cache_dir': self.data_path})
+                                                   'app_cache_dir': self.data_path},
+                                        replace_existing_backend=True)
            Log.Info("Using new style file based cache!")
            return

@@ -359,14 +414,15 @@ class Config(object):
            try:
                subliminal.region.configure('dogpile.cache.dbm', expiration_time=datetime.timedelta(days=30),
                                            arguments={'filename': dbfn,
-                                                       'lock_factory': MutexLock})
+                                                       'lock_factory': MutexLock},
+                                            replace_existing_backend=True)
                Log.Info("Using file based cache!")
                return
            except:
                self.dbm_supported = False

        Log.Warn("Not using file based cache!")
-        subliminal.region.configure('dogpile.cache.memory')
+        subliminal.region.configure('dogpile.cache.memory', replace_existing_backend=True)

    def sync_cache(self):
        if not self.new_style_cache:
@@ -617,12 +673,18 @@ class Config(object):
            if not agent.primary:
                continue

-            for t in list(agent.media_types):
-                if t.media_type in (MOVIE, SHOW):
-                    related_agents = Plex.primary_agent(agent.identifier, t.media_type)
+            media_types = [t.media_type for t in list(agent.media_types)]
+
+            # the new movie agent doesn't populate its media types, workaround
+            if not media_types and agent.identifier == "tv.plex.agents.movie":
+                media_types = [MOVIE]
+
+            for media_type in media_types:
+                if media_type in (MOVIE, SHOW):
+                    related_agents = Plex.primary_agent(agent.identifier, media_type)
                    for a in related_agents:
                        if a.identifier == PLUGIN_IDENTIFIER and a.enabled:
-                            enabled_for_primary_agents[MEDIA_TYPE_TO_STRING[t.media_type]].append(agent.identifier)
+                            enabled_for_primary_agents[MEDIA_TYPE_TO_STRING[media_type]].append(agent.identifier)

        # find the libraries that use them
        for library in self.sections:
@@ -736,8 +798,9 @@ class Config(object):
        return {'opensubtitles': cast_bool(Prefs['provider.opensubtitles.enabled']),
                     # 'thesubdb': Prefs['provider.thesubdb.enabled'],
                     'podnapisi': cast_bool(Prefs['provider.podnapisi.enabled']),
+                     'napisy24': cast_bool(Prefs['provider.napisy24.enabled']),
                     'titlovi': cast_bool(Prefs['provider.titlovi.enabled']),
-                     'addic7ed': cast_bool(Prefs['provider.addic7ed.enabled']),
+                     'addic7ed': cast_bool(Prefs['provider.addic7ed.enabled']) and self.has_anticaptcha,
                     'tvsubtitles': cast_bool(Prefs['provider.tvsubtitles.enabled']),
                     'legendastv': cast_bool(Prefs['provider.legendastv.enabled']),
                     'napiprojekt': cast_bool(Prefs['provider.napiprojekt.enabled']),
@@ -748,7 +811,9 @@ class Config(object):
                     'argenteam': cast_bool(Prefs['provider.argenteam.enabled']),
                     'subscenter': False,
                     'assrt': cast_bool(Prefs['provider.assrt.enabled']),
-                     }
+                     'bsplayer': cast_bool(Prefs['provider.bsplayer.enabled']),
+                     'screwzira': cast_bool(Prefs['provider.screwzira.enabled']),
+                }

    @property
    def providers_enabled(self):
@@ -776,6 +841,9 @@ class Config(object):
            providers["argenteam"] = False
            providers["assrt"] = False
            providers["subscene"] = False
+            providers["napisy24"] = False
+            providers["bsplayer"] = False
+            providers["screwzira"] = False
            providers_forced_off = dict(providers)

        if not self.unrar and providers["legendastv"]:
@@ -816,15 +884,12 @@ class Config(object):
    providers = property(get_providers)

    def get_provider_settings(self):
-        os_use_https = self.advanced.providers.opensubtitles.use_https \
-            if self.advanced.providers.opensubtitles.use_https is not None else True
-
-        os_skip_wrong_fps = self.advanced.providers.opensubtitles.skip_wrong_fps \
-            if self.advanced.providers.opensubtitles.skip_wrong_fps is not None else True
+        os_use_https = self.advanced.providers.opensubtitles.get("use_https", True)
+        os_skip_wrong_fps = self.advanced.providers.opensubtitles.get("skip_wrong_fps", True)

        provider_settings = {'addic7ed': {'username': Prefs['provider.addic7ed.username'],
                                          'password': Prefs['provider.addic7ed.password'],
-                                          'use_random_agents': cast_bool(Prefs['provider.addic7ed.use_random_agents1']),
+                                          'is_vip': cast_bool(Prefs['provider.addic7ed.is_vip']),
                                          },
                             'opensubtitles': {'username': Prefs['provider.opensubtitles.username'],
                                               'password': Prefs['provider.opensubtitles.password'],
@@ -840,8 +905,18 @@ class Config(object):
                                 'only_foreign': self.forced_only,
                                 'also_foreign': self.forced_also,
                             },
+                             'titlovi': {
+                                 'username': Prefs['provider.titlovi.username'],
+                                 'password': Prefs['provider.titlovi.password'],
+                             },
+                             'napisy24': {
+                                 'username': Prefs['provider.napisy24.username'],
+                                 'password': Prefs['provider.napisy24.password'],
+                             },
                             'subscene': {
                                 'only_foreign': self.forced_only,
+                                 'username': Prefs['provider.subscene.username'],
+                                 'password': Prefs['provider.subscene.password'],
                             },
                             'legendastv': {'username': Prefs['provider.legendastv.username'],
                                            'password': Prefs['provider.legendastv.password'],
@@ -870,10 +945,10 @@ class Config(object):
        throttle_data = PROVIDER_THROTTLE_MAP.get(name, PROVIDER_THROTTLE_MAP["default"]).get(cls, None) or \
            PROVIDER_THROTTLE_MAP["default"].get(cls, None)

-        if not throttle_data:
-            return
-
-        throttle_delta, throttle_description = throttle_data
+        if throttle_data:
+            throttle_delta, throttle_description = throttle_data
+        else:
+            throttle_delta, throttle_description = datetime.timedelta(minutes=10), "10 minutes"

        if "provider_throttle" not in Dict:
            Dict["provider_throttle"] = {}
@@ -974,27 +1049,37 @@ class Config(object):
            self.activity_mode = "next_episode"

    def get_plex_transcoder(self):
+        paths = []
        base_path = os.environ.get("PLEX_MEDIA_SERVER_HOME", None)
-        if not base_path:
-            # fall back to bundled plugins path
-            bundle_path = os.environ.get("PLEXBUNDLEDPLUGINSPATH", None)
-            if bundle_path:
-                base_path = os.path.normpath(os.path.join(bundle_path, "..", ".."))
+        if base_path:
+            paths.append(base_path)

+        bundle_path = os.environ.get("PLEXBUNDLEDPLUGINSPATH", None)
+        if bundle_path:
+            paths.append(os.path.normpath(os.path.join(bundle_path, "..", "..")))
+
+        paths.append(self.app_support_path)
+
+        bns = []
        if sys.platform == "darwin":
-            fn = os.path.join(base_path, "MacOS", "Plex Transcoder")
+            bns.append(("MacOS", "Plex Transcoder"))
        elif mswindows:
-            fn = os.path.join(base_path, "plextranscoder.exe")
+            bns = [("plextranscoder.exe",), ("plex transcoder.exe",)]
        else:
-            fn = os.path.join(base_path, "Plex Transcoder")
+            bns.append(("Plex Transcoder",))

-        if os.path.isfile(fn):
-            return fn
+        for path in paths:
+            for bn in bns:
+                fn = os.path.join(path, *bn)

-        # look inside Resources folder as fallback, as well
-        fn = os.path.join(base_path, "Resources", "Plex Transcoder")
-        if os.path.isfile(fn):
-            return fn
+                if os.path.isfile(fn):
+                    return fn
+
+            # look inside Resources folder as fallback, as well
+            for vbn in ("Plex Transcoder", "plextranscoder.exe", "plex transcoder.exe"):
+                fn = os.path.join(path, "Resources", vbn)
+                if os.path.isfile(fn):
+                    return fn

    def parse_rename_mode(self):
        # fixme: exact_filenames should be determined via callback combined with info about the current video
@@ -1047,6 +1132,16 @@ class Config(object):
    def text_based_formats(self):
        return self.advanced.text_subtitle_formats or TEXT_SUBTITLE_EXTS

+    def parse_custom_dns(self):
+        custom_dns = Prefs['use_custom_dns2'].strip()
+        os.environ["dns_resolvers"] = ""
+
+        if custom_dns and custom_dns != "system":
+            ips = filter(lambda x: x, [d.strip() for d in custom_dns.split(",")])
+            if ips:
+                os.environ["dns_resolvers"] = json.dumps(ips)
+            return os.environ["dns_resolvers"]
+
    def init_subliminal_patches(self):
        # configure custom subtitle destination folders for scanning pre-existing subs
        Log.Debug("Patching subliminal ...")
@@ -1057,9 +1152,6 @@ class Config(object):
        subliminal_patch.core.DOWNLOAD_TRIES = int(Prefs['subtitles.try_downloads'])
        subliminal.score.episode_scores["addic7ed_boost"] = int(Prefs['provider.addic7ed.boost_by2'])

-        if self.use_custom_dns:
-            subliminal_patch.http.set_custom_resolver()
-

 config = Config()
 config.initialize()
@@ -33,19 +33,35 @@ def get_missing_languages(video, part):
    alpha3_map = {}
    if config.ietf_as_alpha3:
        for language in languages:
-            if language.country:
+            if language and language.country:
                alpha3_map[language.alpha3] = language.country
                language.country = None

    have_languages = video.subtitle_languages.copy()
    if config.ietf_as_alpha3:
        for language in have_languages:
-            if language.country:
+            if language and language.country:
                alpha3_map[language.alpha3] = language.country
                language.country = None

    missing_languages = (languages - have_languages)

+    if config.any_language_is_enough != "Always search for all configured languages":
+        not_in_forced = "foreign" in config.any_language_is_enough
+        if "External or embedded subtitle" in config.any_language_is_enough:
+            langs = video.subtitle_languages if not not_in_forced else \
+                filter(lambda l: not l.forced, video.subtitle_languages)
+            if langs:
+                Log.Debug("We have at least one subtitle for any configured language.")
+                return set()
+
+        elif "External subtitle" in config.any_language_is_enough:
+            langs = video.external_subtitle_languages if not not_in_forced else \
+                filter(lambda l: not l.forced, video.external_subtitle_languages)
+            if langs:
+                Log.Debug("We have at least one external subtitle for any configured language.")
+                return set()
+
    # all languages are found if we either really have subs for all languages or we only want to have exactly one language
    # and we've only found one (the case for a selected language, Prefs['subtitles.only_one'] (one found sub matches any language))
    found_one_which_is_enough = len(video.subtitle_languages) >= 1 and Prefs['subtitles.only_one']
@@ -54,7 +70,7 @@ def get_missing_languages(video, part):
            Log.Debug('Only one language was requested, and we\'ve got a subtitle for %s', video)
        else:
            Log.Debug('All languages %r exist for %s', languages, video)
-        return False
+        return set()

    # re-add country codes to the missing languages, in case we've removed them above
    if config.ietf_as_alpha3:
@@ -90,21 +106,22 @@ def language_hook(provider):
 def download_best_subtitles(video_part_map, min_score=0, throttle_time=None, providers=None):
    hearing_impaired = Prefs['subtitles.search.hearingImpaired']
    languages = set([Language.rebuild(l) for l in config.lang_list])
-    missing_languages = []
    if not languages:
        return

    use_videos = []
+    missing_languages = set()
    for video, part in video_part_map.iteritems():
        if not video.ignore_all:
-            missing_languages = get_missing_languages(video, part)
+            p_missing_languages = get_missing_languages(video, part)
        else:
-            missing_languages = languages
+            p_missing_languages = languages

-        if missing_languages:
-            Log.Info(u"%s has missing languages: %s", os.path.basename(video.name), missing_languages)
+        if p_missing_languages:
+            Log.Info(u"%s has missing languages: %s", os.path.basename(video.name), p_missing_languages)
            refine_video(video, refiner_settings=config.refiner_settings)
            use_videos.append(video)
+            missing_languages.update(p_missing_languages)

    # prepare blacklist
    blacklist = get_blacklist_from_part_map(video_part_map, languages)
@@ -0,0 +1,208 @@
+# coding=utf-8
+import os
+import subprocess
+import traceback
+
+from support.helpers import quote_args, mswindows, get_title_for_video_metadata, cast_bool, \
+    audio_streams_match_languages
+from support.i18n import _
+from support.items import get_item_kind_from_item, refresh_item, get_all_items, get_item, MI_KEY
+from support.storage import get_subtitle_storage, save_subtitles
+from support.config import config
+from support.history import get_history
+from support.plex_media import get_all_parts, get_embedded_subtitle_streams, get_part, get_plex_metadata, \
+    update_stream_info, is_stream_forced
+from support.scanning import scan_videos
+from subzero.language import Language
+from subliminal_patch.subtitle import ModifiedSubtitle
+
+
+def agent_extract_embedded(video_part_map, set_as_existing=False):
+    try:
+        subtitle_storage = get_subtitle_storage()
+
+        to_extract = []
+        item_count = 0
+
+        threads = []
+
+        for scanned_video, part_info in video_part_map.iteritems():
+            plexapi_item = scanned_video.plexapi_metadata["item"]
+            stored_subs = subtitle_storage.load_or_new(plexapi_item)
+            valid_langs_in_media = \
+                audio_streams_match_languages(scanned_video, config.get_lang_list(ordered=True))
+
+            if not config.lang_list.difference(valid_langs_in_media):
+                Log.Debug("Skipping embedded subtitle extraction for %s, audio streams are in correct language(s)",
+                          plexapi_item.rating_key)
+                continue
+
+            for plexapi_part in get_all_parts(plexapi_item):
+                item_count = item_count + 1
+                used_one_unknown_stream = False
+                used_one_known_stream = False
+                for requested_language in config.lang_list:
+                    skip_unknown = used_one_unknown_stream or used_one_known_stream
+                    embedded_subs = stored_subs.get_by_provider(plexapi_part.id, requested_language, "embedded")
+                    current = stored_subs.get_any(plexapi_part.id, requested_language) or \
+                        requested_language in scanned_video.external_subtitle_languages
+
+                    if not embedded_subs:
+                        stream_data = get_embedded_subtitle_streams(plexapi_part, requested_language=requested_language,
+                                                                    skip_unknown=skip_unknown)
+
+                        if stream_data and stream_data[0]["language"]:
+                            stream = stream_data[0]["stream"]
+                            if stream_data[0]["is_unknown"]:
+                                used_one_unknown_stream = True
+                            else:
+                                used_one_known_stream = True
+
+                            to_extract.append(({scanned_video: part_info}, plexapi_part, str(stream.index),
+                                               str(requested_language), not current))
+
+                            if not cast_bool(Prefs["subtitles.search_after_autoextract"]) or set_as_existing:
+                                scanned_video.subtitle_languages.update({requested_language})
+                    else:
+                        Log.Debug("Skipping embedded subtitle extraction for %s, already got %r from %s",
+                                  plexapi_item.rating_key, requested_language, embedded_subs[0].id)
+        if to_extract:
+            Log.Info("Triggering extraction of %d embedded subtitles of %d items", len(to_extract), item_count)
+            threads.append(Thread.Create(multi_extract_embedded, stream_list=to_extract, refresh=True, with_mods=True,
+                                         single_thread=not config.advanced.auto_extract_multithread))
+            return threads
+    except:
+        Log.Error("Something went wrong when auto-extracting subtitles, continuing: %s", traceback.format_exc())
+
+
+def multi_extract_embedded(stream_list, refresh=False, with_mods=False, single_thread=True, extract_mode="a",
+                           history_storage=None):
+    def execute():
+        for video_part_map, plexapi_part, stream_index, language, set_current in stream_list:
+            plexapi_item = video_part_map.keys()[0].plexapi_metadata["item"]
+
+            extract_embedded_sub(rating_key=plexapi_item.rating_key, part_id=plexapi_part.id,
+                                 plex_item=plexapi_item, part=plexapi_part, scanned_videos=video_part_map,
+                                 stream_index=stream_index, set_current=set_current,
+                                 language=language, with_mods=with_mods, refresh=refresh, extract_mode=extract_mode,
+                                 history_storage=history_storage)
+
+    if single_thread:
+        with Thread.Lock(key="extract_embedded"):
+            execute()
+    else:
+        execute()
+
+
+def season_extract_embedded(rating_key, requested_language, with_mods=False, force=False):
+    # get stored subtitle info for item id
+    subtitle_storage = get_subtitle_storage()
+
+    try:
+        for data in get_all_items(key="children", value=rating_key, base="library/metadata"):
+            item = get_item(data[MI_KEY])
+            if item:
+                stored_subs = subtitle_storage.load_or_new(item)
+                for part in get_all_parts(item):
+                    embedded_subs = stored_subs.get_by_provider(part.id, requested_language, "embedded")
+                    current = stored_subs.get_any(part.id, requested_language)
+                    if not embedded_subs or force:
+                        stream_data = get_embedded_subtitle_streams(part, requested_language=requested_language)
+                        if stream_data:
+                            stream = stream_data[0]["stream"]
+
+                            set_current = not current or force
+                            refresh = not current
+
+                            extract_embedded_sub(rating_key=item.rating_key, part_id=part.id,
+                                                 stream_index=str(stream.index), set_current=set_current,
+                                                 refresh=refresh, language=requested_language, with_mods=with_mods,
+                                                 extract_mode="m")
+    finally:
+        subtitle_storage.destroy()
+
+
+def extract_embedded_sub(**kwargs):
+    rating_key = kwargs["rating_key"]
+    part_id = kwargs.pop("part_id")
+    stream_index = kwargs.pop("stream_index")
+    with_mods = kwargs.pop("with_mods", False)
+    language = Language.fromietf(kwargs.pop("language"))
+    refresh = kwargs.pop("refresh", True)
+    set_current = kwargs.pop("set_current", True)
+
+    plex_item = kwargs.pop("plex_item", get_item(rating_key))
+    item_type = get_item_kind_from_item(plex_item)
+    part = kwargs.pop("part", get_part(plex_item, part_id))
+    scanned_videos = kwargs.pop("scanned_videos", None)
+    extract_mode = kwargs.pop("extract_mode", "a")
+
+    any_successful = False
+
+    from interface.menu_helpers import set_refresh_menu_state
+
+    if part:
+        if not scanned_videos:
+            metadata = get_plex_metadata(rating_key, part_id, item_type, plex_item=plex_item)
+            scanned_videos = scan_videos([metadata], ignore_all=True, skip_hashing=True)
+
+        update_stream_info(part)
+        for stream in part.streams:
+            # subtitle stream
+            if str(stream.index) == stream_index:
+                is_forced = is_stream_forced(stream)
+                bn = os.path.basename(part.file)
+
+                set_refresh_menu_state(_(u"Extracting subtitle %(stream_index)s of %(filename)s",
+                                         stream_index=stream_index,
+                                         filename=bn))
+                Log.Info(u"Extracting stream %s (%s) of %s", stream_index, str(language), bn)
+
+                out_codec = stream.codec if stream.codec != "mov_text" else "srt"
+
+                args = [
+                    config.plex_transcoder, "-i", part.file, "-map", "0:%s" % stream_index, "-f", out_codec, "-"
+                ]
+
+                cmdline = quote_args(args)
+                Log.Debug(u"Calling: %s", cmdline)
+                if mswindows:
+                    Log.Debug("MSWindows: Fixing encoding")
+                    cmdline = cmdline.encode("mbcs")
+
+                output = None
+                try:
+                    output = subprocess.check_output(cmdline, stderr=subprocess.PIPE, shell=True)
+                except:
+                    Log.Error("Extraction failed: %s", traceback.format_exc())
+
+                if output:
+                    subtitle = ModifiedSubtitle(language, mods=config.default_mods if with_mods else None)
+                    subtitle.content = output
+                    subtitle.provider_name = "embedded"
+                    subtitle.id = "stream_%s" % stream_index
+                    subtitle.score = 0
+                    subtitle.set_encoding("utf-8")
+
+                    # fixme: speedup video; only video.name is needed
+                    video = scanned_videos.keys()[0]
+                    save_successful = save_subtitles(scanned_videos, {video: [subtitle]}, mode="m",
+                                                     set_current=set_current)
+                    set_refresh_menu_state(None)
+
+                    if save_successful and refresh:
+                        refresh_item(rating_key)
+
+                    # add item to history
+                    item_title = get_title_for_video_metadata(video.plexapi_metadata,
+                                                              add_section_title=False, add_episode_title=True)
+
+                    history = get_history()
+                    history.add(item_title, video.id, section_title=video.plexapi_metadata["section"],
+                                thumb=video.plexapi_metadata["super_thumb"],
+                                subtitle=subtitle, mode=extract_mode)
+                    history.destroy()
+
+                    any_successful = True
+
+    return any_successful
@@ -12,10 +12,12 @@ import subprocess
 import sys
 from collections import OrderedDict

+from babelfish.exceptions import LanguageError
+
 import chardet

 from bs4 import UnicodeDammit
-from subzero.language import Language
+from subzero.language import Language, language_from_stream
 from subzero.analytics import track_event

 mswindows = (sys.platform == "win32")
@@ -284,6 +286,7 @@ def notify_executable(exe_info, videos, subtitles, storage):
        "subtitle_language", "subtitle_path", "subtitle_filename", "provider", "score", "storage", "series_id",
        "series", "title", "section", "filename", "path", "folder", "season_id", "type", "id", "season"
    )
+    to_clean = ("PYTHONPATH", "PYTHONHOME")
    exe, arguments = exe_info
    for video, video_subtitles in subtitles.items():
        for subtitle in video_subtitles:
@@ -319,8 +322,9 @@ def notify_executable(exe_info, videos, subtitles, storage):
                env = dict(os.environ)

            # clean out any Plex-PYTHONPATH that may bleed through the spawned process
-            if "PYTHONPATH" in env and "plex" in env["PYTHONPATH"].lower():
-                del env["PYTHONPATH"]
+            for v in to_clean:
+                if v in env and "plex" in env[v].lower():
+                    del env[v]

            try:
                proc = subprocess.Popen(quote_args([exe] + prepared_arguments), stdout=subprocess.PIPE,
@@ -388,6 +392,11 @@ def get_language_from_stream(lang_code):
        if lang and lang != "xx":
            # Log.Debug("Found language: %r", lang)
            return Language.fromietf(lang)
+        elif lang:
+            try:
+                return language_from_stream(lang_code)
+            except LanguageError:
+                pass


 def audio_streams_match_languages(video, languages):
@@ -428,17 +437,10 @@ def get_language(lang_short):


 def display_language(l):
+    if not l:
+        return "Unknown"
    return _(str(l.basename).lower()) + ((u" (%s)" % _("forced")) if l.forced else "")


-def is_stream_forced(stream):
-    stream_title = getattr(stream, "title", "") or ""
-    forced = getattr(stream, "forced", False)
-    if not forced and stream_title and "forced" in stream_title.strip().lower():
-        forced = True
-
-    return forced
-
-
 class PartUnknownException(Exception):
    pass
@@ -7,6 +7,7 @@ import helpers
 import subtitlehelpers

 from config import config as sz_config
+from subzero.language import ENDSWITH_LANGUAGECODE_RE


 SECONDARY_TAGS = ['forced', 'normal', 'default', 'embedded', 'embedded-forced', 'custom', 'hi', 'cc', 'sdh']
@@ -125,7 +126,7 @@ def find_subtitles(part, ignore_parts_cleanup=None):
                            root = split_tag[0]

                        # get associated media file name without language
-                        sub_fn = subtitlehelpers.ENDSWITH_LANGUAGECODE_RE.sub("", root)
+                        sub_fn = ENDSWITH_LANGUAGECODE_RE.sub("", root)

                        # subtitle basename and basename without possible language tag  not found in collected
                        # media files? kill.
@@ -7,7 +7,8 @@ import os
 from babelfish import LanguageReverseError

 from support.config import config, TEXT_SUBTITLE_EXTS
-from support.helpers import get_plex_item_display_title, cast_bool, get_language_from_stream, is_stream_forced
+from support.helpers import get_plex_item_display_title, cast_bool, get_language_from_stream
+from support.plex_media import is_stream_forced, update_stream_info
 from support.items import get_item
 from support.lib import Plex
 from support.storage import get_subtitle_storage
@@ -35,7 +36,7 @@ def item_discover_missing_subs(rating_key, kind="show", added_at=None, section_t
    for media in item.media:
        existing_subs = {"internal": [], "external": [], "own_external": [], "count": 0}
        for part in media.parts:
-
+            update_stream_info(part)
            # did we already download an external subtitle before?
            if subtitle_target_dir and stored_subs:
                for language in languages_set:
@@ -1,6 +1,7 @@
 # coding=utf-8

 import os
+import subprocess

 import helpers
 from items import get_item
@@ -26,6 +27,9 @@ tvdb_guid_identifier = "com.plexapp.agents.thetvdb://"


 def get_plexapi_stream_info(plex_item, part_id=None):
+    if not plex_item:
+        return
+
    d = {"stream": {}}
    data = d["stream"]

@@ -100,6 +104,9 @@ def media_to_videos(media, kind="series"):
                plex_episode = get_item(ep.id)
                stream_info = get_plexapi_stream_info(plex_episode)

+                if not stream_info:
+                    continue
+
                for item in media.seasons[season].episodes[episode].items:
                    for part in item.parts:
                        videos.append(
@@ -121,22 +128,24 @@ def media_to_videos(media, kind="series"):
                        )
    else:
        stream_info = get_plexapi_stream_info(plex_item)
-        imdb_id = None
-        if imdb_guid_identifier in media.guid:
-            imdb_id = media.guid[len(imdb_guid_identifier):].split("?")[0]
-        for item in media.items:
-            for part in item.parts:
-                videos.append(
-                    get_metadata_dict(plex_item, part, dict(stream_info, **{"plex_part": part, "type": "movie",
-                                                                             "title": media.title, "id": media.id,
-                                                                             "super_thumb": plex_item.thumb,
-                                                                             "series_id": None, "year": year,
-                                                                             "season_id": None, "imdb_id": imdb_id,
-                                                                             "original_title": original_title,
-                                                                             "series_tvdb_id": None, "tvdb_id": None,
-                                                                             "section": plex_item.section.title})
-                                      )
-                )
+
+        if stream_info:
+            imdb_id = None
+            if imdb_guid_identifier in media.guid:
+                imdb_id = media.guid[len(imdb_guid_identifier):].split("?")[0]
+            for item in media.items:
+                for part in item.parts:
+                    videos.append(
+                        get_metadata_dict(plex_item, part, dict(stream_info, **{"plex_part": part, "type": "movie",
+                                                                                 "title": media.title, "id": media.id,
+                                                                                 "super_thumb": plex_item.thumb,
+                                                                                 "series_id": None, "year": year,
+                                                                                 "season_id": None, "imdb_id": imdb_id,
+                                                                                 "original_title": original_title,
+                                                                                 "series_tvdb_id": None, "tvdb_id": None,
+                                                                                 "section": plex_item.section.title})
+                                          )
+                    )
    return videos


@@ -174,36 +183,100 @@ def get_all_parts(plex_item):
    return parts


-def get_embedded_subtitle_streams(part, requested_language=None, skip_duplicate_unknown=True):
+def update_stream_info(part):
+    try:
+        return update_stream_info_(part)
+    except:
+        Log.Exception("Getting Mediainfo failed for: %s", part.file)
+
+
+def update_stream_info_(part):
+    if config.mediainfo_bin and part.container == "mp4":
+        cmdline = '%s --Inform="Text;-%%ID%%_%%Title%%" %s' % (config.mediainfo_bin, helpers.quote(part.file))
+        result = subprocess.check_output(cmdline, stderr=subprocess.PIPE, shell=True)
+        if result:
+            try:
+                stream_titles = {}
+                for pair in result[1:].split("-"):
+                    sid, title = pair.split("_")
+                    stream_titles[int(sid.strip())] = title.strip()
+            except:
+                pass
+            else:
+                filled = []
+                for stream in part.streams:
+                    if stream.index is None:
+                        Log.Debug("Found stream with no index: %r", stream)
+
+                    index = stream.index+1 if stream.index is not None else 1
+                    if index in stream_titles:
+                        stream.title = stream_titles[index]
+                        filled.append(index-1)
+                if filled:
+                    Log.Debug("Filled missing MP4 stream title info for streams: %s", filled)
+
+
+def is_stream_forced(stream):
+    stream_title = getattr(stream, "title", "") or ""
+    forced = getattr(stream, "forced", False)
+    if not forced and stream_title and "forced" in stream_title.strip().lower():
+        forced = True
+
+    return forced
+
+
+def get_embedded_subtitle_streams(part, requested_language=None, skip_duplicate_unknown=True, skip_unknown=False):
    streams = []
+    streams_unknown = []
+    all_streams = []
    has_unknown = False
+    found_requested_language = False
+    update_stream_info(part)
    for stream in part.streams:
        # subtitle stream
        if stream.stream_type == 3 and not stream.stream_key and stream.codec in TEXT_SUBTITLE_EXTS:
-            is_forced = helpers.is_stream_forced(stream)
+            is_forced = is_stream_forced(stream)
            language = helpers.get_language_from_stream(stream.language_code)
            if language:
                language = Language.rebuild(language, forced=is_forced)

            is_unknown = False
            found_requested_language = requested_language and requested_language == language
+            stream_data = None

-            if not language and config.treat_und_as_first:
+            if not language:
                # only consider first unknown subtitle stream
-                if has_unknown and skip_duplicate_unknown:
-                    continue
+                if config.treat_und_as_first:
+                    if has_unknown and skip_duplicate_unknown:
+                        Log.Debug("skipping duplicate unknown")
+                        continue

-                language = Language.rebuild(list(config.lang_list)[0], forced=is_forced)
+                    language = Language.rebuild(list(config.lang_list)[0], forced=is_forced)
+                else:
+                    language = None
                is_unknown = True
                has_unknown = True
+                stream_data = {"stream": stream, "is_unknown": is_unknown, "language": language,
+                               "is_forced": is_forced}
+                streams_unknown.append(stream_data)

-            if not requested_language or found_requested_language or has_unknown:
-                streams.append({"stream": stream, "is_unknown": is_unknown, "language": language,
-                                "is_forced": is_forced})
+            if not requested_language or found_requested_language:
+                stream_data = {"stream": stream, "is_unknown": is_unknown, "language": language,
+                               "is_forced": is_forced}
+                streams.append(stream_data)

                if found_requested_language:
                    break

+            if stream_data:
+                all_streams.append(stream_data)
+
+    if requested_language:
+        if streams_unknown and not found_requested_language and not skip_unknown:
+            streams = streams_unknown
+    else:
+        streams = all_streams
+
    return streams


@@ -238,6 +311,9 @@ def get_plex_metadata(rating_key, part_id, item_type, plex_item=None):

    stream_info = get_plexapi_stream_info(plex_item, part_id)

+    if not stream_info:
+        return
+
    # get normalized metadata
    # fixme: duplicated logic of media_to_videos
    if item_type == "episode":
@@ -359,3 +435,4 @@ class PMSMediaProxy(object):

            m = m.children[0]
        return parts
+
@@ -4,7 +4,7 @@ import helpers
 from babelfish.exceptions import LanguageError

 from support.lib import Plex, get_intent
-from support.plex_media import get_stream_fps
+from support.plex_media import get_stream_fps, is_stream_forced, update_stream_info
 from support.storage import get_subtitle_storage
 from support.config import config, TEXT_SUBTITLE_EXTS
 from support.subtitlehelpers import get_subtitles_from_metadata
@@ -12,7 +12,7 @@ from subzero.video import parse_video, set_existing_languages
 from subzero.language import language_from_stream, Language


-def scan_video(pms_video_info, ignore_all=False, hints=None, rating_key=None, providers=None, skip_hashing=False):
+def prepare_video(pms_video_info, ignore_all=False, hints=None, rating_key=None, providers=None, skip_hashing=False):
    """
    returnes a subliminal/guessit-refined parsed video
    :param pms_video_info:
@@ -29,7 +29,7 @@ def scan_video(pms_video_info, ignore_all=False, hints=None, rating_key=None, pr
    if ignore_all:
        Log.Debug("Force refresh intended.")

-    Log.Debug("Scanning video: %s, external_subtitles=%s, embedded_subtitles=%s" % (
+    Log.Debug("Detecting streams: %s, account_for_external_subtitles=%s, account_for_embedded_subtitles=%s" % (
        plex_part.file, external_subtitles, embedded_subtitles))

    known_embedded = []
@@ -46,23 +46,25 @@ def scan_video(pms_video_info, ignore_all=False, hints=None, rating_key=None, pr
    # fixme: skip the whole scanning process if known_embedded == wanted languages?
    audio_languages = []
    if plexpy_part:
+        update_stream_info(plexpy_part)
        for stream in plexpy_part.streams:
            if stream.stream_type == 2:
                lang = None
                try:
                    lang = language_from_stream(stream.language_code)
                except LanguageError:
-                    Log.Debug("Couldn't detect embedded audio stream language: %s", stream.language_code)
+                    Log.Info("Couldn't detect embedded audio stream language: %s", stream.language_code)

                # treat unknown language as lang1?
                if not lang and config.treat_und_as_first:
                    lang = Language.rebuild(list(config.lang_list)[0])
+                    Log.Info("Assuming language %s for audio stream: %s", lang, getattr(stream, "index", None))

                audio_languages.append(lang)

            # subtitle stream
            elif stream.stream_type == 3 and embedded_subtitles:
-                is_forced = helpers.is_stream_forced(stream)
+                is_forced = is_stream_forced(stream)

                if ((config.forced_only or config.forced_also) and is_forced) or not is_forced:
                    # embedded subtitle
@@ -73,11 +75,13 @@ def scan_video(pms_video_info, ignore_all=False, hints=None, rating_key=None, pr
                            try:
                                lang = language_from_stream(stream.language_code)
                            except LanguageError:
-                                Log.Debug("Couldn't detect embedded subtitle stream language: %s", stream.language_code)
+                                Log.Info("Couldn't detect embedded subtitle stream language: %s", stream.language_code)

                            # treat unknown language as lang1?
                            if not lang and config.treat_und_as_first:
                                lang = Language.rebuild(list(config.lang_list)[0])
+                                Log.Info("Assuming language %s for subtitle stream: %s", lang,
+                                         getattr(stream, "index", None))

                            if lang:
                                if is_forced:
@@ -127,7 +131,8 @@ def scan_video(pms_video_info, ignore_all=False, hints=None, rating_key=None, pr
            set_existing_languages(video, pms_video_info, external_subtitles=external_subtitles,
                                   embedded_subtitles=embedded_subtitles, known_embedded=known_embedded,
                                   stored_subs=stored_subs, languages=config.lang_list,
-                                   only_one=config.only_one, known_metadata_subs=known_metadata_subs)
+                                   only_one=config.only_one, known_metadata_subs=known_metadata_subs,
+                                   match_strictness=config.ext_match_strictness)

        # add video fps info
        video.fps = plex_part.fps
@@ -154,9 +159,9 @@ def scan_videos(videos, ignore_all=False, providers=None, skip_hashing=False):
        hints = helpers.get_item_hints(video)
        video["plex_part"].fps = get_stream_fps(video["plex_part"].streams)
        p = providers or config.get_providers(media_type="series" if video["type"] == "episode" else "movies")
-        scanned_video = scan_video(video, ignore_all=force_refresh or ignore_all, hints=hints,
-                                   rating_key=video["id"], providers=p,
-                                   skip_hashing=skip_hashing)
+        scanned_video = prepare_video(video, ignore_all=force_refresh or ignore_all, hints=hints,
+                                      rating_key=video["id"], providers=p,
+                                      skip_hashing=skip_hashing)

        if not scanned_video:
            continue
@@ -33,7 +33,7 @@ def store_subtitle_info(scanned_video_part_map, downloaded_subtitles, storage_ty
        video_id = str(video.id)
        plex_item = get_item(video_id)
        if not plex_item:
-            Log.Warning("Plex item not found: %s", video_id)
+            Log.Warn("Plex item not found: %s", video_id)
            continue

        metadata = video.plexapi_metadata
@@ -5,6 +5,7 @@ import helpers

 from config import config, SUBTITLE_EXTS, TEXT_SUBTITLE_EXTS
 from bs4 import UnicodeDammit
+from subzero.language import match_ietf_language


 class SubtitleHelper(object):
@@ -85,19 +86,6 @@ class VobSubSubtitleHelper(SubtitleHelper):
 #####################################################################################################################


-IETF_MATCH = ".+\.([^-.]+)(?:-[A-Za-z]+)?$"
-ENDSWITH_LANGUAGECODE_RE = re.compile("\.([^-.]{2,3})(?:-[A-Za-z]{2,})?$")
-
-
-def match_ietf_language(s):
-    language_match = re.match(".+\.([^\.]+)$" if not helpers.cast_bool(Prefs["subtitles.language.ietf_display"])
-                              else IETF_MATCH, s)
-    if language_match and len(language_match.groups()) == 1:
-        language = language_match.groups()[0]
-        return language
-    return s
-
-
 class DefaultSubtitleHelper(SubtitleHelper):
    @classmethod
    def is_helper_for(cls, filename):
@@ -133,7 +121,7 @@ class DefaultSubtitleHelper(SubtitleHelper):
        # Attempt to extract the language from the filename (e.g. Avatar (2009).eng)
        # IETF support thanks to
        # https://github.com/hpsbranco/LocalMedia.bundle/commit/4fad9aefedece78a1fa96401304351347f644369
-        lang_part = match_ietf_language(file)
+        lang_part = match_ietf_language(file, ietf=helpers.cast_bool(Prefs["subtitles.language.ietf_display"]))
        if lang_part != file:
            language = Locale.Language.Match(lang_part)
        elif config.only_one:
@@ -19,6 +19,7 @@ from support.config import config
 from support.items import get_recent_items, get_item, is_wanted, get_item_title
 from support.helpers import track_usage, get_title_for_video_metadata, cast_bool, PartUnknownException
 from support.plex_media import get_plex_metadata
+from support.extract import agent_extract_embedded
 from support.scanning import scan_videos
 from support.i18n import _
 from download import download_best_subtitles, pre_download_hook, post_download_hook, language_hook
@@ -165,17 +166,22 @@ class SubtitleListingMixin(object):
                    can_verify_series = False

                if can_verify_series and not {"series", "season", "episode"}.issubset(matches):
-                    Log.Debug(u"%s: Skipping %s, because it doesn't match our series/episode", self.name, s)
-                    continue
+                    if "series" not in matches:
+                        s.wrong_series = True
+                    else:
+                        s.wrong_season_ep = True
+
+            orig_matches = matches.copy()
+            score, score_without_hash = compute_score(matches, s, video, hearing_impaired=use_hearing_impaired)

            unsorted_subtitles.append(
-                (s, compute_score(matches, s, video, hearing_impaired=use_hearing_impaired), matches))
-        scored_subtitles = sorted(unsorted_subtitles, key=operator.itemgetter(1), reverse=True)
+                (s, score, score_without_hash, matches, orig_matches))
+        scored_subtitles = sorted(unsorted_subtitles, key=operator.itemgetter(1, 2), reverse=True)

        subtitles = []
-        for subtitle, score, matches in scored_subtitles:
+        for subtitle, score, score_without_hash, matches, orig_matches in scored_subtitles:
            # check score
-            if score < min_score:
+            if score < min_score and not subtitle.wrong_series:
                Log.Info(u'%s: Score %d is below min_score (%d)', self.name, score, min_score)
                continue
            subtitle.score = score
@@ -447,6 +453,17 @@ class SearchAllRecentlyAddedMissing(Task):
                    Log.Debug(u"%s: Looking for missing subtitles: %s", self.name, get_item_title(plex_item))
                    scanned_parts = scan_videos([metadata], providers=providers)

+                    # auto extract embedded
+                    if config.embedded_auto_extract:
+                        if config.plex_transcoder:
+                            ts = agent_extract_embedded(scanned_parts, set_as_existing=True)
+                            if ts:
+                                Log.Debug("Waiting for %i extraction threads to finish" % len(ts))
+                                for t in ts:
+                                    t.join()
+                        else:
+                            Log.Warn("Plex Transcoder not found, can't auto extract")
+
                    downloaded_subtitles = download_best_subtitles(scanned_parts, min_score=min_score,
                                                                   providers=providers)
                    hit_providers = downloaded_subtitles is not None
@@ -653,7 +670,7 @@ class FindBetterSubtitles(DownloadSubtitleMixin, SubtitleListingMixin, Task):
        min_score_series = int(Prefs["subtitles.search.minimumTVScore2"].strip())
        min_score_movies = int(Prefs["subtitles.search.minimumMovieScore2"].strip())
        min_score_extracted_series = config.advanced.find_better_as_extracted_tv_score or 352
-        min_score_extracted_movies = config.advanced.find_better_as_extracted_movie_score or 82
+        min_score_extracted_movies = config.advanced.find_better_as_extracted_movie_score or 112
        overwrite_manually_modified = cast_bool(
            Prefs["scheduler.tasks.FindBetterSubtitles.overwrite_manually_modified"])
        overwrite_manually_selected = cast_bool(
@@ -205,6 +205,19 @@
    ],
    "default": "Never"
  },
+  {
+    "id": "subtitles.any_language_is_enough",
+    "label": "Don't search for subtitles if a subtitle in any configured language exists as",
+    "type": "enum",
+    "values": [
+      "External or embedded subtitle",
+      "External or embedded subtitle (not foreign/forced)",
+      "External subtitle",
+      "External subtitle (not foreign/forced)",
+      "Always search for all configured languages"
+    ],
+    "default": "Always search for all configured languages"
+  },
  {
    "id": "subtitles.language.ietf_display",
    "label": "Display languages with country attribute as ISO 639-1 (e.g. pt-BR = pt)",
@@ -273,6 +286,23 @@
    "type": "text",
    "default": ""
  },
+  {
+    "id": "anticaptcha.service",
+    "label": "AntiCaptcha-Service (needs paid account; enables Addic7ed)",
+    "type": "enum",
+    "values": [
+      "none",
+      "anti-captcha.com",
+      "deathbycaptcha.com"
+    ],
+    "default": "none"
+  },
+  {
+    "id": "anticaptcha.api_key",
+    "label": "AntiCaptcha-Service key (anti-captcha.com: account_key; deathbycaptcha.com: username:password)",
+    "type": "text",
+    "default": ""
+  },
  {
    "id": "provider.opensubtitles.enabled",
    "label": "Provider: Enable OpenSubtitles",
@@ -306,14 +336,28 @@
    "default": "true"
  },
  {
-    "id": "provider.titlovi.enabled",
-    "label": "Provider: Enable Titlovi.com",
+    "id": "provider.napisy24.enabled",
+    "label": "Provider: Enable Napisy24 (pl)",
    "type": "bool",
-    "default": "true"
+    "default": "false"
+  },
+  {
+    "id": "provider.napisy24.username",
+    "label": "Napisy24 Username",
+    "type": "text",
+    "default": ""
+  },
+  {
+    "id": "provider.napisy24.password",
+    "label": "Napisy24 Password",
+    "type": "text",
+    "option": "hidden",
+    "default": "",
+    "secure": "true"
  },
  {
    "id": "provider.addic7ed.enabled",
-    "label": "Provider: Enable Addic7ed",
+    "label": "Provider: Enable Addic7ed (needs AntiCaptcha)",
    "type": "bool",
    "default": "true"
  },
@@ -331,6 +375,12 @@
    "default": "",
    "secure": "true"
  },
+  {
+    "id": "provider.addic7ed.is_vip",
+    "label": "Addic7ed VIP? (80 vs 40 downloads per day)",
+    "type": "bool",
+    "default": "false"
+  },
  {
    "id": "provider.addic7ed.boost_by2",
    "label": "Addic7ed: boost score (if requirements met)",
@@ -364,11 +414,25 @@
    "default": "19"
  },
  {
-    "id": "provider.addic7ed.use_random_agents1",
-    "label": "Addic7ed: Use random user agents",
+    "id": "provider.titlovi.enabled",
+    "label": "Provider: Enable Titlovi.com (User and Password required)",
    "type": "bool",
    "default": "true"
  },
+  {
+    "id": "provider.titlovi.username",
+    "label": "Titlovi Username",
+    "type": "text",
+    "default": ""
+  },
+  {
+    "id": "provider.titlovi.password",
+    "label": "Titlovi Password",
+    "type": "text",
+    "option": "hidden",
+    "default": "",
+    "secure": "true"
+  },
  {
    "id": "provider.legendastv.enabled",
    "label": "Provider: Enable Legendas TV (mostly pt-BR; UNRAR NEEDED)",
@@ -407,6 +471,20 @@
    "type": "bool",
    "default": "true"
  },
+  {
+    "id": "provider.subscene.username",
+    "label": "SubScene Username",
+    "type": "text",
+    "default": ""
+  },
+  {
+    "id": "provider.subscene.password",
+    "label": "SubScene Password",
+    "type": "text",
+    "option": "hidden",
+    "default": "",
+    "secure": "true"
+  },
  {
    "id": "provider.supersubtitles.enabled",
    "label": "Provider: Enable feliratok.info (Hungarian)",
@@ -437,6 +515,18 @@
    "type": "text",
    "default": ""
  },
+  {
+    "id": "provider.bsplayer.enabled",
+    "label": "Provider: Enable BSPlayer Subtitles",
+    "type": "bool",
+    "default": "true"
+  },
+  {
+    "id": "provider.screwzira.enabled",
+    "label": "Provider: Enable ScrewZira (Hebrew)",
+    "type": "bool",
+    "default": "false"
+  },
  {
    "id": "providers.multithreading",
    "label": "Search enabled providers simultaneously (multithreading)",
@@ -722,6 +812,29 @@
    "type": "bool",
    "default": "false"
  },
+  {
+    "id": "scheduler.tasks.SubtitleStorageMaintenance.frequency",
+    "label": "Scheduler: Periodically run subtitle storage maintenance (SZ internal)",
+    "type": "enum",
+    "values": [
+      "never",
+      "every 6 hours",
+      "every 12 hours",
+      "every 24 hours",
+      "every 1 days",
+      "every 2 days",
+      "every 3 days",
+      "every 4 days",
+      "every 1 weeks",
+      "every 2 weeks",
+      "every 3 weeks",
+      "every 4 weeks",
+      "every 5 weeks",
+      "every 6 weeks",
+      "every 12 weeks"
+    ],
+    "default": "every 1 weeks"
+  },
  {
    "id": "history_size",
    "label": "History: amount of items to store historical data for",
@@ -836,10 +949,10 @@
    "default": "15"
  },
  {
-    "id": "use_custom_dns",
-    "label": "Use Google DNS (for \"problematic\" countries)",
-    "type": "bool",
-    "default": "false"
+    "id": "use_custom_dns2",
+    "label": "Use custom DNS (IPs, comma-separated, set to 'system' for system DNS. Default: Google/CF)",
+    "type": "text",
+    "default": "1.1.1.1, 8.8.8.8"
  },
  {
    "id": "proxy",
@@ -9,11 +9,11 @@
        <key>CFBundleInfoDictionaryVersion</key>
        <string>6.0</string>
        <key>CFBundleShortVersionString</key>
-        <string>2.6.4</string>
+        <string>2.6.5</string>
        <key>CFBundleSignature</key>
        <string>????</string>
        <key>CFBundleVersion</key>
-        <string>2.6.4.2881</string>
+        <string>2.6.5.3247</string>
        <key>PlexFrameworkVersion</key>
        <string>2</string>
        <key>PlexPluginClass</key>
@@ -23,7 +23,7 @@
        <key>PlexPluginConsoleLogging</key>
        <string>0</string>
        <key>PlexPluginDevMode</key>
-        <string>0</string>
+        <string>1</string>
         <key>PlexPluginCodePolicy</key>
            <!-- this allows channels to access some python methods which are otherwise blocked, as well as import external code libraries, and interact with the PMS HTTP API -->
            <string>Elevated</string>
@@ -32,7 +32,7 @@

 &lt;h1&gt;Sub-Zero for Plex&lt;/h1&gt;&lt;i&gt;Subtitles done right&lt;/i&gt;

-Version 2.6.4.2881
+Version 2.6.5.3247 DEV

 Originally based on @bramwalet's awesome &lt;a href=&quot;https://github.com/bramwalet/Subliminal.bundle&quot;&gt;Subliminal.bundle&lt;/a&gt;

@@ -46,7 +46,7 @@ Github: &lt;a href=&quot;https://github.com/pannal/Sub-Zero.bundle&quot;&gt;http

 3rd party licenses: &lt;a href=&quot;https://github.com/pannal/Sub-Zero.bundle/tree/master/Licenses&quot;&gt;https://github.com/pannal/Sub-Zero.bundle/tree/master/Licenses&lt;/a&gt;

-panni, 2018
+panni, 2019
 &lt;/div&gt;
 	</string>
    </dict>
@@ -0,0 +1 @@
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)
@@ -0,0 +1,196 @@
+from __future__ import absolute_import
+
+import functools
+from collections import namedtuple
+from threading import RLock
+
+_CacheInfo = namedtuple("CacheInfo", ["hits", "misses", "maxsize", "currsize"])
+
+
+@functools.wraps(functools.update_wrapper)
+def update_wrapper(
+    wrapper,
+    wrapped,
+    assigned=functools.WRAPPER_ASSIGNMENTS,
+    updated=functools.WRAPPER_UPDATES,
+):
+    """
+    Patch two bugs in functools.update_wrapper.
+    """
+    # workaround for http://bugs.python.org/issue3445
+    assigned = tuple(attr for attr in assigned if hasattr(wrapped, attr))
+    wrapper = functools.update_wrapper(wrapper, wrapped, assigned, updated)
+    # workaround for https://bugs.python.org/issue17482
+    wrapper.__wrapped__ = wrapped
+    return wrapper
+
+
+class _HashedSeq(list):
+    __slots__ = 'hashvalue'
+
+    def __init__(self, tup, hash=hash):
+        self[:] = tup
+        self.hashvalue = hash(tup)
+
+    def __hash__(self):
+        return self.hashvalue
+
+
+def _make_key(
+    args,
+    kwds,
+    typed,
+    kwd_mark=(object(),),
+    fasttypes=set([int, str, frozenset, type(None)]),
+    sorted=sorted,
+    tuple=tuple,
+    type=type,
+    len=len,
+):
+    'Make a cache key from optionally typed positional and keyword arguments'
+    key = args
+    if kwds:
+        sorted_items = sorted(kwds.items())
+        key += kwd_mark
+        for item in sorted_items:
+            key += item
+    if typed:
+        key += tuple(type(v) for v in args)
+        if kwds:
+            key += tuple(type(v) for k, v in sorted_items)
+    elif len(key) == 1 and type(key[0]) in fasttypes:
+        return key[0]
+    return _HashedSeq(key)
+
+
+def lru_cache(maxsize=100, typed=False):
+    """Least-recently-used cache decorator.
+
+    If *maxsize* is set to None, the LRU features are disabled and the cache
+    can grow without bound.
+
+    If *typed* is True, arguments of different types will be cached separately.
+    For example, f(3.0) and f(3) will be treated as distinct calls with
+    distinct results.
+
+    Arguments to the cached function must be hashable.
+
+    View the cache statistics named tuple (hits, misses, maxsize, currsize) with
+    f.cache_info().  Clear the cache and statistics with f.cache_clear().
+    Access the underlying function with f.__wrapped__.
+
+    See:  http://en.wikipedia.org/wiki/Cache_algorithms#Least_Recently_Used
+
+    """
+
+    # Users should only access the lru_cache through its public API:
+    #       cache_info, cache_clear, and f.__wrapped__
+    # The internals of the lru_cache are encapsulated for thread safety and
+    # to allow the implementation to change (including a possible C version).
+
+    def decorating_function(user_function):
+
+        cache = dict()
+        stats = [0, 0]  # make statistics updateable non-locally
+        HITS, MISSES = 0, 1  # names for the stats fields
+        make_key = _make_key
+        cache_get = cache.get  # bound method to lookup key or return None
+        _len = len  # localize the global len() function
+        lock = RLock()  # because linkedlist updates aren't threadsafe
+        root = []  # root of the circular doubly linked list
+        root[:] = [root, root, None, None]  # initialize by pointing to self
+        nonlocal_root = [root]  # make updateable non-locally
+        PREV, NEXT, KEY, RESULT = 0, 1, 2, 3  # names for the link fields
+
+        if maxsize == 0:
+
+            def wrapper(*args, **kwds):
+                # no caching, just do a statistics update after a successful call
+                result = user_function(*args, **kwds)
+                stats[MISSES] += 1
+                return result
+
+        elif maxsize is None:
+
+            def wrapper(*args, **kwds):
+                # simple caching without ordering or size limit
+                key = make_key(args, kwds, typed)
+                result = cache_get(
+                    key, root
+                )  # root used here as a unique not-found sentinel
+                if result is not root:
+                    stats[HITS] += 1
+                    return result
+                result = user_function(*args, **kwds)
+                cache[key] = result
+                stats[MISSES] += 1
+                return result
+
+        else:
+
+            def wrapper(*args, **kwds):
+                # size limited caching that tracks accesses by recency
+                key = make_key(args, kwds, typed) if kwds or typed else args
+                with lock:
+                    link = cache_get(key)
+                    if link is not None:
+                        # record recent use of the key by moving it
+                        # to the front of the list
+                        root, = nonlocal_root
+                        link_prev, link_next, key, result = link
+                        link_prev[NEXT] = link_next
+                        link_next[PREV] = link_prev
+                        last = root[PREV]
+                        last[NEXT] = root[PREV] = link
+                        link[PREV] = last
+                        link[NEXT] = root
+                        stats[HITS] += 1
+                        return result
+                result = user_function(*args, **kwds)
+                with lock:
+                    root, = nonlocal_root
+                    if key in cache:
+                        # getting here means that this same key was added to the
+                        # cache while the lock was released.  since the link
+                        # update is already done, we need only return the
+                        # computed result and update the count of misses.
+                        pass
+                    elif _len(cache) >= maxsize:
+                        # use the old root to store the new key and result
+                        oldroot = root
+                        oldroot[KEY] = key
+                        oldroot[RESULT] = result
+                        # empty the oldest link and make it the new root
+                        root = nonlocal_root[0] = oldroot[NEXT]
+                        oldkey = root[KEY]
+                        root[KEY] = root[RESULT] = None
+                        # now update the cache dictionary for the new links
+                        del cache[oldkey]
+                        cache[key] = oldroot
+                    else:
+                        # put result in a new link at the front of the list
+                        last = root[PREV]
+                        link = [last, root, key, result]
+                        last[NEXT] = root[PREV] = cache[key] = link
+                    stats[MISSES] += 1
+                return result
+
+        def cache_info():
+            """Report cache statistics"""
+            with lock:
+                return _CacheInfo(stats[HITS], stats[MISSES], maxsize, len(cache))
+
+        def cache_clear():
+            """Clear the cache and cache statistics"""
+            with lock:
+                cache.clear()
+                root = nonlocal_root[0]
+                root[:] = [root, root, None, None]
+                stats[:] = [0, 0]
+
+        wrapper.__wrapped__ = user_function
+        wrapper.cache_info = cache_info
+        wrapper.cache_clear = cache_clear
+        return update_wrapper(wrapper, user_function)
+
+    return decorating_function
@@ -1,3 +1,3 @@
-from .core import where, old_where
+from .core import contents, where

-__version__ = "2018.10.15"
+__version__ = "2020.06.20"
@@ -1,2 +1,12 @@
-from certifi import where
-print(where())
+import argparse
+
+from certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())
@@ -58,38 +58,6 @@ AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7
 TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg==
 -----END CERTIFICATE-----

-# Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only
-# Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only
-# Label: "Verisign Class 3 Public Primary Certification Authority - G3"
-# Serial: 206684696279472310254277870180966723415
-# MD5 Fingerprint: cd:68:b6:a7:c7:c4:ce:75:e0:1d:4f:57:44:61:92:09
-# SHA1 Fingerprint: 13:2d:0d:45:53:4b:69:97:cd:b2:d5:c3:39:e2:55:76:60:9b:5c:c6
-# SHA256 Fingerprint: eb:04:cf:5e:b1:f3:9a:fa:76:2f:2b:b1:20:f2:96:cb:a5:20:c1:b9:7d:b1:58:95:65:b8:1c:b9:a1:7b:72:44
-----BEGIN CERTIFICATE-----
-MIIEGjCCAwICEQCbfgZJoz5iudXukEhxKe9XMA0GCSqGSIb3DQEBBQUAMIHKMQsw
-CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl
-cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu
-LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT
-aWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp
-dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD
-VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT
-aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ
-bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu
-IENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg
-LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMu6nFL8eB8aHm8b
-N3O9+MlrlBIwT/A2R/XQkQr1F8ilYcEWQE37imGQ5XYgwREGfassbqb1EUGO+i2t
-KmFZpGcmTNDovFJbcCAEWNF6yaRpvIMXZK0Fi7zQWM6NjPXr8EJJC52XJ2cybuGu
-kxUccLwgTS8Y3pKI6GyFVxEa6X7jJhFUokWWVYPKMIno3Nij7SqAP395ZVc+FSBm
-CC+Vk7+qRy+oRpfwEuL+wgorUeZ25rdGt+INpsyow0xZVYnm6FNcHOqd8GIWC6fJ
-Xwzw3sJ2zq/3avL6QaaiMxTJ5Xpj055iN9WFZZ4O5lMkdBteHRJTW8cs54NJOxWu
-imi5V5cCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAERSWwauSCPc/L8my/uRan2Te
-2yFPhpk0djZX3dAVL8WtfxUfN2JzPtTnX84XA9s1+ivbrmAJXx5fj267Cz3qWhMe
-DGBvtcC1IyIuBwvLqXTLR7sdwdela8wv0kL9Sd2nic9TutoAWii/gt/4uhMdUIaC
-/Y4wjylGsB49Ndo4YhYYSq3mtlFs3q9i6wHQHiT+eo8SGhJouPtmmRQURVyu565p
-F4ErWjfJXir0xuKhXFSbplQAz/DxwceYMBo7Nhbbo27q/a2ywtrvAkcTisDxszGt
-TxzhT5yvDwyd93gN2PQ1VoDat20Xj50egWTh/sVFuq1ruQp6Tk9LhO5L8X3dEQ==
-----END CERTIFICATE-----
-
 # Issuer: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
 # Subject: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
 # Label: "Entrust.net Premium 2048 Secure Server CA"
@@ -152,39 +120,6 @@ ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS
 R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp
 -----END CERTIFICATE-----

-# Issuer: CN=AddTrust External CA Root O=AddTrust AB OU=AddTrust External TTP Network
-# Subject: CN=AddTrust External CA Root O=AddTrust AB OU=AddTrust External TTP Network
-# Label: "AddTrust External Root"
-# Serial: 1
-# MD5 Fingerprint: 1d:35:54:04:85:78:b0:3f:42:42:4d:bf:20:73:0a:3f
-# SHA1 Fingerprint: 02:fa:f3:e2:91:43:54:68:60:78:57:69:4d:f5:e4:5b:68:85:18:68
-# SHA256 Fingerprint: 68:7f:a4:51:38:22:78:ff:f0:c8:b1:1f:8d:43:d5:76:67:1c:6e:b2:bc:ea:b4:13:fb:83:d9:65:d0:6d:2f:f2
-----BEGIN CERTIFICATE-----
-MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU
-MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs
-IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290
-MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux
-FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h
-bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v
-dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt
-H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9
-uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX
-mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX
-a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN
-E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0
-WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD
-VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0
-Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU
-cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx
-IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN
-AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH
-YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5
-6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC
-Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX
-c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a
-mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ=
-----END CERTIFICATE-----
-
 # Issuer: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
 # Subject: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
 # Label: "Entrust Root Certification Authority"
@@ -771,36 +706,6 @@ vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep
 +OkuE6N36B9K
 -----END CERTIFICATE-----

-# Issuer: CN=Class 2 Primary CA O=Certplus
-# Subject: CN=Class 2 Primary CA O=Certplus
-# Label: "Certplus Class 2 Primary CA"
-# Serial: 177770208045934040241468760488327595043
-# MD5 Fingerprint: 88:2c:8c:52:b8:a2:3c:f3:f7:bb:03:ea:ae:ac:42:0b
-# SHA1 Fingerprint: 74:20:74:41:72:9c:dd:92:ec:79:31:d8:23:10:8d:c2:81:92:e2:bb
-# SHA256 Fingerprint: 0f:99:3c:8a:ef:97:ba:af:56:87:14:0e:d5:9a:d1:82:1b:b4:af:ac:f0:aa:9a:58:b5:d5:7a:33:8a:3a:fb:cb
-----BEGIN CERTIFICATE-----
-MIIDkjCCAnqgAwIBAgIRAIW9S/PY2uNp9pTXX8OlRCMwDQYJKoZIhvcNAQEFBQAw
-PTELMAkGA1UEBhMCRlIxETAPBgNVBAoTCENlcnRwbHVzMRswGQYDVQQDExJDbGFz
-cyAyIFByaW1hcnkgQ0EwHhcNOTkwNzA3MTcwNTAwWhcNMTkwNzA2MjM1OTU5WjA9
-MQswCQYDVQQGEwJGUjERMA8GA1UEChMIQ2VydHBsdXMxGzAZBgNVBAMTEkNsYXNz
-IDIgUHJpbWFyeSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANxQ
-ltAS+DXSCHh6tlJw/W/uz7kRy1134ezpfgSN1sxvc0NXYKwzCkTsA18cgCSR5aiR
-VhKC9+Ar9NuuYS6JEI1rbLqzAr3VNsVINyPi8Fo3UjMXEuLRYE2+L0ER4/YXJQyL
-kcAbmXuZVg2v7tK8R1fjeUl7NIknJITesezpWE7+Tt9avkGtrAjFGA7v0lPubNCd
-EgETjdyAYveVqUSISnFOYFWe2yMZeVYHDD9jC1yw4r5+FfyUM1hBOHTE4Y+L3yas
-H7WLO7dDWWuwJKZtkIvEcupdM5i3y95ee++U8Rs+yskhwcWYAqqi9lt3m/V+llU0
-HGdpwPFC40es/CgcZlUCAwEAAaOBjDCBiTAPBgNVHRMECDAGAQH/AgEKMAsGA1Ud
-DwQEAwIBBjAdBgNVHQ4EFgQU43Mt38sOKAze3bOkynm4jrvoMIkwEQYJYIZIAYb4
-QgEBBAQDAgEGMDcGA1UdHwQwMC4wLKAqoCiGJmh0dHA6Ly93d3cuY2VydHBsdXMu
-Y29tL0NSTC9jbGFzczIuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQCnVM+IRBnL39R/
-AN9WM2K191EBkOvDP9GIROkkXe/nFL0gt5o8AP5tn9uQ3Nf0YtaLcF3n5QRIqWh8
-yfFC82x/xXp8HVGIutIKPidd3i1RTtMTZGnkLuPT55sJmabglZvOGtd/vjzOUrMR
-FcEPF80Du5wlFbqidon8BvEY0JNLDnyCt6X09l/+7UCmnYR0ObncHoUW2ikbhiMA
-ybuJfm6AiB4vFLQDJKgybwOaRywwvlbGp0ICcBvqQNi6BQNwB6SW//1IMwrh3KWB
-kJtN3X3n57LNXMhqlfil9o3EXXgIvnsG1knPGTZQIy4I5p4FTUcY1Rbpsda2ENW7
-l7+ijrRU
-----END CERTIFICATE-----
-
 # Issuer: CN=DST Root CA X3 O=Digital Signature Trust Co.
 # Subject: CN=DST Root CA X3 O=Digital Signature Trust Co.
 # Label: "DST Root CA X3"
@@ -1219,36 +1124,6 @@ t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw
 WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg==
 -----END CERTIFICATE-----

-# Issuer: CN=Deutsche Telekom Root CA 2 O=Deutsche Telekom AG OU=T-TeleSec Trust Center
-# Subject: CN=Deutsche Telekom Root CA 2 O=Deutsche Telekom AG OU=T-TeleSec Trust Center
-# Label: "Deutsche Telekom Root CA 2"
-# Serial: 38
-# MD5 Fingerprint: 74:01:4a:91:b1:08:c4:58:ce:47:cd:f0:dd:11:53:08
-# SHA1 Fingerprint: 85:a4:08:c0:9c:19:3e:5d:51:58:7d:cd:d6:13:30:fd:8c:de:37:bf
-# SHA256 Fingerprint: b6:19:1a:50:d0:c3:97:7f:7d:a9:9b:cd:aa:c8:6a:22:7d:ae:b9:67:9e:c7:0b:a3:b0:c9:d9:22:71:c1:70:d3
-----BEGIN CERTIFICATE-----
-MIIDnzCCAoegAwIBAgIBJjANBgkqhkiG9w0BAQUFADBxMQswCQYDVQQGEwJERTEc
-MBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxlU2Vj
-IFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290IENB
-IDIwHhcNOTkwNzA5MTIxMTAwWhcNMTkwNzA5MjM1OTAwWjBxMQswCQYDVQQGEwJE
-RTEcMBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxl
-U2VjIFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290
-IENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrC6M14IspFLEU
-ha88EOQ5bzVdSq7d6mGNlUn0b2SjGmBmpKlAIoTZ1KXleJMOaAGtuU1cOs7TuKhC
-QN/Po7qCWWqSG6wcmtoIKyUn+WkjR/Hg6yx6m/UTAtB+NHzCnjwAWav12gz1Mjwr
-rFDa1sPeg5TKqAyZMg4ISFZbavva4VhYAUlfckE8FQYBjl2tqriTtM2e66foai1S
-NNs671x1Udrb8zH57nGYMsRUFUQM+ZtV7a3fGAigo4aKSe5TBY8ZTNXeWHmb0moc
-QqvF1afPaA+W5OFhmHZhyJF81j4A4pFQh+GdCuatl9Idxjp9y7zaAzTVjlsB9WoH
-txa2bkp/AgMBAAGjQjBAMB0GA1UdDgQWBBQxw3kbuvVT1xfgiXotF2wKsyudMzAP
-BgNVHRMECDAGAQH/AgEFMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOC
-AQEAlGRZrTlk5ynrE/5aw4sTV8gEJPB0d8Bg42f76Ymmg7+Wgnxu1MM9756Abrsp
-tJh6sTtU6zkXR34ajgv8HzFZMQSyzhfzLMdiNlXiItiJVbSYSKpk+tYcNthEeFpa
-IzpXl/V6ME+un2pMSyuOoAPjPuCp1NJ70rOo4nI8rZ7/gFnkm0W09juwzTkZmDLl
-6iFhkOQxIY40sfcvNUqFENrnijchvllj4PKFiDFT1FQUhXB59C4Gdyd1Lx+4ivn+
-xbrYNuSD7Odlt79jWvNGr4GUN9RBjNYj1h7P9WgbRGOiWrqnNVmh5XAFmw4jV5mU
-Cm26OWMohpLzGITY+9HPBVZkVw==
-----END CERTIFICATE-----
-
 # Issuer: CN=Cybertrust Global Root O=Cybertrust, Inc
 # Subject: CN=Cybertrust Global Root O=Cybertrust, Inc
 # Label: "Cybertrust Global Root"
@@ -1559,47 +1434,6 @@ uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2
 XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E=
 -----END CERTIFICATE-----

-# Issuer: CN=Staat der Nederlanden Root CA - G2 O=Staat der Nederlanden
-# Subject: CN=Staat der Nederlanden Root CA - G2 O=Staat der Nederlanden
-# Label: "Staat der Nederlanden Root CA - G2"
-# Serial: 10000012
-# MD5 Fingerprint: 7c:a5:0f:f8:5b:9a:7d:6d:30:ae:54:5a:e3:42:a2:8a
-# SHA1 Fingerprint: 59:af:82:79:91:86:c7:b4:75:07:cb:cf:03:57:46:eb:04:dd:b7:16
-# SHA256 Fingerprint: 66:8c:83:94:7d:a6:3b:72:4b:ec:e1:74:3c:31:a0:e6:ae:d0:db:8e:c5:b3:1b:e3:77:bb:78:4f:91:b6:71:6f
-----BEGIN CERTIFICATE-----
-MIIFyjCCA7KgAwIBAgIEAJiWjDANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO
-TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh
-dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEcyMB4XDTA4MDMyNjExMTgxN1oX
-DTIwMDMyNTExMDMxMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl
-ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv
-b3QgQ0EgLSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMVZ5291
-qj5LnLW4rJ4L5PnZyqtdj7U5EILXr1HgO+EASGrP2uEGQxGZqhQlEq0i6ABtQ8Sp
-uOUfiUtnvWFI7/3S4GCI5bkYYCjDdyutsDeqN95kWSpGV+RLufg3fNU254DBtvPU
-Z5uW6M7XxgpT0GtJlvOjCwV3SPcl5XCsMBQgJeN/dVrlSPhOewMHBPqCYYdu8DvE
-pMfQ9XQ+pV0aCPKbJdL2rAQmPlU6Yiile7Iwr/g3wtG61jj99O9JMDeZJiFIhQGp
-5Rbn3JBV3w/oOM2ZNyFPXfUib2rFEhZgF1XyZWampzCROME4HYYEhLoaJXhena/M
-UGDWE4dS7WMfbWV9whUYdMrhfmQpjHLYFhN9C0lK8SgbIHRrxT3dsKpICT0ugpTN
-GmXZK4iambwYfp/ufWZ8Pr2UuIHOzZgweMFvZ9C+X+Bo7d7iscksWXiSqt8rYGPy
-5V6548r6f1CGPqI0GAwJaCgRHOThuVw+R7oyPxjMW4T182t0xHJ04eOLoEq9jWYv
-6q012iDTiIJh8BIitrzQ1aTsr1SIJSQ8p22xcik/Plemf1WvbibG/ufMQFxRRIEK
-eN5KzlW/HdXZt1bv8Hb/C3m1r737qWmRRpdogBQ2HbN/uymYNqUg+oJgYjOk7Na6
-B6duxc8UpufWkjTYgfX8HV2qXB72o007uPc5AgMBAAGjgZcwgZQwDwYDVR0TAQH/
-BAUwAwEB/zBSBgNVHSAESzBJMEcGBFUdIAAwPzA9BggrBgEFBQcCARYxaHR0cDov
-L3d3dy5wa2lvdmVyaGVpZC5ubC9wb2xpY2llcy9yb290LXBvbGljeS1HMjAOBgNV
-HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJFoMocVHYnitfGsNig0jQt8YojrMA0GCSqG
-SIb3DQEBCwUAA4ICAQCoQUpnKpKBglBu4dfYszk78wIVCVBR7y29JHuIhjv5tLyS
-CZa59sCrI2AGeYwRTlHSeYAz+51IvuxBQ4EffkdAHOV6CMqqi3WtFMTC6GY8ggen
-5ieCWxjmD27ZUD6KQhgpxrRW/FYQoAUXvQwjf/ST7ZwaUb7dRUG/kSS0H4zpX897
-IZmflZ85OkYcbPnNe5yQzSipx6lVu6xiNGI1E0sUOlWDuYaNkqbG9AclVMwWVxJK
-gnjIFNkXgiYtXSAfea7+1HAWFpWD2DU5/1JddRwWxRNVz0fMdWVSSt7wsKfkCpYL
-+63C4iWEst3kvX5ZbJvw8NjnyvLplzh+ib7M+zkXYT9y2zqR2GUBGR2tUKRXCnxL
-vJxxcypFURmFzI79R6d0lR2o0a9OF7FpJsKqeFdbxU2n5Z4FF5TKsl+gSRiNNOkm
-bEgeqmiSBeGCc1qb3AdbCG19ndeNIdn8FCCqwkXfP+cAslHkwvgFuXkajDTznlvk
-N1trSt8sV4pAWja63XVECDdCcAz+3F4hoKOKwJCcaNpQ5kUQR3i2TtJlycM33+FC
-Y7BXN0Ute4qcvwXqZVUz9zkQxSgqIXobisQk+T8VyJoVIPVVYpbtbZNQvOSqeK3Z
-ywplh6ZmwcSBo3c6WB4L7oOLnR7SUqTMHW+wmG2UMbX4cQrcufx9MmDm66+KAQ==
-----END CERTIFICATE-----
-
 # Issuer: CN=Hongkong Post Root CA 1 O=Hongkong Post
 # Subject: CN=Hongkong Post Root CA 1 O=Hongkong Post
 # Label: "Hongkong Post Root CA 1"
@@ -2200,6 +2034,45 @@ t/2jioSgrGK+KwmHNPBqAbubKVY8/gA3zyNs8U6qtnRGEmyR7jTV7JqR50S+kDFy
 SjnRBUkLp7Y3gaVdjKozXoEofKd9J+sAro03
 -----END CERTIFICATE-----

+# Issuer: CN=EC-ACC O=Agencia Catalana de Certificacio (NIF Q-0801176-I) OU=Serveis Publics de Certificacio/Vegeu https://www.catcert.net/verarrel (c)03/Jerarquia Entitats de Certificacio Catalanes
+# Subject: CN=EC-ACC O=Agencia Catalana de Certificacio (NIF Q-0801176-I) OU=Serveis Publics de Certificacio/Vegeu https://www.catcert.net/verarrel (c)03/Jerarquia Entitats de Certificacio Catalanes
+# Label: "EC-ACC"
+# Serial: -23701579247955709139626555126524820479
+# MD5 Fingerprint: eb:f5:9d:29:0d:61:f9:42:1f:7c:c2:ba:6d:e3:15:09
+# SHA1 Fingerprint: 28:90:3a:63:5b:52:80:fa:e6:77:4c:0b:6d:a7:d6:ba:a6:4a:f2:e8
+# SHA256 Fingerprint: 88:49:7f:01:60:2f:31:54:24:6a:e2:8c:4d:5a:ef:10:f1:d8:7e:bb:76:62:6f:4a:e0:b7:f9:5b:a7:96:87:99
+-----BEGIN CERTIFICATE-----
+MIIFVjCCBD6gAwIBAgIQ7is969Qh3hSoYqwE893EATANBgkqhkiG9w0BAQUFADCB
+8zELMAkGA1UEBhMCRVMxOzA5BgNVBAoTMkFnZW5jaWEgQ2F0YWxhbmEgZGUgQ2Vy
+dGlmaWNhY2lvIChOSUYgUS0wODAxMTc2LUkpMSgwJgYDVQQLEx9TZXJ2ZWlzIFB1
+YmxpY3MgZGUgQ2VydGlmaWNhY2lvMTUwMwYDVQQLEyxWZWdldSBodHRwczovL3d3
+dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAoYykwMzE1MDMGA1UECxMsSmVyYXJxdWlh
+IEVudGl0YXRzIGRlIENlcnRpZmljYWNpbyBDYXRhbGFuZXMxDzANBgNVBAMTBkVD
+LUFDQzAeFw0wMzAxMDcyMzAwMDBaFw0zMTAxMDcyMjU5NTlaMIHzMQswCQYDVQQG
+EwJFUzE7MDkGA1UEChMyQWdlbmNpYSBDYXRhbGFuYSBkZSBDZXJ0aWZpY2FjaW8g
+KE5JRiBRLTA4MDExNzYtSSkxKDAmBgNVBAsTH1NlcnZlaXMgUHVibGljcyBkZSBD
+ZXJ0aWZpY2FjaW8xNTAzBgNVBAsTLFZlZ2V1IGh0dHBzOi8vd3d3LmNhdGNlcnQu
+bmV0L3ZlcmFycmVsIChjKTAzMTUwMwYDVQQLEyxKZXJhcnF1aWEgRW50aXRhdHMg
+ZGUgQ2VydGlmaWNhY2lvIENhdGFsYW5lczEPMA0GA1UEAxMGRUMtQUNDMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsyLHT+KXQpWIR4NA9h0X84NzJB5R
+85iKw5K4/0CQBXCHYMkAqbWUZRkiFRfCQ2xmRJoNBD45b6VLeqpjt4pEndljkYRm
+4CgPukLjbo73FCeTae6RDqNfDrHrZqJyTxIThmV6PttPB/SnCWDaOkKZx7J/sxaV
+HMf5NLWUhdWZXqBIoH7nF2W4onW4HvPlQn2v7fOKSGRdghST2MDk/7NQcvJ29rNd
+QlB50JQ+awwAvthrDk4q7D7SzIKiGGUzE3eeml0aE9jD2z3Il3rucO2n5nzbcc8t
+lGLfbdb1OL4/pYUKGbio2Al1QnDE6u/LDsg0qBIimAy4E5S2S+zw0JDnJwIDAQAB
+o4HjMIHgMB0GA1UdEQQWMBSBEmVjX2FjY0BjYXRjZXJ0Lm5ldDAPBgNVHRMBAf8E
+BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUoMOLRKo3pUW/l4Ba0fF4
+opvpXY0wfwYDVR0gBHgwdjB0BgsrBgEEAfV4AQMBCjBlMCwGCCsGAQUFBwIBFiBo
+dHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbDA1BggrBgEFBQcCAjApGidW
+ZWdldSBodHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAwDQYJKoZIhvcN
+AQEFBQADggEBAKBIW4IB9k1IuDlVNZyAelOZ1Vr/sXE7zDkJlF7W2u++AVtd0x7Y
+/X1PzaBB4DSTv8vihpw3kpBWHNzrKQXlxJ7HNd+KDM3FIUPpqojlNcAZQmNaAl6k
+SBg6hW/cnbw/nZzBh7h6YQjpdwt/cKt63dmXLGQehb+8dJahw3oS7AwaboMMPOhy
+Rp/7SNVel+axofjk70YllJyJ22k4vuxcDlbHZVHlUIiIv0LVKz3l+bqeLrPK9HOS
+Agu+TGbrIP65y7WZf+a2E/rKS03Z7lNGBjvGTq2TWoF+bCpLagVFjPIhpDGQh2xl
+nJ2lYJU6Un/10asIbvPuW/mIPX64b24D5EI=
+-----END CERTIFICATE-----
+
 # Issuer: CN=Hellenic Academic and Research Institutions RootCA 2011 O=Hellenic Academic and Research Institutions Cert. Authority
 # Subject: CN=Hellenic Academic and Research Institutions RootCA 2011 O=Hellenic Academic and Research Institutions Cert. Authority
 # Label: "Hellenic Academic and Research Institutions RootCA 2011"
@@ -3453,46 +3326,6 @@ AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ
 5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su
 -----END CERTIFICATE-----

-# Issuer: CN=Certinomis - Root CA O=Certinomis OU=0002 433998903
-# Subject: CN=Certinomis - Root CA O=Certinomis OU=0002 433998903
-# Label: "Certinomis - Root CA"
-# Serial: 1
-# MD5 Fingerprint: 14:0a:fd:8d:a8:28:b5:38:69:db:56:7e:61:22:03:3f
-# SHA1 Fingerprint: 9d:70:bb:01:a5:a4:a0:18:11:2e:f7:1c:01:b9:32:c5:34:e7:88:a8
-# SHA256 Fingerprint: 2a:99:f5:bc:11:74:b7:3c:bb:1d:62:08:84:e0:1c:34:e5:1c:cb:39:78:da:12:5f:0e:33:26:88:83:bf:41:58
-----BEGIN CERTIFICATE-----
-MIIFkjCCA3qgAwIBAgIBATANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJGUjET
-MBEGA1UEChMKQ2VydGlub21pczEXMBUGA1UECxMOMDAwMiA0MzM5OTg5MDMxHTAb
-BgNVBAMTFENlcnRpbm9taXMgLSBSb290IENBMB4XDTEzMTAyMTA5MTcxOFoXDTMz
-MTAyMTA5MTcxOFowWjELMAkGA1UEBhMCRlIxEzARBgNVBAoTCkNlcnRpbm9taXMx
-FzAVBgNVBAsTDjAwMDIgNDMzOTk4OTAzMR0wGwYDVQQDExRDZXJ0aW5vbWlzIC0g
-Um9vdCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANTMCQosP5L2
-fxSeC5yaah1AMGT9qt8OHgZbn1CF6s2Nq0Nn3rD6foCWnoR4kkjW4znuzuRZWJfl
-LieY6pOod5tK8O90gC3rMB+12ceAnGInkYjwSond3IjmFPnVAy//ldu9n+ws+hQV
-WZUKxkd8aRi5pwP5ynapz8dvtF4F/u7BUrJ1Mofs7SlmO/NKFoL21prbcpjp3vDF
-TKWrteoB4owuZH9kb/2jJZOLyKIOSY008B/sWEUuNKqEUL3nskoTuLAPrjhdsKkb
-5nPJWqHZZkCqqU2mNAKthH6yI8H7KsZn9DS2sJVqM09xRLWtwHkziOC/7aOgFLSc
-CbAK42C++PhmiM1b8XcF4LVzbsF9Ri6OSyemzTUK/eVNfaoqoynHWmgE6OXWk6Ri
-wsXm9E/G+Z8ajYJJGYrKWUM66A0ywfRMEwNvbqY/kXPLynNvEiCL7sCCeN5LLsJJ
-wx3tFvYk9CcbXFcx3FXuqB5vbKziRcxXV4p1VxngtViZSTYxPDMBbRZKzbgqg4SG
-m/lg0h9tkQPTYKbVPZrdd5A9NaSfD171UkRpucC63M9933zZxKyGIjK8e2uR73r4
-F2iw4lNVYC2vPsKD2NkJK/DAZNuHi5HMkesE/Xa0lZrmFAYb1TQdvtj/dBxThZng
-WVJKYe2InmtJiUZ+IFrZ50rlau7SZRFDAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIB
-BjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTvkUz1pcMw6C8I6tNxIqSSaHh0
-2TAfBgNVHSMEGDAWgBTvkUz1pcMw6C8I6tNxIqSSaHh02TANBgkqhkiG9w0BAQsF
-AAOCAgEAfj1U2iJdGlg+O1QnurrMyOMaauo++RLrVl89UM7g6kgmJs95Vn6RHJk/
-0KGRHCwPT5iVWVO90CLYiF2cN/z7ZMF4jIuaYAnq1fohX9B0ZedQxb8uuQsLrbWw
-F6YSjNRieOpWauwK0kDDPAUwPk2Ut59KA9N9J0u2/kTO+hkzGm2kQtHdzMjI1xZS
-g081lLMSVX3l4kLr5JyTCcBMWwerx20RoFAXlCOotQqSD7J6wWAsOMwaplv/8gzj
-qh8c3LigkyfeY+N/IZ865Z764BNqdeuWXGKRlI5nU7aJ+BIJy29SWwNyhlCVCNSN
-h4YVH5Uk2KRvms6knZtt0rJ2BobGVgjF6wnaNsIbW0G+YSrjcOa4pvi2WsS9Iff/
-ql+hbHY5ZtbqTFXhADObE5hjyW/QASAJN1LnDE8+zbz1X5YnpyACleAu6AdBBR8V
-btaw5BngDwKTACdyxYvRVB9dSsNAl35VpnzBMwQUAR1JIGkLGZOdblgi90AMRgwj
-Y/M50n92Uaf0yKHxDHYiI0ZSKS3io0EHVmmY0gUJvGnHWmHNj4FgFU2A3ZDifcRQ
-8ow7bkrHxuaAKzyBvBGAFhAn1/DNP3nMcyrDflOR1m749fPH0FFNjkulW+YZFzvW
-gQncItzujrnEj1PhZ7szuIgVRs/taTX/dQ1G885x4cVrhkIGuUE=
-----END CERTIFICATE-----
-
 # Issuer: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
 # Subject: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed
 # Label: "OISTE WISeKey Global Root GB CA"
@@ -3849,47 +3682,6 @@ CkcO8DdZEv8tmZQoTipPNU0zWgIxAOp1AE47xDqUEpHJWEadIRNyp4iciuRMStuW
 1KyLa2tJElMzrdfkviT8tQp21KW8EA==
 -----END CERTIFICATE-----

-# Issuer: CN=LuxTrust Global Root 2 O=LuxTrust S.A.
-# Subject: CN=LuxTrust Global Root 2 O=LuxTrust S.A.
-# Label: "LuxTrust Global Root 2"
-# Serial: 59914338225734147123941058376788110305822489521
-# MD5 Fingerprint: b2:e1:09:00:61:af:f7:f1:91:6f:c4:ad:8d:5e:3b:7c
-# SHA1 Fingerprint: 1e:0e:56:19:0a:d1:8b:25:98:b2:04:44:ff:66:8a:04:17:99:5f:3f
-# SHA256 Fingerprint: 54:45:5f:71:29:c2:0b:14:47:c4:18:f9:97:16:8f:24:c5:8f:c5:02:3b:f5:da:5b:e2:eb:6e:1d:d8:90:2e:d5
-----BEGIN CERTIFICATE-----
-MIIFwzCCA6ugAwIBAgIUCn6m30tEntpqJIWe5rgV0xZ/u7EwDQYJKoZIhvcNAQEL
-BQAwRjELMAkGA1UEBhMCTFUxFjAUBgNVBAoMDUx1eFRydXN0IFMuQS4xHzAdBgNV
-BAMMFkx1eFRydXN0IEdsb2JhbCBSb290IDIwHhcNMTUwMzA1MTMyMTU3WhcNMzUw
-MzA1MTMyMTU3WjBGMQswCQYDVQQGEwJMVTEWMBQGA1UECgwNTHV4VHJ1c3QgUy5B
-LjEfMB0GA1UEAwwWTHV4VHJ1c3QgR2xvYmFsIFJvb3QgMjCCAiIwDQYJKoZIhvcN
-AQEBBQADggIPADCCAgoCggIBANeFl78RmOnwYoNMPIf5U2o3C/IPPIfOb9wmKb3F
-ibrJgz337spbxm1Jc7TJRqMbNBM/wYlFV/TZsfs2ZUv7COJIcRHIbjuend+JZTem
-hfY7RBi2xjcwYkSSl2l9QjAk5A0MiWtj3sXh306pFGxT4GHO9hcvHTy95iJMHZP1
-EMShduxq3sVs35a0VkBCwGKSMKEtFZSg0iAGCW5qbeXrt77U8PEVfIvmTroTzEsn
-Xpk8F12PgX8zPU/TPxvsXD/wPEx1bvKm1Z3aLQdjAsZy6ZS8TEmVT4hSyNvoaYL4
-zDRbIvCGp4m9SAptZoFtyMhk+wHh9OHe2Z7d21vUKpkmFRseTJIpgp7VkoGSQXAZ
-96Tlk0u8d2cx3Rz9MXANF5kM+Qw5GSoXtTBxVdUPrljhPS80m8+f9niFwpN6cj5m
-j5wWEWCPnolvZ77gR1o7DJpni89Gxq44o/KnvObWhWszJHAiS8sIm7vI+AIpHb4g
-DEa/a4ebsypmQjVGbKq6rfmYe+lQVRQxv7HaLe2ArWgk+2mr2HETMOZns4dA/Yl+
-8kPREd8vZS9kzl8UubG/Mb2HeFpZZYiq/FkySIbWTLkpS5XTdvN3JW1CHDiDTf2j
-X5t/Lax5Gw5CMZdjpPuKadUiDTSQMC6otOBttpSsvItO13D8xTiOZCXhTTmQzsmH
-hFhxAgMBAAGjgagwgaUwDwYDVR0TAQH/BAUwAwEB/zBCBgNVHSAEOzA5MDcGByuB
-KwEBAQowLDAqBggrBgEFBQcCARYeaHR0cHM6Ly9yZXBvc2l0b3J5Lmx1eHRydXN0
-Lmx1MA4GA1UdDwEB/wQEAwIBBjAfBgNVHSMEGDAWgBT/GCh2+UgFLKGu8SsbK7JT
-+Et8szAdBgNVHQ4EFgQU/xgodvlIBSyhrvErGyuyU/hLfLMwDQYJKoZIhvcNAQEL
-BQADggIBAGoZFO1uecEsh9QNcH7X9njJCwROxLHOk3D+sFTAMs2ZMGQXvw/l4jP9
-BzZAcg4atmpZ1gDlaCDdLnINH2pkMSCEfUmmWjfrRcmF9dTHF5kH5ptV5AzoqbTO
-jFu1EVzPig4N1qx3gf4ynCSecs5U89BvolbW7MM3LGVYvlcAGvI1+ut7MV3CwRI9
-loGIlonBWVx65n9wNOeD4rHh4bhY79SV5GCc8JaXcozrhAIuZY+kt9J/Z93I055c
-qqmkoCUUBpvsT34tC38ddfEz2O3OuHVtPlu5mB0xDVbYQw8wkbIEa91WvpWAVWe+
-2M2D2RjuLg+GLZKecBPs3lHJQ3gCpU3I+V/EkVhGFndadKpAvAefMLmx9xIX3eP/
-JEAdemrRTxgKqpAd60Ae36EeRJIQmvKN4dFLRp7oRUKX6kWZ8+xm1QL68qZKJKre
-zrnK+T+Tb/mjuuqlPpmt/f97mfVl7vBZKGfXkJWkE4SphMHozs51k2MavDzq1WQf
-LSoSOcbDWjLtR5EWDrw4wVDej8oqkDQc7kGUnF4ZLvhFSZl0kbAEb+MEWrGrKqv+
-x9CWttrhSmQGbmBNvUJO/3jaJMobtNeWOWyu8Q6qp31IiyBMz2TWuJdGsE7RKlY6
-oJO9r4Ak4Ap+58rVyuiFVdw2KuGUaJPHZnJED4AhMmwlxyOAgwrr
-----END CERTIFICATE-----
-
 # Issuer: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
 # Subject: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM
 # Label: "TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1"
@@ -4268,3 +4060,561 @@ rYy0UGYwEAYJKwYBBAGCNxUBBAMCAQAwCgYIKoZIzj0EAwMDaAAwZQIwJsdpW9zV
 57LnyAyMjMPdeYwbY9XJUpROTYJKcx6ygISpJcBMWm1JKWB4E+J+SOtkAjEA2zQg
 Mgj/mkkCtojeFK9dbJlxjRo/i9fgojaGHAeCOnZT/cKi7e97sIBPWA9LUzm9
 -----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R1 O=Google Trust Services LLC
+# Subject: CN=GTS Root R1 O=Google Trust Services LLC
+# Label: "GTS Root R1"
+# Serial: 146587175971765017618439757810265552097
+# MD5 Fingerprint: 82:1a:ef:d4:d2:4a:f2:9f:e2:3d:97:06:14:70:72:85
+# SHA1 Fingerprint: e1:c9:50:e6:ef:22:f8:4c:56:45:72:8b:92:20:60:d7:d5:a7:a3:e8
+# SHA256 Fingerprint: 2a:57:54:71:e3:13:40:bc:21:58:1c:bd:2c:f1:3e:15:84:63:20:3e:ce:94:bc:f9:d3:cc:19:6b:f0:9a:54:72
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgIQbkepxUtHDA3sM9CJuRz04TANBgkqhkiG9w0BAQwFADBH
+MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM
+QzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIy
+MDAwMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNl
+cnZpY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQC2EQKLHuOhd5s73L+UPreVp0A8of2C+X0yBoJx9vaM
+f/vo27xqLpeXo4xL+Sv2sfnOhB2x+cWX3u+58qPpvBKJXqeqUqv4IyfLpLGcY9vX
+mX7wCl7raKb0xlpHDU0QM+NOsROjyBhsS+z8CZDfnWQpJSMHobTSPS5g4M/SCYe7
+zUjwTcLCeoiKu7rPWRnWr4+wB7CeMfGCwcDfLqZtbBkOtdh+JhpFAz2weaSUKK0P
+fyblqAj+lug8aJRT7oM6iCsVlgmy4HqMLnXWnOunVmSPlk9orj2XwoSPwLxAwAtc
+vfaHszVsrBhQf4TgTM2S0yDpM7xSma8ytSmzJSq0SPly4cpk9+aCEI3oncKKiPo4
+Zor8Y/kB+Xj9e1x3+naH+uzfsQ55lVe0vSbv1gHR6xYKu44LtcXFilWr06zqkUsp
+zBmkMiVOKvFlRNACzqrOSbTqn3yDsEB750Orp2yjj32JgfpMpf/VjsPOS+C12LOO
+Rc92wO1AK/1TD7Cn1TsNsYqiA94xrcx36m97PtbfkSIS5r762DL8EGMUUXLeXdYW
+k70paDPvOmbsB4om3xPXV2V4J95eSRQAogB/mqghtqmxlbCluQ0WEdrHbEg8QOB+
+DVrNVjzRlwW5y0vtOUucxD/SVRNuJLDWcfr0wbrM7Rv1/oFB2ACYPTrIrnqYNxgF
+lQIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQU5K8rJnEaK0gnhS9SZizv8IkTcT4wDQYJKoZIhvcNAQEMBQADggIBADiW
+Cu49tJYeX++dnAsznyvgyv3SjgofQXSlfKqE1OXyHuY3UjKcC9FhHb8owbZEKTV1
+d5iyfNm9dKyKaOOpMQkpAWBz40d8U6iQSifvS9efk+eCNs6aaAyC58/UEBZvXw6Z
+XPYfcX3v73svfuo21pdwCxXu11xWajOl40k4DLh9+42FpLFZXvRq4d2h9mREruZR
+gyFmxhE+885H7pwoHyXa/6xmld01D1zvICxi/ZG6qcz8WpyTgYMpl0p8WnK0OdC3
+d8t5/Wk6kjftbjhlRn7pYL15iJdfOBL07q9bgsiG1eGZbYwE8na6SfZu6W0eX6Dv
+J4J2QPim01hcDyxC2kLGe4g0x8HYRZvBPsVhHdljUEn2NIVq4BjFbkerQUIpm/Zg
+DdIx02OYI5NaAIFItO/Nis3Jz5nu2Z6qNuFoS3FJFDYoOj0dzpqPJeaAcWErtXvM
+SUWgeExX6GjfhaknBZqlxi9dnKlC54dNuYvoS++cJEPqOba+MSSQGwlfnuzCdyy
+F62ARPBopY+Udf90WuioAnwMCeKpSwughQtiue+hMZL77/ZRBIls6Kl0obsXs7X9
+SQ98POyDGCBDTtWTurQ0sR8WNh8M5mQ5Fkzc4P4dyKliPUDqysU0ArSuiYgzNdws
+E3PYJ/HQcu51OyLemGhmW/HGY0dVHLqlCFF1pkgl
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R2 O=Google Trust Services LLC
+# Subject: CN=GTS Root R2 O=Google Trust Services LLC
+# Label: "GTS Root R2"
+# Serial: 146587176055767053814479386953112547951
+# MD5 Fingerprint: 44:ed:9a:0e:a4:09:3b:00:f2:ae:4c:a3:c6:61:b0:8b
+# SHA1 Fingerprint: d2:73:96:2a:2a:5e:39:9f:73:3f:e1:c7:1e:64:3f:03:38:34:fc:4d
+# SHA256 Fingerprint: c4:5d:7b:b0:8e:6d:67:e6:2e:42:35:11:0b:56:4e:5f:78:fd:92:ef:05:8c:84:0a:ea:4e:64:55:d7:58:5c:60
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgIQbkepxlqz5yDFMJo/aFLybzANBgkqhkiG9w0BAQwFADBH
+MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM
+QzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIy
+MDAwMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNl
+cnZpY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQDO3v2m++zsFDQ8BwZabFn3GTXd98GdVarTzTukk3Lv
+CvptnfbwhYBboUhSnznFt+4orO/LdmgUud+tAWyZH8QiHZ/+cnfgLFuv5AS/T3Kg
+GjSY6Dlo7JUle3ah5mm5hRm9iYz+re026nO8/4Piy33B0s5Ks40FnotJk9/BW9Bu
+XvAuMC6C/Pq8tBcKSOWIm8Wba96wyrQD8Nr0kLhlZPdcTK3ofmZemde4wj7I0BOd
+re7kRXuJVfeKH2JShBKzwkCX44ofR5GmdFrS+LFjKBC4swm4VndAoiaYecb+3yXu
+PuWgf9RhD1FLPD+M2uFwdNjCaKH5wQzpoeJ/u1U8dgbuak7MkogwTZq9TwtImoS1
+mKPV+3PBV2HdKFZ1E66HjucMUQkQdYhMvI35ezzUIkgfKtzra7tEscszcTJGr61K
+8YzodDqs5xoic4DSMPclQsciOzsSrZYuxsN2B6ogtzVJV+mSSeh2FnIxZyuWfoqj
+x5RWIr9qS34BIbIjMt/kmkRtWVtd9QCgHJvGeJeNkP+byKq0rxFROV7Z+2et1VsR
+nTKaG73VululycslaVNVJ1zgyjbLiGH7HrfQy+4W+9OmTN6SpdTi3/UGVN4unUu0
+kzCqgc7dGtxRcw1PcOnlthYhGXmy5okLdWTK1au8CcEYof/UVKGFPP0UJAOyh9Ok
+twIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV
+HQ4EFgQUu//KjiOfT5nK2+JopqUVJxce2Q4wDQYJKoZIhvcNAQEMBQADggIBALZp
+8KZ3/p7uC4Gt4cCpx/k1HUCCq+YEtN/L9x0Pg/B+E02NjO7jMyLDOfxA325BS0JT
+vhaI8dI4XsRomRyYUpOM52jtG2pzegVATX9lO9ZY8c6DR2Dj/5epnGB3GFW1fgiT
+z9D2PGcDFWEJ+YF59exTpJ/JjwGLc8R3dtyDovUMSRqodt6Sm2T4syzFJ9MHwAiA
+pJiS4wGWAqoC7o87xdFtCjMwc3i5T1QWvwsHoaRc5svJXISPD+AVdyx+Jn7axEvb
+pxZ3B7DNdehyQtaVhJ2Gg/LkkM0JR9SLA3DaWsYDQvTtN6LwG1BUSw7YhN4ZKJmB
+R64JGz9I0cNv4rBgF/XuIwKl2gBbbZCr7qLpGzvpx0QnRY5rn/WkhLx3+WuXrD5R
+RaIRpsyF7gpo8j5QOHokYh4XIDdtak23CZvJ/KRY9bb7nE4Yu5UC56GtmwfuNmsk
+0jmGwZODUNKBRqhfYlcsu2xkiAhu7xNUX90txGdj08+JN7+dIPT7eoOboB6BAFDC
+5AwiWVIQ7UNWhwD4FFKnHYuTjKJNRn8nxnGbJN7k2oaLDX5rIMHAnuFl2GqjpuiF
+izoHCBy69Y9Vmhh1fuXsgWbRIXOhNUQLgD1bnF5vKheW0YMjiGZt5obicDIvUiLn
+yOd/xCxgXS/Dr55FBcOEArf9LAhST4Ldo/DUhgkC
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R3 O=Google Trust Services LLC
+# Subject: CN=GTS Root R3 O=Google Trust Services LLC
+# Label: "GTS Root R3"
+# Serial: 146587176140553309517047991083707763997
+# MD5 Fingerprint: 1a:79:5b:6b:04:52:9c:5d:c7:74:33:1b:25:9a:f9:25
+# SHA1 Fingerprint: 30:d4:24:6f:07:ff:db:91:89:8a:0b:e9:49:66:11:eb:8c:5e:46:e5
+# SHA256 Fingerprint: 15:d5:b8:77:46:19:ea:7d:54:ce:1c:a6:d0:b0:c4:03:e0:37:a9:17:f1:31:e8:a0:4e:1e:6b:7a:71:ba:bc:e5
+-----BEGIN CERTIFICATE-----
+MIICDDCCAZGgAwIBAgIQbkepx2ypcyRAiQ8DVd2NHTAKBggqhkjOPQQDAzBHMQsw
+CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
+MBIGA1UEAxMLR1RTIFJvb3QgUjMwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
+MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
+Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjMwdjAQBgcqhkjOPQIBBgUrgQQA
+IgNiAAQfTzOHMymKoYTey8chWEGJ6ladK0uFxh1MJ7x/JlFyb+Kf1qPKzEUURout
+736GjOyxfi//qXGdGIRFBEFVbivqJn+7kAHjSxm65FSWRQmx1WyRRK2EE46ajA2A
+DDL24CejQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
+DgQWBBTB8Sa6oC2uhYHP0/EqEr24Cmf9vDAKBggqhkjOPQQDAwNpADBmAjEAgFuk
+fCPAlaUs3L6JbyO5o91lAFJekazInXJ0glMLfalAvWhgxeG4VDvBNhcl2MG9AjEA
+njWSdIUlUfUk7GRSJFClH9voy8l27OyCbvWFGFPouOOaKaqW04MjyaR7YbPMAuhd
+-----END CERTIFICATE-----
+
+# Issuer: CN=GTS Root R4 O=Google Trust Services LLC
+# Subject: CN=GTS Root R4 O=Google Trust Services LLC
+# Label: "GTS Root R4"
+# Serial: 146587176229350439916519468929765261721
+# MD5 Fingerprint: 5d:b6:6a:c4:60:17:24:6a:1a:99:a8:4b:ee:5e:b4:26
+# SHA1 Fingerprint: 2a:1d:60:27:d9:4a:b1:0a:1c:4d:91:5c:cd:33:a0:cb:3e:2d:54:cb
+# SHA256 Fingerprint: 71:cc:a5:39:1f:9e:79:4b:04:80:25:30:b3:63:e1:21:da:8a:30:43:bb:26:66:2f:ea:4d:ca:7f:c9:51:a4:bd
+-----BEGIN CERTIFICATE-----
+MIICCjCCAZGgAwIBAgIQbkepyIuUtui7OyrYorLBmTAKBggqhkjOPQQDAzBHMQsw
+CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU
+MBIGA1UEAxMLR1RTIFJvb3QgUjQwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw
+MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp
+Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjQwdjAQBgcqhkjOPQIBBgUrgQQA
+IgNiAATzdHOnaItgrkO4NcWBMHtLSZ37wWHO5t5GvWvVYRg1rkDdc/eJkTBa6zzu
+hXyiQHY7qca4R9gq55KRanPpsXI5nymfopjTX15YhmUPoYRlBtHci8nHc8iMai/l
+xKvRHYqjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud
+DgQWBBSATNbrdP9JNqPV2Py1PsVq8JQdjDAKBggqhkjOPQQDAwNnADBkAjBqUFJ0
+CMRw3J5QdCHojXohw0+WbhXRIjVhLfoIN+4Zba3bssx9BzT1YBkstTTZbyACMANx
+sbqjYAuG7ZoIapVon+Kz4ZNkfF6Tpt95LY2F45TPI11xzPKwTdb+mciUqXWi4w==
+-----END CERTIFICATE-----
+
+# Issuer: CN=UCA Global G2 Root O=UniTrust
+# Subject: CN=UCA Global G2 Root O=UniTrust
+# Label: "UCA Global G2 Root"
+# Serial: 124779693093741543919145257850076631279
+# MD5 Fingerprint: 80:fe:f0:c4:4a:f0:5c:62:32:9f:1c:ba:78:a9:50:f8
+# SHA1 Fingerprint: 28:f9:78:16:19:7a:ff:18:25:18:aa:44:fe:c1:a0:ce:5c:b6:4c:8a
+# SHA256 Fingerprint: 9b:ea:11:c9:76:fe:01:47:64:c1:be:56:a6:f9:14:b5:a5:60:31:7a:bd:99:88:39:33:82:e5:16:1a:a0:49:3c
+-----BEGIN CERTIFICATE-----
+MIIFRjCCAy6gAwIBAgIQXd+x2lqj7V2+WmUgZQOQ7zANBgkqhkiG9w0BAQsFADA9
+MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxGzAZBgNVBAMMElVDQSBH
+bG9iYWwgRzIgUm9vdDAeFw0xNjAzMTEwMDAwMDBaFw00MDEyMzEwMDAwMDBaMD0x
+CzAJBgNVBAYTAkNOMREwDwYDVQQKDAhVbmlUcnVzdDEbMBkGA1UEAwwSVUNBIEds
+b2JhbCBHMiBSb290MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxeYr
+b3zvJgUno4Ek2m/LAfmZmqkywiKHYUGRO8vDaBsGxUypK8FnFyIdK+35KYmToni9
+kmugow2ifsqTs6bRjDXVdfkX9s9FxeV67HeToI8jrg4aA3++1NDtLnurRiNb/yzm
+VHqUwCoV8MmNsHo7JOHXaOIxPAYzRrZUEaalLyJUKlgNAQLx+hVRZ2zA+te2G3/R
+VogvGjqNO7uCEeBHANBSh6v7hn4PJGtAnTRnvI3HLYZveT6OqTwXS3+wmeOwcWDc
+C/Vkw85DvG1xudLeJ1uK6NjGruFZfc8oLTW4lVYa8bJYS7cSN8h8s+1LgOGN+jIj
+tm+3SJUIsUROhYw6AlQgL9+/V087OpAh18EmNVQg7Mc/R+zvWr9LesGtOxdQXGLY
+D0tK3Cv6brxzks3sx1DoQZbXqX5t2Okdj4q1uViSukqSKwxW/YDrCPBeKW4bHAyv
+j5OJrdu9o54hyokZ7N+1wxrrFv54NkzWbtA+FxyQF2smuvt6L78RHBgOLXMDj6Dl
+NaBa4kx1HXHhOThTeEDMg5PXCp6dW4+K5OXgSORIskfNTip1KnvyIvbJvgmRlld6
+iIis7nCs+dwp4wwcOxJORNanTrAmyPPZGpeRaOrvjUYG0lZFWJo8DA+DuAUlwznP
+O6Q0ibd5Ei9Hxeepl2n8pndntd978XplFeRhVmUCAwEAAaNCMEAwDgYDVR0PAQH/
+BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFIHEjMz15DD/pQwIX4wV
+ZyF0Ad/fMA0GCSqGSIb3DQEBCwUAA4ICAQATZSL1jiutROTL/7lo5sOASD0Ee/oj
+L3rtNtqyzm325p7lX1iPyzcyochltq44PTUbPrw7tgTQvPlJ9Zv3hcU2tsu8+Mg5
+1eRfB70VVJd0ysrtT7q6ZHafgbiERUlMjW+i67HM0cOU2kTC5uLqGOiiHycFutfl
+1qnN3e92mI0ADs0b+gO3joBYDic/UvuUospeZcnWhNq5NXHzJsBPd+aBJ9J3O5oU
+b3n09tDh05S60FdRvScFDcH9yBIw7m+NESsIndTUv4BFFJqIRNow6rSn4+7vW4LV
+PtateJLbXDzz2K36uGt/xDYotgIVilQsnLAXc47QN6MUPJiVAAwpBVueSUmxX8fj
+y88nZY41F7dXyDDZQVu5FLbowg+UMaeUmMxq67XhJ/UQqAHojhJi6IjMtX9Gl8Cb
+EGY4GjZGXyJoPd/JxhMnq1MGrKI8hgZlb7F+sSlEmqO6SWkoaY/X5V+tBIZkbxqg
+DMUIYs6Ao9Dz7GjevjPHF1t/gMRMTLGmhIrDO7gJzRSBuhjjVFc2/tsvfEehOjPI
+Vg7RE+xygKJBJYoaMVLuCaJu9YzL1DV/pqJuhgyklTGW+Cd+V7lDSKb9triyCGy
+YiGqhkCyLmTTX8jjfhFnRR8F/uOi77Oos/N9j/gMHyIfLXC0uAE0djAA5SN4p1bX
+UB+K+wb1whnw0A==
+-----END CERTIFICATE-----
+
+# Issuer: CN=UCA Extended Validation Root O=UniTrust
+# Subject: CN=UCA Extended Validation Root O=UniTrust
+# Label: "UCA Extended Validation Root"
+# Serial: 106100277556486529736699587978573607008
+# MD5 Fingerprint: a1:f3:5f:43:c6:34:9b:da:bf:8c:7e:05:53:ad:96:e2
+# SHA1 Fingerprint: a3:a1:b0:6f:24:61:23:4a:e3:36:a5:c2:37:fc:a6:ff:dd:f0:d7:3a
+# SHA256 Fingerprint: d4:3a:f9:b3:54:73:75:5c:96:84:fc:06:d7:d8:cb:70:ee:5c:28:e7:73:fb:29:4e:b4:1e:e7:17:22:92:4d:24
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgIQT9Irj/VkyDOeTzRYZiNwYDANBgkqhkiG9w0BAQsFADBH
+MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNVBAMMHFVDQSBF
+eHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwHhcNMTUwMzEzMDAwMDAwWhcNMzgxMjMx
+MDAwMDAwWjBHMQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNV
+BAMMHFVDQSBFeHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwggIiMA0GCSqGSIb3DQEB
+AQUAA4ICDwAwggIKAoICAQCpCQcoEwKwmeBkqh5DFnpzsZGgdT6o+uM4AHrsiWog
+D4vFsJszA1qGxliG1cGFu0/GnEBNyr7uaZa4rYEwmnySBesFK5pI0Lh2PpbIILvS
+sPGP2KxFRv+qZ2C0d35qHzwaUnoEPQc8hQ2E0B92CvdqFN9y4zR8V05WAT558aop
+O2z6+I9tTcg1367r3CTueUWnhbYFiN6IXSV8l2RnCdm/WhUFhvMJHuxYMjMR83dk
+sHYf5BA1FxvyDrFspCqjc/wJHx4yGVMR59mzLC52LqGj3n5qiAno8geK+LLNEOfi
+c0CTuwjRP+H8C5SzJe98ptfRr5//lpr1kXuYC3fUfugH0mK1lTnj8/FtDw5lhIpj
+VMWAtuCeS31HJqcBCF3RiJ7XwzJE+oJKCmhUfzhTA8ykADNkUVkLo4KRel7sFsLz
+KuZi2irbWWIQJUoqgQtHB0MGcIfS+pMRKXpITeuUx3BNr2fVUbGAIAEBtHoIppB/
+TuDvB0GHr2qlXov7z1CymlSvw4m6WC31MJixNnI5fkkE/SmnTHnkBVfblLkWU41G
+sx2VYVdWf6/wFlthWG82UBEL2KwrlRYaDh8IzTY0ZRBiZtWAXxQgXy0MoHgKaNYs
+1+lvK9JKBZP8nm9rZ/+I8U6laUpSNwXqxhaN0sSZ0YIrO7o1dfdRUVjzyAfd5LQD
+fwIDAQABo0IwQDAdBgNVHQ4EFgQU2XQ65DA9DfcS3H5aBZ8eNJr34RQwDwYDVR0T
+AQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQADggIBADaN
+l8xCFWQpN5smLNb7rhVpLGsaGvdftvkHTFnq88nIua7Mui563MD1sC3AO6+fcAUR
+ap8lTwEpcOPlDOHqWnzcSbvBHiqB9RZLcpHIojG5qtr8nR/zXUACE/xOHAbKsxSQ
+VBcZEhrxH9cMaVr2cXj0lH2RC47skFSOvG+hTKv8dGT9cZr4QQehzZHkPJrgmzI5
+c6sq1WnIeJEmMX3ixzDx/BR4dxIOE/TdFpS/S2d7cFOFyrC78zhNLJA5wA3CXWvp
+4uXViI3WLL+rG761KIcSF3Ru/H38j9CHJrAb+7lsq+KePRXBOy5nAliRn+/4Qh8s
+t2j1da3Ptfb/EX3C8CSlrdP6oDyp+l3cpaDvRKS+1ujl5BOWF3sGPjLtx7dCvHaj
+2GU4Kzg1USEODm8uNBNA4StnDG1KQTAYI1oyVZnJF+A83vbsea0rWBmirSwiGpWO
+vpaQXUJXxPkUAzUrHC1RVwinOt4/5Mi0A3PCwSaAuwtCH60NryZy2sy+s6ODWA2C
+xR9GUeOcGMyNm43sSet1UNWMKFnKdDTajAshqx7qG+XH/RU+wBeq+yNuJkbL+vmx
+cmtpzyKEC2IPrNkZAJSidjzULZrtBJ4tBmIQN1IchXIbJ+XMxjHsN+xjWZsLHXbM
+fjKaiJUINlK73nZfdklJrX+9ZSCyycErdhh2n1ax
+-----END CERTIFICATE-----
+
+# Issuer: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
+# Subject: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036
+# Label: "Certigna Root CA"
+# Serial: 269714418870597844693661054334862075617
+# MD5 Fingerprint: 0e:5c:30:62:27:eb:5b:bc:d7:ae:62:ba:e9:d5:df:77
+# SHA1 Fingerprint: 2d:0d:52:14:ff:9e:ad:99:24:01:74:20:47:6e:6c:85:27:27:f5:43
+# SHA256 Fingerprint: d4:8d:3d:23:ee:db:50:a4:59:e5:51:97:60:1c:27:77:4b:9d:7b:18:c9:4d:5a:05:95:11:a1:02:50:b9:31:68
+-----BEGIN CERTIFICATE-----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=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
+# Subject: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI
+# Label: "emSign Root CA - G1"
+# Serial: 235931866688319308814040
+# MD5 Fingerprint: 9c:42:84:57:dd:cb:0b:a7:2e:95:ad:b6:f3:da:bc:ac
+# SHA1 Fingerprint: 8a:c7:ad:8f:73:ac:4e:c1:b5:75:4d:a5:40:f4:fc:cf:7c:b5:8e:8c
+# SHA256 Fingerprint: 40:f6:af:03:46:a9:9a:a1:cd:1d:55:5a:4e:9c:ce:62:c7:f9:63:46:03:ee:40:66:15:83:3d:c8:c8:d0:03:67
+-----BEGIN CERTIFICATE-----
+MIIDlDCCAnygAwIBAgIKMfXkYgxsWO3W2DANBgkqhkiG9w0BAQsFADBnMQswCQYD
+VQQGEwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBU
+ZWNobm9sb2dpZXMgTGltaXRlZDEcMBoGA1UEAxMTZW1TaWduIFJvb3QgQ0EgLSBH
+MTAeFw0xODAyMTgxODMwMDBaFw00MzAyMTgxODMwMDBaMGcxCzAJBgNVBAYTAklO
+MRMwEQYDVQQLEwplbVNpZ24gUEtJMSUwIwYDVQQKExxlTXVkaHJhIFRlY2hub2xv
+Z2llcyBMaW1pdGVkMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEcxMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAk0u76WaK7p1b1TST0Bsew+eeuGQz
+f2N4aLTNLnF115sgxk0pvLZoYIr3IZpWNVrzdr3YzZr/k1ZLpVkGoZM0Kd0WNHVO
+8oG0x5ZOrRkVUkr+PHB1cM2vK6sVmjM8qrOLqs1D/fXqcP/tzxE7lM5OMhbTI0Aq
+d7OvPAEsbO2ZLIvZTmmYsvePQbAyeGHWDV/D+qJAkh1cF+ZwPjXnorfCYuKrpDhM
+tTk1b+oDafo6VGiFbdbyL0NVHpENDtjVaqSW0RM8LHhQ6DqS0hdW5TUaQBw+jSzt
+Od9C4INBdN+jzcKGYEho42kLVACL5HZpIQ15TjQIXhTCzLG3rdd8cIrHhQIDAQAB
+o0IwQDAdBgNVHQ4EFgQU++8Nhp6w492pufEhF38+/PB3KxowDgYDVR0PAQH/BAQD
+AgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAFn/8oz1h31x
+PaOfG1vR2vjTnGs2vZupYeveFix0PZ7mddrXuqe8QhfnPZHr5X3dPpzxz5KsbEjM
+wiI/aTvFthUvozXGaCocV685743QNcMYDHsAVhzNixl03r4PEuDQqqE/AjSxcM6d
+GNYIAwlG7mDgfrbESQRRfXBgvKqy/3lyeqYdPV8q+Mri/Tm3R7nrft8EI6/6nAYH
+6ftjk4BAtcZsCjEozgyfz7MjNYBBjWzEN3uBL4ChQEKF6dk4jeihU80Bv2noWgby
+RQuQ+q7hv53yrlc8pa6yVvSLZUDp/TGBLPQ5Cdjua6e0ph0VpZj3AYHYhX3zUVxx
+iN66zB+Afko=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
+# Subject: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI
+# Label: "emSign ECC Root CA - G3"
+# Serial: 287880440101571086945156
+# MD5 Fingerprint: ce:0b:72:d1:9f:88:8e:d0:50:03:e8:e3:b8:8b:67:40
+# SHA1 Fingerprint: 30:43:fa:4f:f2:57:dc:a0:c3:80:ee:2e:58:ea:78:b2:3f:e6:bb:c1
+# SHA256 Fingerprint: 86:a1:ec:ba:08:9c:4a:8d:3b:be:27:34:c6:12:ba:34:1d:81:3e:04:3c:f9:e8:a8:62:cd:5c:57:a3:6b:be:6b
+-----BEGIN CERTIFICATE-----
+MIICTjCCAdOgAwIBAgIKPPYHqWhwDtqLhDAKBggqhkjOPQQDAzBrMQswCQYDVQQG
+EwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNo
+bm9sb2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0g
+RzMwHhcNMTgwMjE4MTgzMDAwWhcNNDMwMjE4MTgzMDAwWjBrMQswCQYDVQQGEwJJ
+TjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNobm9s
+b2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0gRzMw
+djAQBgcqhkjOPQIBBgUrgQQAIgNiAAQjpQy4LRL1KPOxst3iAhKAnjlfSU2fySU0
+WXTsuwYc58Byr+iuL+FBVIcUqEqy6HyC5ltqtdyzdc6LBtCGI79G1Y4PPwT01xyS
+fvalY8L1X44uT6EYGQIrMgqCZH0Wk9GjQjBAMB0GA1UdDgQWBBR8XQKEE9TMipuB
+zhccLikenEhjQjAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAKBggq
+hkjOPQQDAwNpADBmAjEAvvNhzwIQHWSVB7gYboiFBS+DCBeQyh+KTOgNG3qxrdWB
+CUfvO6wIBHxcmbHtRwfSAjEAnbpV/KlK6O3t5nYBQnvI+GDZjVGLVTv7jHvrZQnD
+JbNR6iC8hZVdyR+EhCVBCyj
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
+# Subject: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI
+# Label: "emSign Root CA - C1"
+# Serial: 825510296613316004955058
+# MD5 Fingerprint: d8:e3:5d:01:21:fa:78:5a:b0:df:ba:d2:ee:2a:5f:68
+# SHA1 Fingerprint: e7:2e:f1:df:fc:b2:09:28:cf:5d:d4:d5:67:37:b1:51:cb:86:4f:01
+# SHA256 Fingerprint: 12:56:09:aa:30:1d:a0:a2:49:b9:7a:82:39:cb:6a:34:21:6f:44:dc:ac:9f:39:54:b1:42:92:f2:e8:c8:60:8f
+-----BEGIN CERTIFICATE-----
+MIIDczCCAlugAwIBAgILAK7PALrEzzL4Q7IwDQYJKoZIhvcNAQELBQAwVjELMAkG
+A1UEBhMCVVMxEzARBgNVBAsTCmVtU2lnbiBQS0kxFDASBgNVBAoTC2VNdWRocmEg
+SW5jMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEMxMB4XDTE4MDIxODE4MzAw
+MFoXDTQzMDIxODE4MzAwMFowVjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
+biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMRwwGgYDVQQDExNlbVNpZ24gUm9v
+dCBDQSAtIEMxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz+upufGZ
+BczYKCFK83M0UYRWEPWgTywS4/oTmifQz/l5GnRfHXk5/Fv4cI7gklL35CX5VIPZ
+HdPIWoU/Xse2B+4+wM6ar6xWQio5JXDWv7V7Nq2s9nPczdcdioOl+yuQFTdrHCZH
+3DspVpNqs8FqOp099cGXOFgFixwR4+S0uF2FHYP+eF8LRWgYSKVGczQ7/g/IdrvH
+GPMF0Ybzhe3nudkyrVWIzqa2kbBPrH4VI5b2P/AgNBbeCsbEBEV5f6f9vtKppa+c
+xSMq9zwhbL2vj07FOrLzNBL834AaSaTUqZX3noleoomslMuoaJuvimUnzYnu3Yy1
+aylwQ6BpC+S5DwIDAQABo0IwQDAdBgNVHQ4EFgQU/qHgcB4qAzlSWkK+XJGFehiq
+TbUwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBAMJKVvoVIXsoounlHfv4LcQ5lkFMOycsxGwYFYDGrK9HWS8mC+M2sO87
+/kOXSTKZEhVb3xEp/6tT+LvBeA+snFOvV71ojD1pM/CjoCNjO2RnIkSt1XHLVip4
+kqNPEjE2NuLe/gDEo2APJ62gsIq1NnpSob0n9CAnYuhNlCQT5AoE6TyrLshDCUrG
+YQTlSTR+08TI9Q/Aqum6VF7zYytPT1DU/rl7mYw9wC68AivTxEDkigcxHpvOJpkT
+xHqmiIMERnHXhuBUDDIlhJu58tBf5E7oke3VIAb3ADMmpDqw8NQBmIMMMAVSKeo
+WXzhriKi4gp6D/piq1JM4fHfyr6DDUI=
+-----END CERTIFICATE-----
+
+# Issuer: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
+# Subject: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI
+# Label: "emSign ECC Root CA - C3"
+# Serial: 582948710642506000014504
+# MD5 Fingerprint: 3e:53:b3:a3:81:ee:d7:10:f8:d3:b0:1d:17:92:f5:d5
+# SHA1 Fingerprint: b6:af:43:c2:9b:81:53:7d:f6:ef:6b:c3:1f:1f:60:15:0c:ee:48:66
+# SHA256 Fingerprint: bc:4d:80:9b:15:18:9d:78:db:3e:1d:8c:f4:f9:72:6a:79:5d:a1:64:3c:a5:f1:35:8e:1d:db:0e:dc:0d:7e:b3
+-----BEGIN CERTIFICATE-----
+MIICKzCCAbGgAwIBAgIKe3G2gla4EnycqDAKBggqhkjOPQQDAzBaMQswCQYDVQQG
+EwJVUzETMBEGA1UECxMKZW1TaWduIFBLSTEUMBIGA1UEChMLZU11ZGhyYSBJbmMx
+IDAeBgNVBAMTF2VtU2lnbiBFQ0MgUm9vdCBDQSAtIEMzMB4XDTE4MDIxODE4MzAw
+MFoXDTQzMDIxODE4MzAwMFowWjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln
+biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMSAwHgYDVQQDExdlbVNpZ24gRUND
+IFJvb3QgQ0EgLSBDMzB2MBAGByqGSM49AgEGBSuBBAAiA2IABP2lYa57JhAd6bci
+MK4G9IGzsUJxlTm801Ljr6/58pc1kjZGDoeVjbk5Wum739D+yAdBPLtVb4Ojavti
+sIGJAnB9SMVK4+kiVCJNk7tCDK93nCOmfddhEc5lx/h//vXyqaNCMEAwHQYDVR0O
+BBYEFPtaSNCAIEDyqOkAB2kZd6fmw/TPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMB
+Af8EBTADAQH/MAoGCCqGSM49BAMDA2gAMGUCMQC02C8Cif22TGK6Q04ThHK1rt0c
+3ta13FaPWEBaLd4gTCKDypOofu4SQMfWh0/434UCMBwUZOR8loMRnLDRWmFLpg9J
+0wD8ofzkpf9/rdcw0Md3f76BB1UwUCAU9Vc4CqgxUQ==
+-----END CERTIFICATE-----
+
+# Issuer: CN=Hongkong Post Root CA 3 O=Hongkong Post
+# Subject: CN=Hongkong Post Root CA 3 O=Hongkong Post
+# Label: "Hongkong Post Root CA 3"
+# Serial: 46170865288971385588281144162979347873371282084
+# MD5 Fingerprint: 11:fc:9f:bd:73:30:02:8a:fd:3f:f3:58:b9:cb:20:f0
+# SHA1 Fingerprint: 58:a2:d0:ec:20:52:81:5b:c1:f3:f8:64:02:24:4e:c2:8e:02:4b:02
+# SHA256 Fingerprint: 5a:2f:c0:3f:0c:83:b0:90:bb:fa:40:60:4b:09:88:44:6c:76:36:18:3d:f9:84:6e:17:10:1a:44:7f:b8:ef:d6
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
+# Subject: CN=Entrust Root Certification Authority - G4 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2015 Entrust, Inc. - for authorized use only
+# Label: "Entrust Root Certification Authority - G4"
+# Serial: 289383649854506086828220374796556676440
+# MD5 Fingerprint: 89:53:f1:83:23:b7:7c:8e:05:f1:8c:71:38:4e:1f:88
+# SHA1 Fingerprint: 14:88:4e:86:26:37:b0:26:af:59:62:5c:40:77:ec:35:29:ba:96:01
+# SHA256 Fingerprint: db:35:17:d1:f6:73:2a:2d:5a:b9:7c:53:3e:c7:07:79:ee:32:70:a6:2f:b4:ac:42:38:37:24:60:e6:f0:1e:88
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
+# Subject: CN=Microsoft ECC Root Certificate Authority 2017 O=Microsoft Corporation
+# Label: "Microsoft ECC Root Certificate Authority 2017"
+# Serial: 136839042543790627607696632466672567020
+# MD5 Fingerprint: dd:a1:03:e6:4a:93:10:d1:bf:f0:19:42:cb:fe:ed:67
+# SHA1 Fingerprint: 99:9a:64:c3:7f:f4:7d:9f:ab:95:f1:47:69:89:14:60:ee:c4:c3:c5
+# SHA256 Fingerprint: 35:8d:f3:9d:76:4a:f9:e1:b7:66:e9:c9:72:df:35:2e:e1:5c:fa:c2:27:af:6a:d1:d7:0e:8e:4a:6e:dc:ba:02
+-----BEGIN CERTIFICATE-----
+MIICWTCCAd+gAwIBAgIQZvI9r4fei7FK6gxXMQHC7DAKBggqhkjOPQQDAzBlMQsw
+CQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYD
+VQQDEy1NaWNyb3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIw
+MTcwHhcNMTkxMjE4MjMwNjQ1WhcNNDIwNzE4MjMxNjA0WjBlMQswCQYDVQQGEwJV
+UzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1NaWNy
+b3NvZnQgRUNDIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwdjAQBgcq
+hkjOPQIBBgUrgQQAIgNiAATUvD0CQnVBEyPNgASGAlEvaqiBYgtlzPbKnR5vSmZR
+ogPZnZH6thaxjG7efM3beaYvzrvOcS/lpaso7GMEZpn4+vKTEAXhgShC48Zo9OYb
+hGBKia/teQ87zvH2RPUBeMCjVDBSMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBTIy5lycFIM+Oa+sgRXKSrPQhDtNTAQBgkrBgEEAYI3
+FQEEAwIBADAKBggqhkjOPQQDAwNoADBlAjBY8k3qDPlfXu5gKcs68tvWMoQZP3zV
+L8KxzJOuULsJMsbG7X7JNpQS5GiFBqIb0C8CMQCZ6Ra0DvpWSNSkMBaReNtUjGUB
+iudQZsIxtzm6uBoiB078a1QWIP8rtedMDE2mT3M=
+-----END CERTIFICATE-----
+
+# Issuer: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
+# Subject: CN=Microsoft RSA Root Certificate Authority 2017 O=Microsoft Corporation
+# Label: "Microsoft RSA Root Certificate Authority 2017"
+# Serial: 40975477897264996090493496164228220339
+# MD5 Fingerprint: 10:ff:00:ff:cf:c9:f8:c7:7a:c0:ee:35:8e:c9:0f:47
+# SHA1 Fingerprint: 73:a5:e6:4a:3b:ff:83:16:ff:0e:dc:cc:61:8a:90:6e:4e:ae:4d:74
+# SHA256 Fingerprint: c7:41:f7:0f:4b:2a:8d:88:bf:2e:71:c1:41:22:ef:53:ef:10:eb:a0:cf:a5:e6:4c:fa:20:f4:18:85:30:73:e0
+-----BEGIN CERTIFICATE-----
+MIIFqDCCA5CgAwIBAgIQHtOXCV/YtLNHcB6qvn9FszANBgkqhkiG9w0BAQwFADBl
+MQswCQYDVQQGEwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYw
+NAYDVQQDEy1NaWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5
+IDIwMTcwHhcNMTkxMjE4MjI1MTIyWhcNNDIwNzE4MjMwMDIzWjBlMQswCQYDVQQG
+EwJVUzEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTYwNAYDVQQDEy1N
+aWNyb3NvZnQgUlNBIFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTcwggIi
+MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKW76UM4wplZEWCpW9R2LBifOZ
+Nt9GkMml7Xhqb0eRaPgnZ1AzHaGm++DlQ6OEAlcBXZxIQIJTELy/xztokLaCLeX0
+ZdDMbRnMlfl7rEqUrQ7eS0MdhweSE5CAg2Q1OQT85elss7YfUJQ4ZVBcF0a5toW1
+HLUX6NZFndiyJrDKxHBKrmCk3bPZ7Pw71VdyvD/IybLeS2v4I2wDwAW9lcfNcztm
+gGTjGqwu+UcF8ga2m3P1eDNbx6H7JyqhtJqRjJHTOoI+dkC0zVJhUXAoP8XFWvLJ
+jEm7FFtNyP9nTUwSlq31/niol4fX/V4ggNyhSyL71Imtus5Hl0dVe49FyGcohJUc
+aDDv70ngNXtk55iwlNpNhTs+VcQor1fznhPbRiefHqJeRIOkpcrVE7NLP8TjwuaG
+YaRSMLl6IE9vDzhTyzMMEyuP1pq9KsgtsRx9S1HKR9FIJ3Jdh+vVReZIZZ2vUpC6
+W6IYZVcSn2i51BVrlMRpIpj0M+Dt+VGOQVDJNE92kKz8OMHY4Xu54+OU4UZpyw4K
+UGsTuqwPN1q3ErWQgR5WrlcihtnJ0tHXUeOrO8ZV/R4O03QK0dqq6mm4lyiPSMQH
+FJDOvTKVTUssKZqwJz58oHhEmrARdlns87/I6KJClTUFLkqqNfs+avNJVgyeY+Q
+W5g5xAgGwax/Dj0ApQIDAQABo1QwUjAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/
+BAUwAwEB/zAdBgNVHQ4EFgQUCctZf4aycI8awznjwNnpv7tNsiMwEAYJKwYBBAGC
+NxUBBAMCAQAwDQYJKoZIhvcNAQEMBQADggIBAKyvPl3CEZaJjqPnktaXFbgToqZC
+LgLNFgVZJ8og6Lq46BrsTaiXVq5lQ7GPAJtSzVXNUzltYkyLDVt8LkS/gxCP81OC
+gMNPOsduET/m4xaRhPtthH80dK2Jp86519efhGSSvpWhrQlTM93uCupKUY5vVau6
+tZRGrox/2KJQJWVggEbbMwSubLWYdFQl3JPk+ONVFT24bcMKpBLBaYVu32TxU5nh
+SnUgnZUP5NbcA/FZGOhHibJXWpS2qdgXKxdJ5XbLwVaZOjex/2kskZGT4d9Mozd2
+TaGf+G0eHdP67Pv0RR0Tbc/3WeUiJ3IrhvNXuzDtJE3cfVa7o7P4NHmJweDyAmH3
+pvwPuxwXC65B2Xy9J6P9LjrRk5Sxcx0ki69bIImtt2dmefU6xqaWM/5TkshGsRGR
+xpl/j8nWZjEgQRCHLQzWwa80mMpkg/sTV9HB8Dx6jKXB/ZUhoHHBk2dxEuqPiApp
+GWSZI1b7rCoucL5mxAyE7+WL85MB+GqQk2dLsmijtWKP6T+MejteD+eMuMZ87zf9
+dOLITzNy4ZQ5bb0Sr74MTnB8G2+NszKTc0QWbej09+CVgI+WXTik9KveCjCHk9hN
+AHFiRSdLOkKEW39lt2c0Ui2cFmuqqNh7o0JMcccMyj6D5KbvtwEwXlGjefVwaaZB
+RA+GsCyRxj3qrg+E
+-----END CERTIFICATE-----
+
+# Issuer: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
+# Subject: CN=e-Szigno Root CA 2017 O=Microsec Ltd.
+# Label: "e-Szigno Root CA 2017"
+# Serial: 411379200276854331539784714
+# MD5 Fingerprint: de:1f:f6:9e:84:ae:a7:b4:21:ce:1e:58:7d:d1:84:98
+# SHA1 Fingerprint: 89:d4:83:03:4f:9e:9a:48:80:5f:72:37:d4:a9:a6:ef:cb:7c:1f:d1
+# SHA256 Fingerprint: be:b0:0b:30:83:9b:9b:c3:2c:32:e4:44:79:05:95:06:41:f2:64:21:b1:5e:d0:89:19:8b:51:8a:e2:ea:1b:99
+-----BEGIN CERTIFICATE-----
+MIICQDCCAeWgAwIBAgIMAVRI7yH9l1kN9QQKMAoGCCqGSM49BAMCMHExCzAJBgNV
+BAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRk
+LjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25vIFJv
+b3QgQ0EgMjAxNzAeFw0xNzA4MjIxMjA3MDZaFw00MjA4MjIxMjA3MDZaMHExCzAJ
+BgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMg
+THRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxHjAcBgNVBAMMFWUtU3ppZ25v
+IFJvb3QgQ0EgMjAxNzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJbcPYrYsHtv
+xie+RJCxs1YVe45DJH0ahFnuY2iyxl6H0BVIHqiQrb1TotreOpCmYF9oMrWGQd+H
+Wyx7xf58etqjYzBhMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G
+A1UdDgQWBBSHERUI0arBeAyxr87GyZDvvzAEwDAfBgNVHSMEGDAWgBSHERUI0arB
+eAyxr87GyZDvvzAEwDAKBggqhkjOPQQDAgNJADBGAiEAtVfd14pVCzbhhkT61Nlo
+jbjcI4qKDdQvfepz7L9NbKgCIQDLpbQS+ue16M9+k/zzNY9vTlp8tLxOsvxyqltZ
+efcMQ==
+-----END CERTIFICATE-----
+
+# Issuer: O=CERTSIGN SA OU=certSIGN ROOT CA G2
+# Subject: O=CERTSIGN SA OU=certSIGN ROOT CA G2
+# Label: "certSIGN Root CA G2"
+# Serial: 313609486401300475190
+# MD5 Fingerprint: 8c:f1:75:8a:c6:19:cf:94:b7:f7:65:20:87:c3:97:c7
+# SHA1 Fingerprint: 26:f9:93:b4:ed:3d:28:27:b0:b9:4b:a7:e9:15:1d:a3:8d:92:e5:32
+# SHA256 Fingerprint: 65:7c:fe:2f:a7:3f:aa:38:46:25:71:f3:32:a2:36:3a:46:fc:e7:02:09:51:71:07:02:cd:fb:b6:ee:da:33:05
+-----BEGIN CERTIFICATE-----
+MIIFRzCCAy+gAwIBAgIJEQA0tk7GNi02MA0GCSqGSIb3DQEBCwUAMEExCzAJBgNV
+BAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJR04g
+Uk9PVCBDQSBHMjAeFw0xNzAyMDYwOTI3MzVaFw00MjAyMDYwOTI3MzVaMEExCzAJ
+BgNVBAYTAlJPMRQwEgYDVQQKEwtDRVJUU0lHTiBTQTEcMBoGA1UECxMTY2VydFNJ
+R04gUk9PVCBDQSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMDF
+dRmRfUR0dIf+DjuW3NgBFszuY5HnC2/OOwppGnzC46+CjobXXo9X69MhWf05N0Iw
+vlDqtg+piNguLWkh59E3GE59kdUWX2tbAMI5Qw02hVK5U2UPHULlj88F0+7cDBrZ
+uIt4ImfkabBoxTzkbFpG583H+u/E7Eu9aqSs/cwoUe+StCmrqzWaTOTECMYmzPhp
+n+Sc8CnTXPnGFiWeI8MgwT0PPzhAsP6CRDiqWhqKa2NYOLQV07YRaXseVO6MGiKs
+cpc/I1mbySKEwQdPzH/iV8oScLumZfNpdWO9lfsbl83kqK/20U6o2YpxJM02PbyW
+xPFsqa7lzw1uKA2wDrXKUXt4FMMgL3/7FFXhEZn91QqhngLjYl/rNUssuHLoPj1P
+rCy7Lobio3aP5ZMqz6WryFyNSwb/EkaseMsUBzXgqd+L6a8VTxaJW732jcZZroiF
+DsGJ6x9nxUWO/203Nit4ZoORUSs9/1F3dmKh7Gc+PoGD4FapUB8fepmrY7+EF3fx
+DTvf95xhszWYijqy7DwaNz9+j5LP2RIUZNoQAhVB/0/E6xyjyfqZ90bp4RjZsbgy
+LcsUDFDYg2WD7rlcz8sFWkz6GZdr1l0T08JcVLwyc6B49fFtHsufpaafItzRUZ6C
+eWRgKRM+o/1Pcmqr4tTluCRVLERLiohEnMqE0yo7AgMBAAGjQjBAMA8GA1UdEwEB
+/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSCIS1mxteg4BXrzkwJ
+d8RgnlRuAzANBgkqhkiG9w0BAQsFAAOCAgEAYN4auOfyYILVAzOBywaK8SJJ6ejq
+kX/GM15oGQOGO0MBzwdw5AgeZYWR5hEit/UCI46uuR59H35s5r0l1ZUa8gWmr4UC
+b6741jH/JclKyMeKqdmfS0mbEVeZkkMR3rYzpMzXjWR91M08KCy0mpbqTfXERMQl
+qiCA2ClV9+BB/AYm/7k29UMUA2Z44RGx2iBfRgB4ACGlHgAoYXhvqAEBj500mv/0
+OJD7uNGzcgbJceaBxXntC6Z58hMLnPddDnskk7RI24Zf3lCGeOdA5jGokHZwYa+c
+NywRtYK3qq4kNFtyDGkNzVmf9nGvnAvRCjj5BiKDUyUM/FHE5r7iOZULJK2v0ZXk
+ltd0ZGtxTgI8qoXzIKNDOXZbbFD+mpwUHmUUihW9o4JFWklWatKcsWMy5WHgUyIO
+pwpJ6st+H6jiYoD2EEVSmAYY3qXNL3+q1Ok+CHLsIwMCPKaq2LxndD0UF/tUSxfj
+03k9bWtJySgOLnRQvwzZRjoQhsmnP+mg7H/rpXdYaXHmgwo38oZJar55CJD2AhZk
+PuXaTH4MNMn5X7azKFGnpyuqSfqNZSlO42sTp5SjLVFteAxEy9/eCG/Oo2Sr05WE
+1LlSVHJ7liXMvGnjSG4N0MedJ5qq+BOS3R7fY581qRY27Iy4g/Q9iY/NtBde17MX
+QRBdJ3NghVdJIgc=
+-----END CERTIFICATE-----
@@ -1,37 +1,60 @@
-#!/usr/bin/env python
 # -*- coding: utf-8 -*-

 """
 certifi.py
 ~~~~~~~~~~

-This module returns the installation location of cacert.pem.
+This module returns the installation location of cacert.pem or its contents.
 """
 import os
-import warnings
+
+try:
+    from importlib.resources import path as get_path, read_text
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where():
+        # This is slightly terrible, but we want to delay extracting the file
+        # in cases where we're inside of a zipimport situation until someone
+        # actually calls where(), but we don't want to re-extract the file
+        # on every call of where(), so we'll do it once then store it in a
+        # global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you to
+            # manage the cleanup of this file, so it doesn't actually return a
+            # path, it returns a context manager that will give you the path
+            # when you enter it and will do any cleanup when you leave it. In
+            # the common case of not needing a temporary file, it will just
+            # return the file system location and the __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = get_path("certifi", "cacert.pem")
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+
+        return _CACERT_PATH


-class DeprecatedBundleWarning(DeprecationWarning):
-    """
-    The weak security bundle is being deprecated. Please bother your service
-    provider to get them to stop using cross-signed roots.
-    """
+except ImportError:
+    # This fallback will work for Python versions prior to 3.7 that lack the
+    # importlib.resources module but relies on the existing `where` function
+    # so won't address issues with environments like PyOxidizer that don't set
+    # __file__ on modules.
+    def read_text(_module, _path, encoding="ascii"):
+        with open(where(), "r", encoding=encoding) as data:
+            return data.read()
+
+    # If we don't have importlib.resources, then we will just do the old logic
+    # of assuming we're on the filesystem and munge the path directly.
+    def where():
+        f = os.path.dirname(__file__)
+
+        return os.path.join(f, "cacert.pem")


-def where():
-    f = os.path.dirname(__file__)
-
-    return os.path.join(f, 'cacert.pem')
-
-
-def old_where():
-    warnings.warn(
-        "The weak security bundle has been removed. certifi.old_where() is now an alias "
-        "of certifi.where(). Please update your code to use certifi.where() instead. "
-        "certifi.old_where() will be removed in 2018.",
-        DeprecatedBundleWarning
-    )
-    return where()
-
-if __name__ == '__main__':
-    print(where())
+def contents():
+    return read_text("certifi", "cacert.pem", encoding="ascii")
@@ -0,0 +1,311 @@
+import logging
+import re
+import sys
+import ssl
+
+from copy import deepcopy
+from time import sleep
+from collections import OrderedDict
+
+from requests.sessions import Session
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.util.ssl_ import create_urllib3_context
+
+from .interpreters import JavaScriptInterpreter
+from .user_agent import User_Agent
+
+try:
+    from requests_toolbelt.utils import dump
+except ImportError:
+    pass
+
+try:
+    import brotli
+except ImportError:
+    pass
+
+try:
+    from urlparse import urlparse
+    from urlparse import urlunparse
+except ImportError:
+    from urllib.parse import urlparse
+    from urllib.parse import urlunparse
+
+##########################################################################################################################################################
+
+__version__ = '1.1.9'
+
+BUG_REPORT = 'Cloudflare may have changed their technique, or there may be a bug in the script.'
+
+##########################################################################################################################################################
+
+
+class CipherSuiteAdapter(HTTPAdapter):
+
+    def __init__(self, cipherSuite=None, **kwargs):
+        self.cipherSuite = cipherSuite
+
+        if hasattr(ssl, 'PROTOCOL_TLS'):
+            self.ssl_context = create_urllib3_context(
+                ssl_version=getattr(ssl, 'PROTOCOL_TLSv1_3', ssl.PROTOCOL_TLSv1_2),
+                ciphers=self.cipherSuite
+            )
+        else:
+            self.ssl_context = create_urllib3_context(ssl_version=ssl.PROTOCOL_TLSv1)
+
+        super(CipherSuiteAdapter, self).__init__(**kwargs)
+
+    ##########################################################################################################################################################
+
+    def init_poolmanager(self, *args, **kwargs):
+        kwargs['ssl_context'] = self.ssl_context
+        return super(CipherSuiteAdapter, self).init_poolmanager(*args, **kwargs)
+
+    ##########################################################################################################################################################
+
+    def proxy_manager_for(self, *args, **kwargs):
+        kwargs['ssl_context'] = self.ssl_context
+        return super(CipherSuiteAdapter, self).proxy_manager_for(*args, **kwargs)
+
+##########################################################################################################################################################
+
+
+class CloudScraper(Session):
+    def __init__(self, *args, **kwargs):
+        self.debug = kwargs.pop('debug', False)
+        self.delay = kwargs.pop('delay', None)
+        self.interpreter = kwargs.pop('interpreter', 'js2py')
+        self.allow_brotli = kwargs.pop('allow_brotli', True if 'brotli' in sys.modules.keys() else False)
+        self.cipherSuite = None
+
+        super(CloudScraper, self).__init__(*args, **kwargs)
+
+        if 'requests' in self.headers['User-Agent']:
+            # Set a random User-Agent if no custom User-Agent has been set
+            self.headers = User_Agent(allow_brotli=self.allow_brotli).headers
+
+        self.mount('https://', CipherSuiteAdapter(self.loadCipherSuite()))
+
+    ##########################################################################################################################################################
+
+    @staticmethod
+    def debugRequest(req):
+        try:
+            print(dump.dump_all(req).decode('utf-8'))
+        except:  # noqa
+            pass
+
+    ##########################################################################################################################################################
+
+    def loadCipherSuite(self):
+        if self.cipherSuite:
+            return self.cipherSuite
+
+        self.cipherSuite = ''
+
+        if hasattr(ssl, 'PROTOCOL_TLS'):
+            ciphers = [
+                'ECDHE-ECDSA-AES128-GCM-SHA256', 'ECDHE-RSA-AES128-GCM-SHA256', 'ECDHE-ECDSA-AES256-GCM-SHA384',
+                'ECDHE-RSA-AES256-GCM-SHA384', 'ECDHE-ECDSA-CHACHA20-POLY1305-SHA256', 'ECDHE-RSA-CHACHA20-POLY1305-SHA256',
+                'ECDHE-RSA-AES128-CBC-SHA', 'ECDHE-RSA-AES256-CBC-SHA', 'RSA-AES128-GCM-SHA256', 'RSA-AES256-GCM-SHA384',
+                'ECDHE-RSA-AES128-GCM-SHA256', 'RSA-AES256-SHA', '3DES-EDE-CBC'
+            ]
+
+            if hasattr(ssl, 'PROTOCOL_TLSv1_3'):
+                ciphers.insert(0, ['GREASE_3A', 'GREASE_6A', 'AES128-GCM-SHA256', 'AES256-GCM-SHA256', 'AES256-GCM-SHA384', 'CHACHA20-POLY1305-SHA256'])
+
+            ctx = ssl.SSLContext(getattr(ssl, 'PROTOCOL_TLSv1_3', ssl.PROTOCOL_TLSv1_2))
+
+            for cipher in ciphers:
+                try:
+                    ctx.set_ciphers(cipher)
+                    self.cipherSuite = '{}:{}'.format(self.cipherSuite, cipher).rstrip(':')
+                except ssl.SSLError:
+                    pass
+
+        return self.cipherSuite
+
+    ##########################################################################################################################################################
+
+    def request(self, method, url, *args, **kwargs):
+        ourSuper = super(CloudScraper, self)
+        resp = ourSuper.request(method, url, *args, **kwargs)
+
+        if resp.headers.get('Content-Encoding') == 'br':
+            if self.allow_brotli and resp._content:
+                resp._content = brotli.decompress(resp.content)
+            else:
+                logging.warning('Brotli content detected, But option is disabled, we will not continue.')
+                return resp
+
+        # Debug request
+        if self.debug:
+            self.debugRequest(resp)
+
+        # Check if Cloudflare anti-bot is on
+        if self.isChallengeRequest(resp):
+            if resp.request.method != 'GET':
+                # Work around if the initial request is not a GET,
+                # Supersede with a GET then re-request the original METHOD.
+                self.request('GET', resp.url)
+                resp = ourSuper.request(method, url, *args, **kwargs)
+            else:
+                # Solve Challenge
+                resp = self.sendChallengeResponse(resp, **kwargs)
+
+        return resp
+
+    ##########################################################################################################################################################
+
+    @staticmethod
+    def isChallengeRequest(resp):
+        if resp.headers.get('Server', '').startswith('cloudflare'):
+            if b'why_captcha' in resp.content or b'/cdn-cgi/l/chk_captcha' in resp.content:
+                raise ValueError('Captcha')
+
+            return (
+                resp.status_code in [429, 503]
+                and all(s in resp.content for s in [b'jschl_vc', b'jschl_answer'])
+            )
+
+        return False
+
+    ##########################################################################################################################################################
+
+    def sendChallengeResponse(self, resp, **original_kwargs):
+        body = resp.text
+
+        # Cloudflare requires a delay before solving the challenge
+        if not self.delay:
+            try:
+                delay = float(re.search(r'submit\(\);\r?\n\s*},\s*([0-9]+)', body).group(1)) / float(1000)
+                if isinstance(delay, (int, float)):
+                    self.delay = delay
+            except:  # noqa
+                pass
+
+        sleep(self.delay)
+
+        parsed_url = urlparse(resp.url)
+        domain = parsed_url.netloc
+        submit_url = '{}://{}/cdn-cgi/l/chk_jschl'.format(parsed_url.scheme, domain)
+
+        cloudflare_kwargs = deepcopy(original_kwargs)
+
+        try:
+            params = OrderedDict()
+
+            s = re.search(r'name="s"\svalue="(?P<s_value>[^"]+)', body)
+            if s:
+                params['s'] = s.group('s_value')
+
+            params.update(
+                [
+                    ('jschl_vc', re.search(r'name="jschl_vc" value="(\w+)"', body).group(1)),
+                    ('pass', re.search(r'name="pass" value="(.+?)"', body).group(1))
+                ]
+            )
+
+            params = cloudflare_kwargs.setdefault('params', params)
+
+        except Exception as e:
+            raise ValueError('Unable to parse Cloudflare anti-bots page: {} {}'.format(e.message, BUG_REPORT))
+
+        # Solve the Javascript challenge
+        params['jschl_answer'] = JavaScriptInterpreter.dynamicImport(self.interpreter).solveChallenge(body, domain)
+
+        # Requests transforms any request into a GET after a redirect,
+        # so the redirect has to be handled manually here to allow for
+        # performing other types of requests even as the first request.
+
+        cloudflare_kwargs['allow_redirects'] = False
+
+        redirect = self.request(resp.request.method, submit_url, **cloudflare_kwargs)
+        redirect_location = urlparse(redirect.headers['Location'])
+        if not redirect_location.netloc:
+            redirect_url = urlunparse(
+                (
+                    parsed_url.scheme,
+                    domain,
+                    redirect_location.path,
+                    redirect_location.params,
+                    redirect_location.query,
+                    redirect_location.fragment
+                )
+            )
+            return self.request(resp.request.method, redirect_url, **original_kwargs)
+
+        return self.request(resp.request.method, redirect.headers['Location'], **original_kwargs)
+
+    ##########################################################################################################################################################
+
+    @classmethod
+    def create_scraper(cls, sess=None, **kwargs):
+        """
+        Convenience function for creating a ready-to-go CloudScraper object.
+        """
+        scraper = cls(**kwargs)
+
+        if sess:
+            attrs = ['auth', 'cert', 'cookies', 'headers', 'hooks', 'params', 'proxies', 'data']
+            for attr in attrs:
+                val = getattr(sess, attr, None)
+                if val:
+                    setattr(scraper, attr, val)
+
+        return scraper
+
+    ##########################################################################################################################################################
+
+    # Functions for integrating cloudscraper with other applications and scripts
+    @classmethod
+    def get_tokens(cls, url, **kwargs):
+        scraper = cls.create_scraper(
+            debug=kwargs.pop('debug', False),
+            delay=kwargs.pop('delay', None),
+            interpreter=kwargs.pop('interpreter', 'js2py'),
+            allow_brotli=kwargs.pop('allow_brotli', True),
+        )
+
+        try:
+            resp = scraper.get(url, **kwargs)
+            resp.raise_for_status()
+        except Exception:
+            logging.error('"{}" returned an error. Could not collect tokens.'.format(url))
+            raise
+
+        domain = urlparse(resp.url).netloc
+        # noinspection PyUnusedLocal
+        cookie_domain = None
+
+        for d in scraper.cookies.list_domains():
+            if d.startswith('.') and d in ('.{}'.format(domain)):
+                cookie_domain = d
+                break
+        else:
+            raise ValueError('Unable to find Cloudflare cookies. Does the site actually have Cloudflare IUAM ("I\'m Under Attack Mode") enabled?')
+
+        return (
+            {
+                '__cfduid': scraper.cookies.get('__cfduid', '', domain=cookie_domain),
+                'cf_clearance': scraper.cookies.get('cf_clearance', '', domain=cookie_domain)
+            },
+            scraper.headers['User-Agent']
+        )
+
+    ##########################################################################################################################################################
+
+    @classmethod
+    def get_cookie_string(cls, url, **kwargs):
+        """
+        Convenience function for building a Cookie HTTP header value.
+        """
+        tokens, user_agent = cls.get_tokens(url, **kwargs)
+        return '; '.join('='.join(pair) for pair in tokens.items()), user_agent
+
+
+##########################################################################################################################################################
+
+create_scraper = CloudScraper.create_scraper
+get_tokens = CloudScraper.get_tokens
+get_cookie_string = CloudScraper.get_cookie_string
@@ -0,0 +1,89 @@
+import re
+import sys
+import logging
+import abc
+
+if sys.version_info >= (3, 4):
+    ABC = abc.ABC  # noqa
+else:
+    ABC = abc.ABCMeta('ABC', (), {})
+
+##########################################################################################################################################################
+
+BUG_REPORT = 'Cloudflare may have changed their technique, or there may be a bug in the script.'
+
+##########################################################################################################################################################
+
+interpreters = {}
+
+
+class JavaScriptInterpreter(ABC):
+    @abc.abstractmethod
+    def __init__(self, name):
+        interpreters[name] = self
+
+    @classmethod
+    def dynamicImport(cls, name):
+        if name not in interpreters:
+            try:
+                __import__('{}.{}'.format(cls.__module__, name))
+                if not isinstance(interpreters.get(name), JavaScriptInterpreter):
+                    raise ImportError('The interpreter was not initialized.')
+            except ImportError:
+                logging.error('Unable to load {} interpreter'.format(name))
+                raise
+
+        return interpreters[name]
+
+    @abc.abstractmethod
+    def eval(self, jsEnv, js):
+        pass
+
+    def solveChallenge(self, body, domain):
+        try:
+            js = re.search(
+                r'setTimeout\(function\(\){\s+(var s,t,o,p,b,r,e,a,k,i,n,g,f.+?\r?\n[\s\S]+?a\.value =.+?)\r?\n',
+                body
+            ).group(1)
+        except Exception:
+            raise ValueError('Unable to identify Cloudflare IUAM Javascript on website. {}'.format(BUG_REPORT))
+
+        js = re.sub(r'\s{2,}', ' ', js, flags=re.MULTILINE | re.DOTALL).replace('\'; 121\'', '')
+        js += '\na.value;'
+
+        jsEnv = '''
+            String.prototype.italics=function(str) {{return "<i>" + this + "</i>";}};
+            var document = {{
+                createElement: function () {{
+                    return {{ firstChild: {{ href: "https://{domain}/" }} }}
+                }},
+                getElementById: function () {{
+                    return {{"innerHTML": "{innerHTML}"}};
+                }}
+            }};
+        '''
+
+        try:
+            innerHTML = re.search(
+                r'<div(?: [^<>]*)? id="([^<>]*?)">([^<>]*?)</div>',
+                body,
+                re.MULTILINE | re.DOTALL
+            )
+            innerHTML = innerHTML.group(2) if innerHTML else ''
+
+        except:  # noqa
+            logging.error('Error extracting Cloudflare IUAM Javascript. {}'.format(BUG_REPORT))
+            raise
+
+        try:
+            result = self.eval(
+                re.sub(r'\s{2,}', ' ', jsEnv.format(domain=domain, innerHTML=innerHTML), flags=re.MULTILINE | re.DOTALL),
+                js
+            )
+
+            float(result)
+        except Exception:
+            logging.error('Error executing Cloudflare IUAM Javascript. {}'.format(BUG_REPORT))
+            raise
+
+        return result
@@ -0,0 +1,32 @@
+from __future__ import absolute_import
+
+import js2py
+import logging
+import base64
+
+from . import JavaScriptInterpreter
+
+from .jsunfuck import jsunfuck
+
+
+class ChallengeInterpreter(JavaScriptInterpreter):
+
+    def __init__(self):
+        super(ChallengeInterpreter, self).__init__('js2py')
+
+    def eval(self, jsEnv, js):
+        if js2py.eval_js('(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]') == '1':
+            logging.warning('WARNING - Please upgrade your js2py https://github.com/PiotrDabkowski/Js2Py, applying work around for the meantime.')
+            js = jsunfuck(js)
+
+        def atob(s):
+            return base64.b64decode('{}'.format(s)).decode('utf-8')
+
+        js2py.disable_pyimport()
+        context = js2py.EvalJs({'atob': atob})
+        result = context.eval('{}{}'.format(jsEnv, js))
+
+        return result
+
+
+ChallengeInterpreter()
@@ -0,0 +1,97 @@
+MAPPING = {
+    'a': '(false+"")[1]',
+    'b': '([]["entries"]()+"")[2]',
+    'c': '([]["fill"]+"")[3]',
+    'd': '(undefined+"")[2]',
+    'e': '(true+"")[3]',
+    'f': '(false+"")[0]',
+    'g': '(false+[0]+String)[20]',
+    'h': '(+(101))["to"+String["name"]](21)[1]',
+    'i': '([false]+undefined)[10]',
+    'j': '([]["entries"]()+"")[3]',
+    'k': '(+(20))["to"+String["name"]](21)',
+    'l': '(false+"")[2]',
+    'm': '(Number+"")[11]',
+    'n': '(undefined+"")[1]',
+    'o': '(true+[]["fill"])[10]',
+    'p': '(+(211))["to"+String["name"]](31)[1]',
+    'q': '(+(212))["to"+String["name"]](31)[1]',
+    'r': '(true+"")[1]',
+    's': '(false+"")[3]',
+    't': '(true+"")[0]',
+    'u': '(undefined+"")[0]',
+    'v': '(+(31))["to"+String["name"]](32)',
+    'w': '(+(32))["to"+String["name"]](33)',
+    'x': '(+(101))["to"+String["name"]](34)[1]',
+    'y': '(NaN+[Infinity])[10]',
+    'z': '(+(35))["to"+String["name"]](36)',
+    'A': '(+[]+Array)[10]',
+    'B': '(+[]+Boolean)[10]',
+    'C': 'Function("return escape")()(("")["italics"]())[2]',
+    'D': 'Function("return escape")()([]["fill"])["slice"]("-1")',
+    'E': '(RegExp+"")[12]',
+    'F': '(+[]+Function)[10]',
+    'G': '(false+Function("return Date")()())[30]',
+    'I': '(Infinity+"")[0]',
+    'M': '(true+Function("return Date")()())[30]',
+    'N': '(NaN+"")[0]',
+    'O': '(NaN+Function("return{}")())[11]',
+    'R': '(+[]+RegExp)[10]',
+    'S': '(+[]+String)[10]',
+    'T': '(NaN+Function("return Date")()())[30]',
+    'U': '(NaN+Function("return{}")()["to"+String["name"]]["call"]())[11]',
+    ' ': '(NaN+[]["fill"])[11]',
+    '"': '("")["fontcolor"]()[12]',
+    '%': 'Function("return escape")()([]["fill"])[21]',
+    '&': '("")["link"](0+")[10]',
+    '(': '(undefined+[]["fill"])[22]',
+    ')': '([0]+false+[]["fill"])[20]',
+    '+': '(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[2]',
+    ',': '([]["slice"]["call"](false+"")+"")[1]',
+    '-': '(+(.+[0000000001])+"")[2]',
+    '.': '(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]',
+    '/': '(false+[0])["italics"]()[10]',
+    ':': '(RegExp()+"")[3]',
+    ';': '("")["link"](")[14]',
+    '<': '("")["italics"]()[0]',
+    '=': '("")["fontcolor"]()[11]',
+    '>': '("")["italics"]()[2]',
+    '?': '(RegExp()+"")[2]',
+    '[': '([]["entries"]()+"")[0]',
+    ']': '([]["entries"]()+"")[22]',
+    '{': '(true+[]["fill"])[20]',
+    '}': '([]["fill"]+"")["slice"]("-1")'
+}
+
+SIMPLE = {
+    'false': '![]',
+    'true': '!![]',
+    'undefined': '[][[]]',
+    'NaN': '+[![]]',
+    'Infinity': '+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]]+[+[]])'  # +"1e1000"
+}
+
+CONSTRUCTORS = {
+    'Array': '[]',
+    'Number': '(+[])',
+    'String': '([]+[])',
+    'Boolean': '(![])',
+    'Function': '[]["fill"]',
+    'RegExp': 'Function("return/"+false+"/")()'
+}
+
+
+def jsunfuck(jsfuckString):
+    for key in sorted(MAPPING, key=lambda k: len(MAPPING[k]), reverse=True):
+        if MAPPING.get(key) in jsfuckString:
+            jsfuckString = jsfuckString.replace(MAPPING.get(key), '"{}"'.format(key))
+
+    for key in sorted(SIMPLE, key=lambda k: len(SIMPLE[k]), reverse=True):
+        if SIMPLE.get(key) in jsfuckString:
+            jsfuckString = jsfuckString.replace(SIMPLE.get(key), '{}'.format(key))
+
+    # for key in sorted(CONSTRUCTORS, key=lambda k: len(CONSTRUCTORS[k]), reverse=True):
+    #    if CONSTRUCTORS.get(key) in jsfuckString:
+    #        jsfuckString = jsfuckString.replace(CONSTRUCTORS.get(key), '{}'.format(key))
+
+    return jsfuckString
@@ -0,0 +1,46 @@
+import base64
+import logging
+import subprocess
+
+from . import JavaScriptInterpreter
+
+##########################################################################################################################################################
+
+BUG_REPORT = 'Cloudflare may have changed their technique, or there may be a bug in the script.'
+
+##########################################################################################################################################################
+
+
+class ChallengeInterpreter(JavaScriptInterpreter):
+
+    def __init__(self):
+        super(ChallengeInterpreter, self).__init__('nodejs')
+
+    def eval(self, jsEnv, js):
+        try:
+            js = 'var atob = function(str) {return Buffer.from(str, "base64").toString("binary");};' \
+                 'var challenge = atob("%s");' \
+                 'var context = {atob: atob};' \
+                 'var options = {filename: "iuam-challenge.js", timeout: 4000};' \
+                 'var answer = require("vm").runInNewContext(challenge, context, options);' \
+                 'process.stdout.write(String(answer));' \
+                 % base64.b64encode('{}{}'.format(jsEnv, js).encode('UTF-8')).decode('ascii')
+
+            return subprocess.check_output(['node', '-e', js])
+
+        except OSError as e:
+            if e.errno == 2:
+                raise EnvironmentError(
+                    'Missing Node.js runtime. Node is required and must be in the PATH (check with `node -v`). Your Node binary may be called `nodejs` rather than `node`, '
+                    'in which case you may need to run `apt-get install nodejs-legacy` on some Debian-based systems. (Please read the cloudscraper'
+                    ' README\'s Dependencies section: https://github.com/VeNoMouS/cloudscraper#dependencies.'
+                )
+            raise
+        except Exception:
+            logging.error('Error executing Cloudflare IUAM Javascript. %s' % BUG_REPORT)
+            raise
+
+        pass
+
+
+ChallengeInterpreter()
@@ -0,0 +1,40 @@
+import os
+import json
+import random
+import logging
+
+from collections import OrderedDict
+
+##########################################################################################################################################################
+
+
+class User_Agent():
+
+    ##########################################################################################################################################################
+
+    def __init__(self, *args, **kwargs):
+        self.headers = None
+        self.loadUserAgent(*args, **kwargs)
+
+    ##########################################################################################################################################################
+
+    def loadUserAgent(self, *args, **kwargs):
+        browser = kwargs.pop('browser', 'chrome')
+
+        user_agents = json.load(
+            open(os.path.join(os.path.dirname(__file__), 'browsers.json'), 'r'),
+            object_pairs_hook=OrderedDict
+        )
+
+        if not user_agents.get(browser):
+            logging.error('Sorry "{}" browser User-Agent was not found.'.format(browser))
+            raise
+
+        user_agent = random.choice(user_agents.get(browser))
+
+        self.headers = user_agent.get('headers')
+        self.headers['User-Agent'] = random.choice(user_agent.get('User-Agent'))
+
+        if not kwargs.get('allow_brotli', False):
+            if 'br' in self.headers['Accept-Encoding']:
+                self.headers['Accept-Encoding'] = ','.join([encoding for encoding in self.headers['Accept-Encoding'].split(',') if encoding.strip() != 'br']).strip()
@@ -0,0 +1,336 @@
+{
+  "chrome": [
+    {
+      "User-Agent": [
+        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.82 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.101 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.101 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.101 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.75 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.110 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.110 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.110 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.110 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.81 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.113 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.89 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.89 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.89 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.89 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.89 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.89 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.98 Safari/537.36"
+      ],
+      "headers": {
+        "Connection": "keep-alive",
+        "Upgrade-Insecure-Requests": "1",
+        "User-Agent": null,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.8",
+        "Accept-Encoding": "gzip, deflate, , br"
+      }
+    },
+    {
+      "User-Agent": [
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.86 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.78 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36"
+      ],
+      "headers": {
+        "Connection": "keep-alive",
+        "Upgrade-Insecure-Requests": "1",
+        "User-Agent": null,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.8",
+        "Accept-Encoding": "gzip, deflate, br"
+      }
+    },
+    {
+      "User-Agent": [
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.62 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.119 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.146 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.117 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.117 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.117 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.117 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.117 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.117 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.117 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.117 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.117 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.80 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.75 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.92 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.92 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.109 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.170 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.81 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.81 Safari/537.36"
+      ],
+      "headers": {
+        "Connection": "keep-alive",
+        "Upgrade-Insecure-Requests": "1",
+        "User-Agent": null,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9",
+        "Accept-Encoding": "gzip, deflate, br"
+      }
+    },
+    {
+      "User-Agent": [
+        "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36"
+      ],
+      "headers": {
+        "Connection": "keep-alive",
+        "User-Agent": null,
+        "Upgrade-Insecure-Requests": "1",
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9",
+        "Accept-Encoding": "gzip, deflate, br"
+      }
+    },
+    {
+      "User-Agent": [
+        "Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.40 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.40 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.28 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.28 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.28 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.28 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.28 Safari/537.36"
+      ],
+      "headers": {
+        "Connection": "keep-alive",
+        "Upgrade-Insecure-Requests": "1",
+        "User-Agent": null,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3",
+        "Accept-Language": "en-US,en;q=0.9",
+        "Accept-Encoding": "gzip, deflate, br"
+      }
+    },
+    {
+      "User-Agent": [
+        "Mozilla/5.0 (Linux; Android 8.1.0; SM-N960F Build/M1AJQ) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 8.0.0; SM-G965F Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 8.0.0; Pixel 2 Build/OPD1.170816.010) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 8.0.0; Pixel Build/OPR6.170623.012) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 7.1.1; SM-A530F Build/NMF26X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 7.1; Pixel Build/NDE63H) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 7.0; SM-G955F Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 7.0; SM-G950F Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 7.0; SM-T825 Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 6.0.1; SM-G930F Build/MMB29K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 6.0; Nexus 6 Build/MRA58K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 6.0; XT1092 Build/MPE24.49-18) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 6.0.1; SM-N910C Build/MMB29K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 5.0.2; SM-G920F Build/LRX22G) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 5.0; Nexus 6 Build/LRX21O) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 9; Pixel 3 XL Build/PD1A.180720.030) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 9; Pixel 3 Build/PD1A.180720.030) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 9; Pixel 2 Build/PPR1.180610.009) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 4.4; Nexus 5 Build/KRT16M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 4.4.2; SM-T530 Build/KOT49H) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 4.4.4; SM-N910C Build/KTU84P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 5.1.1; Nexus 9 Build/LMY47X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 7.1.1; SM-N950F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.90 Mobile Safari/537.36"
+      ],
+      "headers": {
+        "Connection": "keep-alive",
+        "Upgrade-Insecure-Requests": "1",
+        "User-Agent": null,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Encoding": "gzip, deflate, br",
+        "Accept-Language": "en-US,en;q=0.9"
+      }
+    },
+    {
+      "User-Agent": [
+        "Mozilla/5.0 (Linux; Android 8.1.0; SM-T835 Build/M1AJQ) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 8.0.0; SM-G960F Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36",
+        "Mozilla/5.0 (Linux; Android 5.0; XT1092 Build/LXE22.46-19) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.85 Mobile Safari/537.36"
+      ],
+      "headers": {
+        "Connection": "keep-alive",
+        "Upgrade-Insecure-Requests": "1",
+        "User-Agent": null,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Encoding": "gzip, deflate, br",
+        "Accept-Language": "en-GB,en-US;q=0.9,en;q=0.8"
+      }
+    }
+  ]
+}
@@ -0,0 +1,516 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+
+"""Death by Captcha HTTP and socket API clients.
+
+There are two types of Death by Captcha (DBC hereinafter) API: HTTP and
+socket ones.  Both offer the same functionalily, with the socket API
+sporting faster responses and using way less connections.
+
+To access the socket API, use SocketClient class; for the HTTP API, use
+HttpClient class.  Both are thread-safe.  SocketClient keeps a persistent
+connection opened and serializes all API requests sent through it, thus
+it is advised to keep a pool of them if you're script is heavily
+multithreaded.
+
+Both SocketClient and HttpClient give you the following methods:
+
+get_user()
+    Returns your DBC account details as a dict with the following keys:
+
+    "user": your account numeric ID; if login fails, it will be the only
+        item with the value of 0;
+    "rate": your CAPTCHA rate, i.e. how much you will be charged for one
+        solved CAPTCHA in US cents;
+    "balance": your DBC account balance in US cents;
+    "is_banned": flag indicating whether your account is suspended or not.
+
+get_balance()
+    Returns your DBC account balance in US cents.
+
+get_captcha(cid)
+    Returns an uploaded CAPTCHA details as a dict with the following keys:
+
+    "captcha": the CAPTCHA numeric ID; if no such CAPTCHAs found, it will
+        be the only item with the value of 0;
+    "text": the CAPTCHA text, if solved, otherwise None;
+    "is_correct": flag indicating whether the CAPTCHA was solved correctly
+        (DBC can detect that in rare cases).
+
+    The only argument `cid` is the CAPTCHA numeric ID.
+
+get_text(cid)
+    Returns an uploaded CAPTCHA text (None if not solved).  The only argument
+    `cid` is the CAPTCHA numeric ID.
+
+report(cid)
+    Reports an incorrectly solved CAPTCHA.  The only argument `cid` is the
+    CAPTCHA numeric ID.  Returns True on success, False otherwise.
+
+upload(captcha)
+    Uploads a CAPTCHA.  The only argument `captcha` can be either file-like
+    object (any object with `read` method defined, actually, so StringIO
+    will do), or CAPTCHA image file name.  On successul upload you'll get
+    the CAPTCHA details dict (see get_captcha() method).
+
+    NOTE: AT THIS POINT THE UPLOADED CAPTCHA IS NOT SOLVED YET!  You have
+    to poll for its status periodically using get_captcha() or get_text()
+    method until the CAPTCHA is solved and you get the text.
+
+decode(captcha, timeout=DEFAULT_TIMEOUT)
+    A convenient method that uploads a CAPTCHA and polls for its status
+    periodically, but no longer than `timeout` (defaults to 60 seconds).
+    If solved, you'll get the CAPTCHA details dict (see get_captcha()
+    method for details).  See upload() method for details on `captcha`
+    argument.
+
+Visit http://www.deathbycaptcha.com/user/api for updates.
+
+"""
+
+import base64
+import binascii
+import errno
+import imghdr
+import random
+import os
+import select
+import socket
+import sys
+import threading
+import time
+import urllib
+import urllib2
+try:
+    from json import read as json_decode, write as json_encode
+except ImportError:
+    try:
+        from json import loads as json_decode, dumps as json_encode
+    except ImportError:
+        from simplejson import loads as json_decode, dumps as json_encode
+
+
+# API version and unique software ID
+API_VERSION = 'DBC/Python v4.6'
+
+# Default CAPTCHA timeout and decode() polling interval
+DEFAULT_TIMEOUT = 60
+DEFAULT_TOKEN_TIMEOUT = 120
+POLLS_INTERVAL = [1, 1, 2, 3, 2, 2, 3, 2, 2]
+DFLT_POLL_INTERVAL = 3
+
+# Base HTTP API url
+HTTP_BASE_URL = 'http://api.dbcapi.me/api'
+
+# Preferred HTTP API server's response content type, do not change
+HTTP_RESPONSE_TYPE = 'application/json'
+
+# Socket API server's host & ports range
+SOCKET_HOST = 'api.dbcapi.me'
+SOCKET_PORTS = range(8123, 8131)
+
+
+def _load_image(captcha):
+    if hasattr(captcha, 'read'):
+        img = captcha.read()
+    elif type(captcha) == bytearray:
+        img = captcha
+    else:
+        img = ''
+        try:
+            captcha_file = open(captcha, 'rb')
+        except Exception:
+            raise
+        else:
+            img = captcha_file.read()
+            captcha_file.close()
+    if not len(img):
+        raise ValueError('CAPTCHA image is empty')
+    elif imghdr.what(None, img) is None:
+        raise TypeError('Unknown CAPTCHA image type')
+    else:
+        return img
+
+
+class AccessDeniedException(Exception):
+    pass
+
+
+class Client(object):
+
+    """Death by Captcha API Client."""
+
+    def __init__(self, username, password):
+        self.is_verbose = False
+        self.userpwd = {'username': username, 'password': password}
+
+    def _log(self, cmd, msg=''):
+        if self.is_verbose:
+            print '%d %s %s' % (time.time(), cmd, msg.rstrip())
+        return self
+
+    def close(self):
+        pass
+
+    def connect(self):
+        pass
+
+    def get_user(self):
+        """Fetch user details -- ID, balance, rate and banned status."""
+        raise NotImplementedError()
+
+    def get_balance(self):
+        """Fetch user balance (in US cents)."""
+        return self.get_user().get('balance')
+
+    def get_captcha(self, cid):
+        """Fetch a CAPTCHA details -- ID, text and correctness flag."""
+        raise NotImplementedError()
+
+    def get_text(self, cid):
+        """Fetch a CAPTCHA text."""
+        return self.get_captcha(cid).get('text') or None
+
+    def report(self, cid):
+        """Report a CAPTCHA as incorrectly solved."""
+        raise NotImplementedError()
+
+    def upload(self, captcha):
+        """Upload a CAPTCHA.
+
+        Accepts file names and file-like objects.  Returns CAPTCHA details
+        dict on success.
+
+        """
+        raise NotImplementedError()
+
+    def decode(self, captcha=None, timeout=None, **kwargs):
+        """
+        Try to solve a CAPTCHA.
+
+        See Client.upload() for arguments details.
+
+        Uploads a CAPTCHA, polls for its status periodically with arbitrary
+        timeout (in seconds), returns CAPTCHA details if (correctly) solved.
+        """
+        if not timeout:
+            if not captcha:
+                timeout = DEFAULT_TOKEN_TIMEOUT
+            else:
+                timeout = DEFAULT_TIMEOUT
+
+        deadline = time.time() + (max(0, timeout) or DEFAULT_TIMEOUT)
+        uploaded_captcha = self.upload(captcha, **kwargs)
+        if uploaded_captcha:
+            intvl_idx = 0  # POLL_INTERVAL index
+            while deadline > time.time() and not uploaded_captcha.get('text'):
+                intvl, intvl_idx = self._get_poll_interval(intvl_idx)
+                time.sleep(intvl)
+                pulled = self.get_captcha(uploaded_captcha['captcha'])
+                if pulled['captcha'] == uploaded_captcha['captcha']:
+                    uploaded_captcha = pulled
+            if uploaded_captcha.get('text') and \
+                    uploaded_captcha.get('is_correct'):
+                return uploaded_captcha
+
+    def _get_poll_interval(self, idx):
+        """Returns poll interval and next index depending on index provided"""
+
+        if len(POLLS_INTERVAL) > idx:
+            intvl = POLLS_INTERVAL[idx]
+        else:
+            intvl = DFLT_POLL_INTERVAL
+        idx += 1
+
+        return intvl, idx
+
+
+class HttpClient(Client):
+
+    """Death by Captcha HTTP API client."""
+
+    def __init__(self, *args):
+        Client.__init__(self, *args)
+        self.opener = urllib2.build_opener(urllib2.HTTPRedirectHandler())
+
+    def _call(self, cmd, payload=None, headers=None):
+        if headers is None:
+            headers = {}
+        headers['Accept'] = HTTP_RESPONSE_TYPE
+        headers['User-Agent'] = API_VERSION
+        if hasattr(payload, 'items'):
+            payload = urllib.urlencode(payload)
+            self._log('SEND', '%s %d %s' % (cmd, len(payload), payload))
+        else:
+            self._log('SEND', '%s' % cmd)
+        if payload is not None:
+            headers['Content-Length'] = len(payload)
+        try:
+            response = self.opener.open(urllib2.Request(
+                HTTP_BASE_URL + '/' + cmd.strip('/'),
+                data=payload,
+                headers=headers
+            )).read()
+        except urllib2.HTTPError, err:
+            if 403 == err.code:
+                raise AccessDeniedException('Access denied, please check'
+                                            ' your credentials and/or balance')
+            elif 400 == err.code or 413 == err.code:
+                raise ValueError("CAPTCHA was rejected by the service, check"
+                                 " if it's a valid image")
+            elif 503 == err.code:
+                raise OverflowError("CAPTCHA was rejected due to service"
+                                    " overload, try again later")
+            else:
+                raise err
+        else:
+            self._log('RECV', '%d %s' % (len(response), response))
+            try:
+                return json_decode(response)
+            except Exception:
+                raise RuntimeError('Invalid API response')
+        return {}
+
+    def get_user(self):
+        return self._call('user', self.userpwd.copy()) or {'user': 0}
+
+    def get_captcha(self, cid):
+        return self._call('captcha/%d' % cid) or {'captcha': 0}
+
+    def report(self, cid):
+        return not self._call('captcha/%d/report' % cid,
+                              self.userpwd.copy()).get('is_correct')
+
+    def upload(self, captcha=None, **kwargs):
+        boundary = binascii.hexlify(os.urandom(16))
+        banner = kwargs.get('banner', '')
+        if banner:
+            kwargs['banner'] = 'base64:' + base64.b64encode(_load_image(banner))
+        body = '\r\n'.join(('\r\n'.join((
+            '--%s' % boundary,
+            'Content-Disposition: form-data; name="%s"' % k,
+            'Content-Type: text/plain',
+            'Content-Length: %d' % len(str(v)),
+            '',
+            str(v)
+        ))) for k, v in self.userpwd.items())
+
+        body += '\r\n'.join(('\r\n'.join((
+            '--%s' % boundary,
+            'Content-Disposition: form-data; name="%s"' % k,
+            'Content-Type: text/plain',
+            'Content-Length: %d' % len(str(v)),
+            '',
+            str(v)
+        ))) for k, v in kwargs.items())
+
+        if captcha:
+            img = _load_image(captcha)
+            body += '\r\n'.join((
+                '',
+                '--%s' % boundary,
+                'Content-Disposition: form-data; name="captchafile"; '
+                    'filename="captcha"',
+                'Content-Type: application/octet-stream',
+                'Content-Length: %d' % len(img),
+                '',
+                img,
+                '--%s--' % boundary,
+                ''
+            ))
+
+        response = self._call('captcha', body, {
+            'Content-Type': 'multipart/form-data; boundary="%s"' % boundary
+        }) or {}
+        if response.get('captcha'):
+            return response
+
+
+class SocketClient(Client):
+
+    """Death by Captcha socket API client."""
+
+    TERMINATOR = '\r\n'
+
+    def __init__(self, *args):
+        Client.__init__(self, *args)
+        self.socket_lock = threading.Lock()
+        self.socket = None
+
+    def close(self):
+        if self.socket:
+            self._log('CLOSE')
+            try:
+                self.socket.shutdown(socket.SHUT_RDWR)
+            except socket.error:
+                pass
+            finally:
+                self.socket.close()
+                self.socket = None
+
+    def connect(self):
+        if not self.socket:
+            self._log('CONN')
+            host = (socket.gethostbyname(SOCKET_HOST),
+                    random.choice(SOCKET_PORTS))
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.socket.settimeout(0)
+            try:
+                self.socket.connect(host)
+            except socket.error, err:
+                if (err.args[0] not in
+                        (errno.EAGAIN, errno.EWOULDBLOCK, errno.EINPROGRESS)):
+                    self.close()
+                    raise err
+        return self.socket
+
+    def __del__(self):
+        self.close()
+
+    def _sendrecv(self, sock, buf):
+        self._log('SEND', buf)
+        fds = [sock]
+        buf += self.TERMINATOR
+        response = ''
+        intvl_idx = 0
+        while True:
+            intvl, intvl_idx = self._get_poll_interval(intvl_idx)
+            rds, wrs, exs = select.select((not buf and fds) or [],
+                                          (buf and fds) or [],
+                                          fds,
+                                          intvl)
+            if exs:
+                raise IOError('select() failed')
+            try:
+                if wrs:
+                    while buf:
+                        buf = buf[wrs[0].send(buf):]
+                elif rds:
+                    while True:
+                        s = rds[0].recv(256)
+                        if not s:
+                            raise IOError('recv(): connection lost')
+                        else:
+                            response += s
+            except socket.error, err:
+                if (err.args[0] not in
+                        (errno.EAGAIN, errno.EWOULDBLOCK, errno.EINPROGRESS)):
+                    raise err
+            if response.endswith(self.TERMINATOR):
+                self._log('RECV', response)
+                return response.rstrip(self.TERMINATOR)
+        raise IOError('send/recv timed out')
+
+    def _call(self, cmd, data=None):
+        if data is None:
+            data = {}
+        data['cmd'] = cmd
+        data['version'] = API_VERSION
+        request = json_encode(data)
+
+        response = None
+        for _ in range(2):
+            if not self.socket and cmd != 'login':
+                self._call('login', self.userpwd.copy())
+            self.socket_lock.acquire()
+            try:
+                sock = self.connect()
+                response = self._sendrecv(sock, request)
+            except IOError, err:
+                sys.stderr.write(str(err) + "\n")
+                self.close()
+            except socket.error, err:
+                sys.stderr.write(str(err) + "\n")
+                self.close()
+                raise IOError('Connection refused')
+            else:
+                break
+            finally:
+                self.socket_lock.release()
+
+        if response is None:
+            raise IOError('Connection lost or timed out during API request')
+
+        try:
+            response = json_decode(response)
+        except Exception:
+            raise RuntimeError('Invalid API response')
+
+        if not response.get('error'):
+            return response
+
+        error = response['error']
+        if error in ('not-logged-in', 'invalid-credentials'):
+            raise AccessDeniedException('Access denied, check your credentials')
+        elif 'banned' == error:
+            raise AccessDeniedException('Access denied, account is suspended')
+        elif 'insufficient-funds' == error:
+            raise AccessDeniedException(
+                'CAPTCHA was rejected due to low balance')
+        elif 'invalid-captcha' == error:
+            raise ValueError('CAPTCHA is not a valid image')
+        elif 'service-overload' == error:
+            raise OverflowError(
+                'CAPTCHA was rejected due to service overload, try again later')
+        else:
+            self.socket_lock.acquire()
+            self.close()
+            self.socket_lock.release()
+            raise RuntimeError('API server error occured: %s' % error)
+
+    def get_user(self):
+        return self._call('user') or {'user': 0}
+
+    def get_captcha(self, cid):
+        return self._call('captcha', {'captcha': cid}) or {'captcha': 0}
+
+    def upload(self, captcha=None, **kwargs):
+        data = {}
+        if captcha:
+            data['captcha'] = base64.b64encode(_load_image(captcha))
+        if kwargs:
+            banner = kwargs.get('banner', '')
+            if banner:
+                kwargs['banner'] = base64.b64encode(_load_image(banner))
+            data.update(kwargs)
+        response = self._call('upload', data)
+        if response.get('captcha'):
+            uploaded_captcha = dict(
+                (k, response.get(k))
+                for k in ('captcha', 'text', 'is_correct')
+            )
+            if not uploaded_captcha['text']:
+                uploaded_captcha['text'] = None
+            return uploaded_captcha
+
+    def report(self, cid):
+        return not self._call('report', {'captcha': cid}).get('is_correct')
+
+
+if '__main__' == __name__:
+    # Put your DBC username & password here:
+    # client = HttpClient(sys.argv[1], sys.argv[2])
+    client = SocketClient(sys.argv[1], sys.argv[2])
+    client.is_verbose = True
+
+    print 'Your balance is %s US cents' % client.get_balance()
+
+    for fn in sys.argv[3:]:
+        try:
+            # Put your CAPTCHA image file name or file-like object, and optional
+            # solving timeout (in seconds) here:
+            captcha = client.decode(fn, DEFAULT_TIMEOUT)
+        except Exception, e:
+            sys.stderr.write('Failed uploading CAPTCHA: %s\n' % (e, ))
+            captcha = None
+
+        if captcha:
+            print 'CAPTCHA %d solved: %s' % \
+                  (captcha['captcha'], captcha['text'])
+
+            # Report as incorrectly solved if needed.  Make sure the CAPTCHA was
+            # in fact incorrectly solved!
+            # try:
+            #    client.report(captcha['captcha'])
+            # except Exception, e:
+            #    sys.stderr.write('Failed reporting CAPTCHA: %s\n' % (e, ))
@@ -5,6 +5,7 @@ import pickle
 import shutil
 import tempfile
 import traceback
+import hashlib

 import appdirs

@@ -89,7 +90,7 @@ class FileCache(MutableMapping):
    """

    def __init__(self, appname, flag='c', mode=0o666, keyencoding='utf-8',
-                 serialize=True, app_cache_dir=None):
+                 serialize=True, app_cache_dir=None, key_file_ext=".txt"):
        """Initialize a :class:`FileCache` object."""
        if not isinstance(flag, str):
            raise TypeError("flag must be str not '{}'".format(type(flag)))
@@ -130,6 +131,7 @@ class FileCache(MutableMapping):
        self._mode = mode
        self._keyencoding = keyencoding
        self._serialize = serialize
+        self.key_file_ext = key_file_ext

    def _parse_appname(self, appname):
        """Splits an appname into the appname and subcache components."""
@@ -188,6 +190,11 @@ class FileCache(MutableMapping):
            except:
                logger.error("Couldn't write content from %r to cache file: %r: %s", ekey, filename,
                             traceback.format_exc())
+            try:
+                self.__write_to_file(filename + self.key_file_ext, ekey)
+            except:
+                logger.error("Couldn't write content from %r to cache file: %r: %s", ekey, filename,
+                             traceback.format_exc())
        self._buffer.clear()
        self._sync = False

@@ -196,8 +203,7 @@ class FileCache(MutableMapping):
        raise ValueError("invalid operation on closed cache")

    def _encode_key(self, key):
-        """Encode key using *hex_codec* for constructing a cache filename.
-
+        """
        Keys are implicitly converted to :class:`bytes` if passed as
        :class:`str`.

@@ -206,16 +212,15 @@ class FileCache(MutableMapping):
            key = key.encode(self._keyencoding)
        elif not isinstance(key, bytes):
            raise TypeError("key must be bytes or str")
-        return codecs.encode(key, 'hex_codec').decode(self._keyencoding)
+        return key.decode(self._keyencoding)

    def _decode_key(self, key):
-        """Decode key using hex_codec to retrieve the original key.
-
+        """
        Keys are returned as :class:`str` if serialization is enabled.
        Keys are returned as :class:`bytes` if serialization is disabled.

        """
-        bkey = codecs.decode(key.encode(self._keyencoding), 'hex_codec')
+        bkey = key.encode(self._keyencoding)
        return bkey.decode(self._keyencoding) if self._serialize else bkey

    def _dumps(self, value):
@@ -226,18 +231,24 @@ class FileCache(MutableMapping):

    def _key_to_filename(self, key):
        """Convert an encoded key to an absolute cache filename."""
-        return os.path.join(self.cache_dir, key)
+        if isinstance(key, unicode):
+            key = key.encode(self._keyencoding)
+        return os.path.join(self.cache_dir, hashlib.md5(key).hexdigest())

    def _filename_to_key(self, absfilename):
        """Convert an absolute cache filename to a key name."""
-        return os.path.split(absfilename)[1]
+        hkey_hdr_fn = absfilename + self.key_file_ext
+        if os.path.isfile(hkey_hdr_fn):
+            with open(hkey_hdr_fn, 'rb') as f:
+                key = f.read()
+                return key.decode(self._keyencoding) if self._serialize else key

    def _all_filenames(self, scandir_generic=True):
        """Return a list of absolute cache filenames"""
        _scandir = _scandir_generic if scandir_generic else scandir
        try:
            for entry in _scandir(self.cache_dir):
-                if entry.is_file(follow_symlinks=False):
+                if entry.is_file(follow_symlinks=False) and not entry.name.endswith(self.key_file_ext):
                    yield os.path.join(self.cache_dir, entry.name)
        except (FileNotFoundError, OSError):
            raise StopIteration
@@ -250,14 +261,17 @@ class FileCache(MutableMapping):
        else:
            return set(file_keys + list(self._buffer))

-    def _write_to_file(self, filename, bytesvalue):
+    def __write_to_file(self, filename, value):
        """Write bytesvalue to filename."""
        fh, tmp = tempfile.mkstemp()
        with os.fdopen(fh, self._flag) as f:
-            f.write(self._dumps(bytesvalue))
+            f.write(value)
        rename(tmp, filename)
        os.chmod(filename, self._mode)

+    def _write_to_file(self, filename, bytesvalue):
+        self.__write_to_file(filename, self._dumps(bytesvalue))
+
    def _read_from_file(self, filename):
        """Read data from filename."""
        try:
@@ -274,6 +288,7 @@ class FileCache(MutableMapping):
        else:
            filename = self._key_to_filename(ekey)
            self._write_to_file(filename, value)
+            self.__write_to_file(filename + self.key_file_ext, ekey)

    def __getitem__(self, key):
        ekey = self._encode_key(key)
@@ -283,8 +298,9 @@ class FileCache(MutableMapping):
            except KeyError:
                pass
        filename = self._key_to_filename(ekey)
-        if filename not in self._all_filenames():
+        if not os.path.isfile(filename):
            raise KeyError(key)
+
        return self._read_from_file(filename)

    def __delitem__(self, key):
@@ -301,6 +317,11 @@ class FileCache(MutableMapping):
        except (IOError, OSError):
            pass

+        try:
+            os.remove(filename + self.key_file_ext)
+        except (IOError, OSError):
+            pass
+
    def __iter__(self):
        for key in self._all_keys():
            yield self._decode_key(key)
@@ -310,4 +331,10 @@ class FileCache(MutableMapping):

    def __contains__(self, key):
        ekey = self._encode_key(key)
-        return ekey in self._all_keys()
+        if not self._sync:
+            try:
+                return ekey in self._buffer
+            except KeyError:
+                pass
+        filename = self._key_to_filename(ekey)
+        return os.path.isfile(filename)
@@ -0,0 +1,75 @@
+# The MIT License
+#
+# Copyright 2014, 2015 Piotr Dabkowski
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the 'Software'),
+# to deal in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so, subject
+# to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or
+# substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+# LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+#  OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
+""" This module allows you to translate and execute Javascript in pure python.
+    Basically its implementation of ECMAScript 5.1 in pure python.
+
+    Use eval_js method to execute javascript code and get resulting python object (builtin if possible).
+
+    EXAMPLE:
+    >>> import js2py
+    >>> add = js2py.eval_js('function add(a, b) {return a + b}')
+    >>> add(1, 2) + 3
+    6
+    >>> add('1', 2, 3)
+    u'12'
+    >>> add.constructor
+    function Function() { [python code] }
+
+
+    Or use EvalJs to execute many javascript code fragments under same context - you would be able to get any
+    variable from the context!
+
+    >>> js = js2py.EvalJs()
+    >>> js.execute('var a = 10; function f(x) {return x*x};')
+    >>> js.f(9)
+    81
+    >>> js.a
+    10
+
+    Also you can use its console method to play with interactive javascript console.
+
+
+    Use parse_js to parse (syntax tree is just like in esprima.js) and translate_js to trasnlate JavaScript.
+
+    Finally, you can use pyimport statement from inside JS code to import and use python libraries.
+
+    >>> js2py.eval_js('pyimport urllib; urllib.urlopen("https://www.google.com")')
+
+    NOTE: This module is still not fully finished:
+
+          Date and JSON builtin objects are not implemented
+          Array prototype is not fully finished (will be soon)
+
+    Other than that everything should work fine.
+
+"""
+
+__author__ = 'Piotr Dabkowski'
+__all__ = [
+    'EvalJs', 'translate_js', 'import_js', 'eval_js', 'parse_js',
+    'translate_file', 'run_file', 'disable_pyimport', 'eval_js6',
+    'translate_js6', 'PyJsException', 'get_file_contents',
+    'write_file_contents', 'require'
+]
+
+from .base import PyJsException
+from .evaljs import *
+from .translators import parse as parse_js
+from .node_import import require
@@ -0,0 +1 @@
+__author__ = 'Piotr Dabkowski'
@@ -0,0 +1,48 @@
+from ..base import *
+
+
+@Js
+def Array():
+    if len(arguments) == 0 or len(arguments) > 1:
+        return arguments.to_list()
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js([])
+        temp.put('length', a)
+        return temp
+    return [a]
+
+
+Array.create = Array
+Array.own['length']['value'] = Js(1)
+
+
+@Js
+def isArray(arg):
+    return arg.Class == 'Array'
+
+
+Array.define_own_property('isArray', {
+    'value': isArray,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
+
+Array.define_own_property(
+    'prototype', {
+        'value': ArrayPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+ArrayPrototype.define_own_property('constructor', {
+    'value': Array,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
@@ -0,0 +1,41 @@
+# this is based on jsarray.py
+
+# todo check everything :)
+
+from ..base import *
+try:
+    import numpy
+except:
+    pass
+
+
+@Js
+def ArrayBuffer():
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js(bytearray([0] * length))
+        return temp
+    return Js(bytearray([0]))
+
+
+ArrayBuffer.create = ArrayBuffer
+ArrayBuffer.own['length']['value'] = Js(None)
+
+ArrayBuffer.define_own_property(
+    'prototype', {
+        'value': ArrayBufferPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+ArrayBufferPrototype.define_own_property(
+    'constructor', {
+        'value': ArrayBuffer,
+        'enumerable': False,
+        'writable': False,
+        'configurable': True
+    })
@@ -0,0 +1,16 @@
+from ..base import *
+
+BooleanPrototype.define_own_property('constructor', {
+    'value': Boolean,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
+
+Boolean.define_own_property(
+    'prototype', {
+        'value': BooleanPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
@@ -0,0 +1,405 @@
+from ..base import *
+from .time_helpers import *
+
+TZ_OFFSET = (time.altzone // 3600)
+ABS_OFFSET = abs(TZ_OFFSET)
+TZ_NAME = time.tzname[1]
+ISO_FORMAT = '%s-%s-%sT%s:%s:%s.%sZ'
+
+
+@Js
+def Date(year, month, date, hours, minutes, seconds, ms):
+    return now().to_string()
+
+
+Date.Class = 'Date'
+
+
+def now():
+    return PyJsDate(int(time.time() * 1000), prototype=DatePrototype)
+
+
+@Js
+def UTC(year, month, date, hours, minutes, seconds, ms):  # todo complete this
+    args = arguments
+    y = args[0].to_number()
+    m = args[1].to_number()
+    l = len(args)
+    dt = args[2].to_number() if l > 2 else Js(1)
+    h = args[3].to_number() if l > 3 else Js(0)
+    mi = args[4].to_number() if l > 4 else Js(0)
+    sec = args[5].to_number() if l > 5 else Js(0)
+    mili = args[6].to_number() if l > 6 else Js(0)
+    if not y.is_nan() and 0 <= y.value <= 99:
+        y = y + Js(1900)
+    t = TimeClip(MakeDate(MakeDay(y, m, dt), MakeTime(h, mi, sec, mili)))
+    return PyJsDate(t, prototype=DatePrototype)
+
+
+@Js
+def parse(string):
+    return PyJsDate(
+        TimeClip(parse_date(string.to_string().value)),
+        prototype=DatePrototype)
+
+
+Date.define_own_property('now', {
+    'value': Js(now),
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
+
+Date.define_own_property('parse', {
+    'value': parse,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
+
+Date.define_own_property('UTC', {
+    'value': UTC,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
+
+
+class PyJsDate(PyJs):
+    Class = 'Date'
+    extensible = True
+
+    def __init__(self, value, prototype=None):
+        self.value = value
+        self.own = {}
+        self.prototype = prototype
+
+    # todo fix this problematic datetime part
+    def to_local_dt(self):
+        return datetime.datetime.utcfromtimestamp(
+            UTCToLocal(self.value) // 1000)
+
+    def to_utc_dt(self):
+        return datetime.datetime.utcfromtimestamp(self.value // 1000)
+
+    def local_strftime(self, pattern):
+        if self.value is NaN:
+            return 'Invalid Date'
+        try:
+            dt = self.to_local_dt()
+        except:
+            raise MakeError(
+                'TypeError',
+                'unsupported date range. Will fix in future versions')
+        try:
+            return dt.strftime(pattern)
+        except:
+            raise MakeError(
+                'TypeError',
+                'Could not generate date string from this date (limitations of python.datetime)'
+            )
+
+    def utc_strftime(self, pattern):
+        if self.value is NaN:
+            return 'Invalid Date'
+        try:
+            dt = self.to_utc_dt()
+        except:
+            raise MakeError(
+                'TypeError',
+                'unsupported date range. Will fix in future versions')
+        try:
+            return dt.strftime(pattern)
+        except:
+            raise MakeError(
+                'TypeError',
+                'Could not generate date string from this date (limitations of python.datetime)'
+            )
+
+
+def parse_date(py_string):  # todo support all date string formats
+    try:
+        try:
+            dt = datetime.datetime.strptime(py_string, "%Y-%m-%dT%H:%M:%S.%fZ")
+        except:
+            dt = datetime.datetime.strptime(py_string, "%Y-%m-%dT%H:%M:%SZ")
+        return MakeDate(
+            MakeDay(Js(dt.year), Js(dt.month - 1), Js(dt.day)),
+            MakeTime(
+                Js(dt.hour), Js(dt.minute), Js(dt.second),
+                Js(dt.microsecond // 1000)))
+    except:
+        raise MakeError(
+            'TypeError',
+            'Could not parse date %s - unsupported date format. Currently only supported format is RFC3339 utc. Sorry!'
+            % py_string)
+
+
+def date_constructor(*args):
+    if len(args) >= 2:
+        return date_constructor2(*args)
+    elif len(args) == 1:
+        return date_constructor1(args[0])
+    else:
+        return date_constructor0()
+
+
+def date_constructor0():
+    return now()
+
+
+def date_constructor1(value):
+    v = value.to_primitive()
+    if v._type() == 'String':
+        v = parse_date(v.value)
+    else:
+        v = v.to_int()
+    return PyJsDate(TimeClip(v), prototype=DatePrototype)
+
+
+def date_constructor2(*args):
+    y = args[0].to_number()
+    m = args[1].to_number()
+    l = len(args)
+    dt = args[2].to_number() if l > 2 else Js(1)
+    h = args[3].to_number() if l > 3 else Js(0)
+    mi = args[4].to_number() if l > 4 else Js(0)
+    sec = args[5].to_number() if l > 5 else Js(0)
+    mili = args[6].to_number() if l > 6 else Js(0)
+    if not y.is_nan() and 0 <= y.value <= 99:
+        y = y + Js(1900)
+    t = TimeClip(
+        LocalToUTC(MakeDate(MakeDay(y, m, dt), MakeTime(h, mi, sec, mili))))
+    return PyJsDate(t, prototype=DatePrototype)
+
+
+Date.create = date_constructor
+
+DatePrototype = PyJsDate(float('nan'), prototype=ObjectPrototype)
+
+
+def check_date(obj):
+    if obj.Class != 'Date':
+        raise MakeError('TypeError', 'this is not a Date object')
+
+
+class DateProto:
+    def toString():
+        check_date(this)
+        if this.value is NaN:
+            return 'Invalid Date'
+        offset = (UTCToLocal(this.value) - this.value) // msPerHour
+        return this.local_strftime(
+            '%a %b %d %Y %H:%M:%S GMT') + '%s00 (%s)' % (pad(
+                offset, 2, True), GetTimeZoneName(this.value))
+
+    def toDateString():
+        check_date(this)
+        return this.local_strftime('%d %B %Y')
+
+    def toTimeString():
+        check_date(this)
+        return this.local_strftime('%H:%M:%S')
+
+    def toLocaleString():
+        check_date(this)
+        return this.local_strftime('%d %B %Y %H:%M:%S')
+
+    def toLocaleDateString():
+        check_date(this)
+        return this.local_strftime('%d %B %Y')
+
+    def toLocaleTimeString():
+        check_date(this)
+        return this.local_strftime('%H:%M:%S')
+
+    def valueOf():
+        check_date(this)
+        return this.value
+
+    def getTime():
+        check_date(this)
+        return this.value
+
+    def getFullYear():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return YearFromTime(UTCToLocal(this.value))
+
+    def getUTCFullYear():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return YearFromTime(this.value)
+
+    def getMonth():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return MonthFromTime(UTCToLocal(this.value))
+
+    def getDate():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return DateFromTime(UTCToLocal(this.value))
+
+    def getUTCMonth():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return MonthFromTime(this.value)
+
+    def getUTCDate():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return DateFromTime(this.value)
+
+    def getDay():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return WeekDay(UTCToLocal(this.value))
+
+    def getUTCDay():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return WeekDay(this.value)
+
+    def getHours():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return HourFromTime(UTCToLocal(this.value))
+
+    def getUTCHours():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return HourFromTime(this.value)
+
+    def getMinutes():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return MinFromTime(UTCToLocal(this.value))
+
+    def getUTCMinutes():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return MinFromTime(this.value)
+
+    def getSeconds():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return SecFromTime(UTCToLocal(this.value))
+
+    def getUTCSeconds():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return SecFromTime(this.value)
+
+    def getMilliseconds():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return msFromTime(UTCToLocal(this.value))
+
+    def getUTCMilliseconds():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return msFromTime(this.value)
+
+    def getTimezoneOffset():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return (this.value - UTCToLocal(this.value)) // 60000
+
+    def setTime(time):
+        check_date(this)
+        this.value = TimeClip(time.to_number().to_int())
+        return this.value
+
+    def setMilliseconds(ms):
+        check_date(this)
+        t = UTCToLocal(this.value)
+        tim = MakeTime(
+            HourFromTime(t), MinFromTime(t), SecFromTime(t), ms.to_int())
+        u = TimeClip(LocalToUTC(MakeDate(Day(t), tim)))
+        this.value = u
+        return u
+
+    def setUTCMilliseconds(ms):
+        check_date(this)
+        t = this.value
+        tim = MakeTime(
+            HourFromTime(t), MinFromTime(t), SecFromTime(t), ms.to_int())
+        u = TimeClip(MakeDate(Day(t), tim))
+        this.value = u
+        return u
+
+    # todo Complete all setters!
+
+    def toUTCString():
+        check_date(this)
+        return this.utc_strftime('%d %B %Y %H:%M:%S')
+
+    def toISOString():
+        check_date(this)
+        t = this.value
+        year = YearFromTime(t)
+        month, day, hour, minute, second, milli = pad(
+            MonthFromTime(t) + 1), pad(DateFromTime(t)), pad(
+                HourFromTime(t)), pad(MinFromTime(t)), pad(
+                    SecFromTime(t)), pad(msFromTime(t))
+        return ISO_FORMAT % (unicode(year) if 0 <= year <= 9999 else pad(
+            year, 6, True), month, day, hour, minute, second, milli)
+
+    def toJSON(key):
+        o = this.to_object()
+        tv = o.to_primitive('Number')
+        if tv.Class == 'Number' and not tv.is_finite():
+            return this.null
+        toISO = o.get('toISOString')
+        if not toISO.is_callable():
+            raise this.MakeError('TypeError', 'toISOString is not callable')
+        return toISO.call(o, ())
+
+
+def pad(num, n=2, sign=False):
+    '''returns n digit string representation of the num'''
+    s = unicode(abs(num))
+    if len(s) < n:
+        s = '0' * (n - len(s)) + s
+    if not sign:
+        return s
+    if num >= 0:
+        return '+' + s
+    else:
+        return '-' + s
+
+
+fill_prototype(DatePrototype, DateProto, default_attrs)
+
+Date.define_own_property(
+    'prototype', {
+        'value': DatePrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+DatePrototype.define_own_property('constructor', {
+    'value': Date,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
@@ -0,0 +1,87 @@
+# this is based on jsarray.py
+
+from ..base import *
+try:
+    import numpy
+except:
+    pass
+
+
+@Js
+def Float32Array():
+    TypedArray = (PyJsInt8Array, PyJsUint8Array, PyJsUint8ClampedArray,
+                  PyJsInt16Array, PyJsUint16Array, PyJsInt32Array,
+                  PyJsUint32Array, PyJsFloat32Array, PyJsFloat64Array)
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):  # length
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js(numpy.full(length, 0, dtype=numpy.float32))
+        temp.put('length', a)
+        return temp
+    elif isinstance(a, PyJsString):  # object (string)
+        temp = Js(numpy.array(list(a.value), dtype=numpy.float32))
+        temp.put('length', Js(len(list(a.value))))
+        return temp
+    elif isinstance(a, PyJsArray) or isinstance(a, TypedArray) or isinstance(
+            a, PyJsArrayBuffer):  # object (Array, TypedArray)
+        array = a.to_list()
+        array = [(int(item.value) if item.value != None else 0)
+                 for item in array]
+        temp = Js(numpy.array(array, dtype=numpy.float32))
+        temp.put('length', Js(len(array)))
+        return temp
+    elif isinstance(a, PyObjectWrapper):  # object (ArrayBuffer, etc)
+        if len(a.obj) % 4 != 0:
+            raise MakeError(
+                'RangeError',
+                'Byte length of Float32Array should be a multiple of 4')
+        if len(arguments) > 1:
+            offset = int(arguments[1].value)
+            if offset % 4 != 0:
+                raise MakeError(
+                    'RangeError',
+                    'Start offset of Float32Array should be a multiple of 4')
+        else:
+            offset = 0
+        if len(arguments) > 2:
+            length = int(arguments[2].value)
+        else:
+            length = int((len(a.obj) - offset) / 4)
+        array = numpy.frombuffer(
+            a.obj, dtype=numpy.float32, count=length, offset=offset)
+        temp = Js(array)
+        temp.put('length', Js(length))
+        temp.buff = array
+        return temp
+    temp = Js(numpy.full(0, 0, dtype=numpy.float32))
+    temp.put('length', Js(0))
+    return temp
+
+
+Float32Array.create = Float32Array
+Float32Array.own['length']['value'] = Js(3)
+
+Float32Array.define_own_property(
+    'prototype', {
+        'value': Float32ArrayPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+Float32ArrayPrototype.define_own_property(
+    'constructor', {
+        'value': Float32Array,
+        'enumerable': False,
+        'writable': True,
+        'configurable': True
+    })
+
+Float32ArrayPrototype.define_own_property('BYTES_PER_ELEMENT', {
+    'value': Js(4),
+    'enumerable': False,
+    'writable': False,
+    'configurable': False
+})
@@ -0,0 +1,87 @@
+# this is based on jsarray.py
+
+from ..base import *
+try:
+    import numpy
+except:
+    pass
+
+
+@Js
+def Float64Array():
+    TypedArray = (PyJsInt8Array, PyJsUint8Array, PyJsUint8ClampedArray,
+                  PyJsInt16Array, PyJsUint16Array, PyJsInt32Array,
+                  PyJsUint32Array, PyJsFloat32Array, PyJsFloat64Array)
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):  # length
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js(numpy.full(length, 0, dtype=numpy.float64))
+        temp.put('length', a)
+        return temp
+    elif isinstance(a, PyJsString):  # object (string)
+        temp = Js(numpy.array(list(a.value), dtype=numpy.float64))
+        temp.put('length', Js(len(list(a.value))))
+        return temp
+    elif isinstance(a, PyJsArray) or isinstance(a, TypedArray) or isinstance(
+            a, PyJsArrayBuffer):  # object (Array, TypedArray)
+        array = a.to_list()
+        array = [(int(item.value) if item.value != None else 0)
+                 for item in array]
+        temp = Js(numpy.array(array, dtype=numpy.float64))
+        temp.put('length', Js(len(array)))
+        return temp
+    elif isinstance(a, PyObjectWrapper):  # object (ArrayBuffer, etc)
+        if len(a.obj) % 8 != 0:
+            raise MakeError(
+                'RangeError',
+                'Byte length of Float64Array should be a multiple of 8')
+        if len(arguments) > 1:
+            offset = int(arguments[1].value)
+            if offset % 8 != 0:
+                raise MakeError(
+                    'RangeError',
+                    'Start offset of Float64Array should be a multiple of 8')
+        else:
+            offset = 0
+        if len(arguments) > 2:
+            length = int(arguments[2].value)
+        else:
+            length = int((len(a.obj) - offset) / 8)
+        array = numpy.frombuffer(
+            a.obj, dtype=numpy.float64, count=length, offset=offset)
+        temp = Js(array)
+        temp.put('length', Js(length))
+        temp.buff = array
+        return temp
+    temp = Js(numpy.full(0, 0, dtype=numpy.float64))
+    temp.put('length', Js(0))
+    return temp
+
+
+Float64Array.create = Float64Array
+Float64Array.own['length']['value'] = Js(3)
+
+Float64Array.define_own_property(
+    'prototype', {
+        'value': Float64ArrayPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+Float64ArrayPrototype.define_own_property(
+    'constructor', {
+        'value': Float64Array,
+        'enumerable': False,
+        'writable': True,
+        'configurable': True
+    })
+
+Float64ArrayPrototype.define_own_property('BYTES_PER_ELEMENT', {
+    'value': Js(8),
+    'enumerable': False,
+    'writable': False,
+    'configurable': False
+})
@@ -0,0 +1,52 @@
+from ..base import *
+try:
+    from ..translators.translator import translate_js
+except:
+    pass
+
+
+@Js
+def Function():
+    # convert arguments to python list of strings
+    a = [e.to_string().value for e in arguments.to_list()]
+    body = ';'
+    args = ()
+    if len(a):
+        body = '%s;' % a[-1]
+        args = a[:-1]
+    # translate this function to js inline function
+    js_func = '(function (%s) {%s})' % (','.join(args), body)
+    # now translate js inline to python function
+    py_func = translate_js(js_func, '')
+    # add set func scope to global scope
+    # a but messy solution but works :)
+    globals()['var'] = PyJs.GlobalObject
+    # define py function and return it
+    temp = executor(py_func, globals())
+    temp.source = '{%s}' % body
+    temp.func_name = 'anonymous'
+    return temp
+
+
+def executor(f, glob):
+    exec (f, globals())
+    return globals()['PyJs_anonymous_0_']
+
+
+#new statement simply calls Function
+Function.create = Function
+
+#set constructor property inside FunctionPrototype
+
+fill_in_props(FunctionPrototype, {'constructor': Function}, default_attrs)
+
+#attach prototype to Function constructor
+Function.define_own_property(
+    'prototype', {
+        'value': FunctionPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+#Fix Function length (its 0 and should be 1)
+Function.own['length']['value'] = Js(1)
@@ -0,0 +1,87 @@
+# this is based on jsarray.py
+
+from ..base import *
+try:
+    import numpy
+except:
+    pass
+
+
+@Js
+def Int16Array():
+    TypedArray = (PyJsInt8Array, PyJsUint8Array, PyJsUint8ClampedArray,
+                  PyJsInt16Array, PyJsUint16Array, PyJsInt32Array,
+                  PyJsUint32Array, PyJsFloat32Array, PyJsFloat64Array)
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):  # length
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js(numpy.full(length, 0, dtype=numpy.int16))
+        temp.put('length', a)
+        return temp
+    elif isinstance(a, PyJsString):  # object (string)
+        temp = Js(numpy.array(list(a.value), dtype=numpy.int16))
+        temp.put('length', Js(len(list(a.value))))
+        return temp
+    elif isinstance(a, PyJsArray) or isinstance(a, TypedArray) or isinstance(
+            a, PyJsArrayBuffer):  # object (Array, TypedArray)
+        array = a.to_list()
+        array = [(int(item.value) if item.value != None else 0)
+                 for item in array]
+        temp = Js(numpy.array(array, dtype=numpy.int16))
+        temp.put('length', Js(len(array)))
+        return temp
+    elif isinstance(a, PyObjectWrapper):  # object (ArrayBuffer, etc)
+        if len(a.obj) % 2 != 0:
+            raise MakeError(
+                'RangeError',
+                'Byte length of Int16Array should be a multiple of 2')
+        if len(arguments) > 1:
+            offset = int(arguments[1].value)
+            if offset % 2 != 0:
+                raise MakeError(
+                    'RangeError',
+                    'Start offset of Int16Array should be a multiple of 2')
+        else:
+            offset = 0
+        if len(arguments) > 2:
+            length = int(arguments[2].value)
+        else:
+            length = int((len(a.obj) - offset) / 2)
+        array = numpy.frombuffer(
+            a.obj, dtype=numpy.int16, count=length, offset=offset)
+        temp = Js(array)
+        temp.put('length', Js(length))
+        temp.buff = array
+        return temp
+    temp = Js(numpy.full(0, 0, dtype=numpy.int16))
+    temp.put('length', Js(0))
+    return temp
+
+
+Int16Array.create = Int16Array
+Int16Array.own['length']['value'] = Js(3)
+
+Int16Array.define_own_property(
+    'prototype', {
+        'value': Int16ArrayPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+Int16ArrayPrototype.define_own_property(
+    'constructor', {
+        'value': Int16Array,
+        'enumerable': False,
+        'writable': True,
+        'configurable': True
+    })
+
+Int16ArrayPrototype.define_own_property('BYTES_PER_ELEMENT', {
+    'value': Js(2),
+    'enumerable': False,
+    'writable': False,
+    'configurable': False
+})
@@ -0,0 +1,87 @@
+# this is based on jsarray.py
+
+from ..base import *
+try:
+    import numpy
+except:
+    pass
+
+
+@Js
+def Int32Array():
+    TypedArray = (PyJsInt8Array, PyJsUint8Array, PyJsUint8ClampedArray,
+                  PyJsInt16Array, PyJsUint16Array, PyJsInt32Array,
+                  PyJsUint32Array, PyJsFloat32Array, PyJsFloat64Array)
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):  # length
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js(numpy.full(length, 0, dtype=numpy.int32))
+        temp.put('length', a)
+        return temp
+    elif isinstance(a, PyJsString):  # object (string)
+        temp = Js(numpy.array(list(a.value), dtype=numpy.int32))
+        temp.put('length', Js(len(list(a.value))))
+        return temp
+    elif isinstance(a, PyJsArray) or isinstance(a, TypedArray) or isinstance(
+            a, PyJsArrayBuffer):  # object (Array, TypedArray)
+        array = a.to_list()
+        array = [(int(item.value) if item.value != None else 0)
+                 for item in array]
+        temp = Js(numpy.array(array, dtype=numpy.int32))
+        temp.put('length', Js(len(array)))
+        return temp
+    elif isinstance(a, PyObjectWrapper):  # object (ArrayBuffer, etc)
+        if len(a.obj) % 4 != 0:
+            raise MakeError(
+                'RangeError',
+                'Byte length of Int32Array should be a multiple of 4')
+        if len(arguments) > 1:
+            offset = int(arguments[1].value)
+            if offset % 4 != 0:
+                raise MakeError(
+                    'RangeError',
+                    'Start offset of Int32Array should be a multiple of 4')
+        else:
+            offset = 0
+        if len(arguments) > 2:
+            length = int(arguments[2].value)
+        else:
+            length = int((len(a.obj) - offset) / 4)
+        array = numpy.frombuffer(
+            a.obj, dtype=numpy.int32, count=length, offset=offset)
+        temp = Js(array)
+        temp.put('length', Js(length))
+        temp.buff = array
+        return temp
+    temp = Js(numpy.full(0, 0, dtype=numpy.int32))
+    temp.put('length', Js(0))
+    return temp
+
+
+Int32Array.create = Int32Array
+Int32Array.own['length']['value'] = Js(3)
+
+Int32Array.define_own_property(
+    'prototype', {
+        'value': Int32ArrayPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+Int32ArrayPrototype.define_own_property(
+    'constructor', {
+        'value': Int32Array,
+        'enumerable': False,
+        'writable': True,
+        'configurable': True
+    })
+
+Int32ArrayPrototype.define_own_property('BYTES_PER_ELEMENT', {
+    'value': Js(4),
+    'enumerable': False,
+    'writable': False,
+    'configurable': False
+})
@@ -0,0 +1,79 @@
+# this is based on jsarray.py
+
+from ..base import *
+try:
+    import numpy
+except:
+    pass
+
+
+@Js
+def Int8Array():
+    TypedArray = (PyJsInt8Array, PyJsUint8Array, PyJsUint8ClampedArray,
+                  PyJsInt16Array, PyJsUint16Array, PyJsInt32Array,
+                  PyJsUint32Array, PyJsFloat32Array, PyJsFloat64Array)
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):  # length
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js(numpy.full(length, 0, dtype=numpy.int8))
+        temp.put('length', a)
+        return temp
+    elif isinstance(a, PyJsString):  # object (string)
+        temp = Js(numpy.array(list(a.value), dtype=numpy.int8))
+        temp.put('length', Js(len(list(a.value))))
+        return temp
+    elif isinstance(a, PyJsArray) or isinstance(a, TypedArray) or isinstance(
+            a, PyJsArrayBuffer):  # object (Array, TypedArray)
+        array = a.to_list()
+        array = [(int(item.value) if item.value != None else 0)
+                 for item in array]
+        temp = Js(numpy.array(array, dtype=numpy.int8))
+        temp.put('length', Js(len(array)))
+        return temp
+    elif isinstance(a, PyObjectWrapper):  # object (ArrayBuffer, etc)
+        if len(arguments) > 1:
+            offset = int(arguments[1].value)
+        else:
+            offset = 0
+        if len(arguments) > 2:
+            length = int(arguments[2].value)
+        else:
+            length = int(len(a.obj) - offset)
+        array = numpy.frombuffer(
+            a.obj, dtype=numpy.int8, count=length, offset=offset)
+        temp = Js(array)
+        temp.put('length', Js(length))
+        temp.buff = array
+        return temp
+    temp = Js(numpy.full(0, 0, dtype=numpy.int8))
+    temp.put('length', Js(0))
+    return temp
+
+
+Int8Array.create = Int8Array
+Int8Array.own['length']['value'] = Js(3)
+
+Int8Array.define_own_property(
+    'prototype', {
+        'value': Int8ArrayPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+Int8ArrayPrototype.define_own_property(
+    'constructor', {
+        'value': Int8Array,
+        'enumerable': False,
+        'writable': True,
+        'configurable': True
+    })
+
+Int8ArrayPrototype.define_own_property('BYTES_PER_ELEMENT', {
+    'value': Js(1),
+    'enumerable': False,
+    'writable': False,
+    'configurable': False
+})
@@ -0,0 +1,157 @@
+from ..base import *
+import math
+import random
+
+Math = PyJsObject(prototype=ObjectPrototype)
+Math.Class = 'Math'
+
+CONSTANTS = {
+    'E': 2.7182818284590452354,
+    'LN10': 2.302585092994046,
+    'LN2': 0.6931471805599453,
+    'LOG2E': 1.4426950408889634,
+    'LOG10E': 0.4342944819032518,
+    'PI': 3.1415926535897932,
+    'SQRT1_2': 0.7071067811865476,
+    'SQRT2': 1.4142135623730951
+}
+
+for constant, value in CONSTANTS.items():
+    Math.define_own_property(
+        constant, {
+            'value': Js(value),
+            'writable': False,
+            'enumerable': False,
+            'configurable': False
+        })
+
+
+class MathFunctions:
+    def abs(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        return abs(a)
+
+    def acos(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        try:
+            return math.acos(a)
+        except:
+            return NaN
+
+    def asin(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        try:
+            return math.asin(a)
+        except:
+            return NaN
+
+    def atan(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        return math.atan(a)
+
+    def atan2(y, x):
+        a = x.to_number().value
+        b = y.to_number().value
+        if a != a or b != b:  # it must be a nan
+            return NaN
+        return math.atan2(b, a)
+
+    def ceil(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        return math.ceil(a)
+
+    def floor(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        return math.floor(a)
+
+    def round(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        return round(a)
+
+    def sin(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        return math.sin(a)
+
+    def cos(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        return math.cos(a)
+
+    def tan(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        return math.tan(a)
+
+    def log(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        try:
+            return math.log(a)
+        except:
+            return NaN
+
+    def exp(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        return math.exp(a)
+
+    def pow(x, y):
+        a = x.to_number().value
+        b = y.to_number().value
+        if a != a or b != b:  # it must be a nan
+            return NaN
+        try:
+            return a**b
+        except:
+            return NaN
+
+    def sqrt(x):
+        a = x.to_number().value
+        if a != a:  # it must be a nan
+            return NaN
+        try:
+            return a**0.5
+        except:
+            return NaN
+
+    def min():
+        if not len(arguments):
+            return Infinity
+        lis = tuple(e.to_number().value for e in arguments.to_list())
+        if any(e != e for e in lis):  # we dont want NaNs
+            return NaN
+        return min(*lis)
+
+    def max():
+        if not len(arguments):
+            return -Infinity
+        lis = tuple(e.to_number().value for e in arguments.to_list())
+        if any(e != e for e in lis):  # we dont want NaNs
+            return NaN
+        return max(*lis)
+
+    def random():
+        return random.random()
+
+
+fill_prototype(Math, MathFunctions, default_attrs)
@@ -0,0 +1,23 @@
+from ..base import *
+
+CONSTS = {
+    'prototype': NumberPrototype,
+    'MAX_VALUE': 1.7976931348623157e308,
+    'MIN_VALUE': 5.0e-324,
+    'NaN': NaN,
+    'NEGATIVE_INFINITY': float('-inf'),
+    'POSITIVE_INFINITY': float('inf')
+}
+
+fill_in_props(Number, CONSTS, {
+    'enumerable': False,
+    'writable': False,
+    'configurable': False
+})
+
+NumberPrototype.define_own_property('constructor', {
+    'value': Number,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
@@ -0,0 +1,198 @@
+from ..base import *
+import six
+
+#todo Double check everything is OK
+
+
+@Js
+def Object():
+    val = arguments.get('0')
+    if val.is_null() or val.is_undefined():
+        return PyJsObject(prototype=ObjectPrototype)
+    return val.to_object()
+
+
+@Js
+def object_constructor():
+    if len(arguments):
+        val = arguments.get('0')
+        if val.TYPE == 'Object':
+            #Implementation dependent, but my will simply return :)
+            return val
+        elif val.TYPE in ('Number', 'String', 'Boolean'):
+            return val.to_object()
+    return PyJsObject(prototype=ObjectPrototype)
+
+
+Object.create = object_constructor
+Object.own['length']['value'] = Js(1)
+
+
+class ObjectMethods:
+    def getPrototypeOf(obj):
+        if not obj.is_object():
+            raise MakeError('TypeError',
+                            'Object.getPrototypeOf called on non-object')
+        return null if obj.prototype is None else obj.prototype
+
+    def getOwnPropertyDescriptor(obj, prop):
+        if not obj.is_object():
+            raise MakeError(
+                'TypeError',
+                'Object.getOwnPropertyDescriptor called on non-object')
+        return obj.own.get(
+            prop.to_string().
+            value)  # will return undefined if we dont have this prop
+
+    def getOwnPropertyNames(obj):
+        if not obj.is_object():
+            raise MakeError(
+                'TypeError',
+                'Object.getOwnPropertyDescriptor called on non-object')
+        return obj.own.keys()
+
+    def create(obj):
+        if not (obj.is_object() or obj.is_null()):
+            raise MakeError('TypeError',
+                            'Object prototype may only be an Object or null')
+        temp = PyJsObject(prototype=(None if obj.is_null() else obj))
+        if len(arguments) > 1 and not arguments[1].is_undefined():
+            if six.PY2:
+                ObjectMethods.defineProperties.__func__(temp, arguments[1])
+            else:
+                ObjectMethods.defineProperties(temp, arguments[1])
+        return temp
+
+    def defineProperty(obj, prop, attrs):
+        if not obj.is_object():
+            raise MakeError('TypeError',
+                            'Object.defineProperty called on non-object')
+        name = prop.to_string().value
+        if not obj.define_own_property(name, ToPropertyDescriptor(attrs)):
+            raise MakeError('TypeError', 'Cannot redefine property: %s' % name)
+        return obj
+
+    def defineProperties(obj, properties):
+        if not obj.is_object():
+            raise MakeError('TypeError',
+                            'Object.defineProperties called on non-object')
+        props = properties.to_object()
+        for name in props:
+            desc = ToPropertyDescriptor(props.get(name.value))
+            if not obj.define_own_property(name.value, desc):
+                raise MakeError(
+                    'TypeError',
+                    'Failed to define own property: %s' % name.value)
+        return obj
+
+    def seal(obj):
+        if not obj.is_object():
+            raise MakeError('TypeError', 'Object.seal called on non-object')
+        for desc in obj.own.values():
+            desc['configurable'] = False
+        obj.extensible = False
+        return obj
+
+    def freeze(obj):
+        if not obj.is_object():
+            raise MakeError('TypeError', 'Object.freeze called on non-object')
+        for desc in obj.own.values():
+            desc['configurable'] = False
+            if is_data_descriptor(desc):
+                desc['writable'] = False
+        obj.extensible = False
+        return obj
+
+    def preventExtensions(obj):
+        if not obj.is_object():
+            raise MakeError('TypeError',
+                            'Object.preventExtensions on non-object')
+        obj.extensible = False
+        return obj
+
+    def isSealed(obj):
+        if not obj.is_object():
+            raise MakeError('TypeError',
+                            'Object.isSealed called on non-object')
+        if obj.extensible:
+            return False
+        for desc in obj.own.values():
+            if desc['configurable']:
+                return False
+        return True
+
+    def isFrozen(obj):
+        if not obj.is_object():
+            raise MakeError('TypeError',
+                            'Object.isFrozen called on non-object')
+        if obj.extensible:
+            return False
+        for desc in obj.own.values():
+            if desc['configurable']:
+                return False
+            if is_data_descriptor(desc) and desc['writable']:
+                return False
+        return True
+
+    def isExtensible(obj):
+        if not obj.is_object():
+            raise MakeError('TypeError',
+                            'Object.isExtensible called on non-object')
+        return obj.extensible
+
+    def keys(obj):
+        if not obj.is_object():
+            raise MakeError('TypeError', 'Object.keys called on non-object')
+        return [e for e, d in six.iteritems(obj.own) if d.get('enumerable')]
+
+
+# add methods attached to Object constructor
+fill_prototype(Object, ObjectMethods, default_attrs)
+# add constructor to prototype
+fill_in_props(ObjectPrototype, {'constructor': Object}, default_attrs)
+# add prototype property to the constructor.
+Object.define_own_property(
+    'prototype', {
+        'value': ObjectPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+# some utility functions:
+
+
+def ToPropertyDescriptor(obj):  # page 38 (50 absolute)
+    if obj.TYPE != 'Object':
+        raise MakeError('TypeError',
+                        'Can\'t convert non-object to property descriptor')
+    desc = {}
+    if obj.has_property('enumerable'):
+        desc['enumerable'] = obj.get('enumerable').to_boolean().value
+    if obj.has_property('configurable'):
+        desc['configurable'] = obj.get('configurable').to_boolean().value
+    if obj.has_property('value'):
+        desc['value'] = obj.get('value')
+    if obj.has_property('writable'):
+        desc['writable'] = obj.get('writable').to_boolean().value
+    if obj.has_property('get'):
+        cand = obj.get('get')
+        if not (cand.is_undefined() or cand.is_callable()):
+            raise MakeError(
+                'TypeError',
+                'Invalid getter (it has to be a function or undefined)')
+        desc['get'] = cand
+    if obj.has_property('set'):
+        cand = obj.get('set')
+        if not (cand.is_undefined() or cand.is_callable()):
+            raise MakeError(
+                'TypeError',
+                'Invalid setter (it has to be a function or undefined)')
+        desc['set'] = cand
+    if ('get' in desc or 'set' in desc) and ('value' in desc
+                                             or 'writable' in desc):
+        raise MakeError(
+            'TypeError',
+            'Invalid property.  A property cannot both have accessors and be writable or have a value.'
+        )
+    return desc
@@ -0,0 +1,16 @@
+from ..base import *
+
+RegExpPrototype.define_own_property('constructor', {
+    'value': RegExp,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
+
+RegExp.define_own_property(
+    'prototype', {
+        'value': RegExpPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
@@ -0,0 +1,40 @@
+from ..base import *
+# python 3 support
+import six
+if six.PY3:
+    unichr = chr
+
+
+@Js
+def fromCharCode():
+    args = arguments.to_list()
+    res = u''
+    for e in args:
+        res += unichr(e.to_uint16())
+    return this.Js(res)
+
+
+fromCharCode.own['length']['value'] = Js(1)
+
+String.define_own_property(
+    'fromCharCode', {
+        'value': fromCharCode,
+        'enumerable': False,
+        'writable': True,
+        'configurable': True
+    })
+
+String.define_own_property(
+    'prototype', {
+        'value': StringPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+StringPrototype.define_own_property('constructor', {
+    'value': String,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
@@ -0,0 +1,87 @@
+# this is based on jsarray.py
+
+from ..base import *
+try:
+    import numpy
+except:
+    pass
+
+
+@Js
+def Uint16Array():
+    TypedArray = (PyJsInt8Array, PyJsUint8Array, PyJsUint8ClampedArray,
+                  PyJsInt16Array, PyJsUint16Array, PyJsInt32Array,
+                  PyJsUint32Array, PyJsFloat32Array, PyJsFloat64Array)
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):  # length
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js(numpy.full(length, 0, dtype=numpy.uint16))
+        temp.put('length', a)
+        return temp
+    elif isinstance(a, PyJsString):  # object (string)
+        temp = Js(numpy.array(list(a.value), dtype=numpy.uint16))
+        temp.put('length', Js(len(list(a.value))))
+        return temp
+    elif isinstance(a, PyJsArray) or isinstance(a, TypedArray) or isinstance(
+            a, PyJsArrayBuffer):  # object (Array, TypedArray)
+        array = a.to_list()
+        array = [(int(item.value) if item.value != None else 0)
+                 for item in array]
+        temp = Js(numpy.array(array, dtype=numpy.uint16))
+        temp.put('length', Js(len(array)))
+        return temp
+    elif isinstance(a, PyObjectWrapper):  # object (ArrayBuffer, etc)
+        if len(a.obj) % 2 != 0:
+            raise MakeError(
+                'RangeError',
+                'Byte length of Uint16Array should be a multiple of 2')
+        if len(arguments) > 1:
+            offset = int(arguments[1].value)
+            if offset % 2 != 0:
+                raise MakeError(
+                    'RangeError',
+                    'Start offset of Uint16Array should be a multiple of 2')
+        else:
+            offset = 0
+        if len(arguments) > 2:
+            length = int(arguments[2].value)
+        else:
+            length = int((len(a.obj) - offset) / 2)
+        array = numpy.frombuffer(
+            a.obj, dtype=numpy.uint16, count=length, offset=offset)
+        temp = Js(array)
+        temp.put('length', Js(length))
+        temp.buff = array
+        return temp
+    temp = Js(numpy.full(0, 0, dtype=numpy.uint16))
+    temp.put('length', Js(0))
+    return temp
+
+
+Uint16Array.create = Uint16Array
+Uint16Array.own['length']['value'] = Js(3)
+
+Uint16Array.define_own_property(
+    'prototype', {
+        'value': Uint16ArrayPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+Uint16ArrayPrototype.define_own_property(
+    'constructor', {
+        'value': Uint16Array,
+        'enumerable': False,
+        'writable': True,
+        'configurable': True
+    })
+
+Uint16ArrayPrototype.define_own_property('BYTES_PER_ELEMENT', {
+    'value': Js(2),
+    'enumerable': False,
+    'writable': False,
+    'configurable': False
+})
@@ -0,0 +1,95 @@
+# this is based on jsarray.py
+
+from ..base import *
+try:
+    import numpy
+except:
+    pass
+
+
+@Js
+def Uint32Array():
+    TypedArray = (PyJsInt8Array, PyJsUint8Array, PyJsUint8ClampedArray,
+                  PyJsInt16Array, PyJsUint16Array, PyJsInt32Array,
+                  PyJsUint32Array, PyJsFloat32Array, PyJsFloat64Array)
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):  # length
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js(numpy.full(length, 0, dtype=numpy.uint32))
+        temp.put('length', a)
+        return temp
+    elif isinstance(a, PyJsString):  # object (string)
+        temp = Js(numpy.array(list(a.value), dtype=numpy.uint32))
+        temp.put('length', Js(len(list(a.value))))
+        return temp
+    elif isinstance(a, PyJsArray) or isinstance(a, TypedArray) or isinstance(
+            a, PyJsArrayBuffer):  # object (Array, TypedArray)
+        array = a.to_list()
+        array = [(int(item.value) if item.value != None else 0)
+                 for item in array]
+        if len(arguments) > 1:
+            offset = int(arguments[1].value)
+        else:
+            offset = 0
+        if len(arguments) > 2:
+            length = int(arguments[2].value)
+        else:
+            length = len(array) - offset
+        temp = Js(
+            numpy.array(array[offset:offset + length], dtype=numpy.uint32))
+        temp.put('length', Js(length))
+        return temp
+    elif isinstance(a, PyObjectWrapper):  # object (ArrayBuffer, etc)
+        if len(a.obj) % 4 != 0:
+            raise MakeError(
+                'RangeError',
+                'Byte length of Uint32Array should be a multiple of 4')
+        if len(arguments) > 1:
+            offset = int(arguments[1].value)
+            if offset % 4 != 0:
+                raise MakeError(
+                    'RangeError',
+                    'Start offset of Uint32Array should be a multiple of 4')
+        else:
+            offset = 0
+        if len(arguments) > 2:
+            length = int(arguments[2].value)
+        else:
+            length = int((len(a.obj) - offset) / 4)
+        temp = Js(
+            numpy.frombuffer(
+                a.obj, dtype=numpy.uint32, count=length, offset=offset))
+        temp.put('length', Js(length))
+        return temp
+    temp = Js(numpy.full(0, 0, dtype=numpy.uint32))
+    temp.put('length', Js(0))
+    return temp
+
+
+Uint32Array.create = Uint32Array
+Uint32Array.own['length']['value'] = Js(3)
+
+Uint32Array.define_own_property(
+    'prototype', {
+        'value': Uint32ArrayPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+Uint32ArrayPrototype.define_own_property(
+    'constructor', {
+        'value': Uint32Array,
+        'enumerable': False,
+        'writable': True,
+        'configurable': True
+    })
+
+Uint32ArrayPrototype.define_own_property('BYTES_PER_ELEMENT', {
+    'value': Js(4),
+    'enumerable': False,
+    'writable': False,
+    'configurable': False
+})
@@ -0,0 +1,79 @@
+# this is based on jsarray.py
+
+from ..base import *
+try:
+    import numpy
+except:
+    pass
+
+
+@Js
+def Uint8Array():
+    TypedArray = (PyJsInt8Array, PyJsUint8Array, PyJsUint8ClampedArray,
+                  PyJsInt16Array, PyJsUint16Array, PyJsInt32Array,
+                  PyJsUint32Array, PyJsFloat32Array, PyJsFloat64Array)
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):  # length
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js(numpy.full(length, 0, dtype=numpy.uint8))
+        temp.put('length', a)
+        return temp
+    elif isinstance(a, PyJsString):  # object (string)
+        temp = Js(numpy.array(list(a.value), dtype=numpy.uint8))
+        temp.put('length', Js(len(list(a.value))))
+        return temp
+    elif isinstance(a, PyJsArray) or isinstance(a, TypedArray) or isinstance(
+            a, PyJsArrayBuffer):  # object (Array, TypedArray)
+        array = a.to_list()
+        array = [(int(item.value) if item.value != None else 0)
+                 for item in array]
+        temp = Js(numpy.array(array, dtype=numpy.uint8))
+        temp.put('length', Js(len(array)))
+        return temp
+    elif isinstance(a, PyObjectWrapper):  # object (ArrayBuffer, etc)
+        if len(arguments) > 1:
+            offset = int(arguments[1].value)
+        else:
+            offset = 0
+        if len(arguments) > 2:
+            length = int(arguments[2].value)
+        else:
+            length = int(len(a.obj) - offset)
+        array = numpy.frombuffer(
+            a.obj, dtype=numpy.uint8, count=length, offset=offset)
+        temp = Js(array)
+        temp.put('length', Js(length))
+        temp.buff = array
+        return temp
+    temp = Js(numpy.full(0, 0, dtype=numpy.uint8))
+    temp.put('length', Js(0))
+    return temp
+
+
+Uint8Array.create = Uint8Array
+Uint8Array.own['length']['value'] = Js(3)
+
+Uint8Array.define_own_property(
+    'prototype', {
+        'value': Uint8ArrayPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+Uint8ArrayPrototype.define_own_property(
+    'constructor', {
+        'value': Uint8Array,
+        'enumerable': False,
+        'writable': True,
+        'configurable': True
+    })
+
+Uint8ArrayPrototype.define_own_property('BYTES_PER_ELEMENT', {
+    'value': Js(1),
+    'enumerable': False,
+    'writable': False,
+    'configurable': False
+})
@@ -0,0 +1,79 @@
+# this is based on jsarray.py
+
+from ..base import *
+try:
+    import numpy
+except:
+    pass
+
+
+@Js
+def Uint8ClampedArray():
+    TypedArray = (PyJsInt8Array, PyJsUint8Array, PyJsUint8ClampedArray,
+                  PyJsInt16Array, PyJsUint16Array, PyJsInt32Array,
+                  PyJsUint32Array, PyJsFloat32Array, PyJsFloat64Array)
+    a = arguments[0]
+    if isinstance(a, PyJsNumber):  # length
+        length = a.to_uint32()
+        if length != a.value:
+            raise MakeError('RangeError', 'Invalid array length')
+        temp = Js(numpy.full(length, 0, dtype=numpy.uint8), Clamped=True)
+        temp.put('length', a)
+        return temp
+    elif isinstance(a, PyJsString):  # object (string)
+        temp = Js(numpy.array(list(a.value), dtype=numpy.uint8), Clamped=True)
+        temp.put('length', Js(len(list(a.value))))
+        return temp
+    elif isinstance(a, PyJsArray) or isinstance(a, TypedArray) or isinstance(
+            a, PyJsArrayBuffer):  # object (Array, TypedArray)
+        array = a.to_list()
+        array = [(int(item.value) if item.value != None else 0)
+                 for item in array]
+        temp = Js(numpy.array(array, dtype=numpy.uint8), Clamped=True)
+        temp.put('length', Js(len(array)))
+        return temp
+    elif isinstance(a, PyObjectWrapper):  # object (ArrayBuffer, etc)
+        if len(arguments) > 1:
+            offset = int(arguments[1].value)
+        else:
+            offset = 0
+        if len(arguments) > 2:
+            length = int(arguments[2].value)
+        else:
+            length = int(len(a.obj) - offset)
+        array = numpy.frombuffer(
+            a.obj, dtype=numpy.uint8, count=length, offset=offset)
+        temp = Js(array, Clamped=True)
+        temp.put('length', Js(length))
+        temp.buff = array
+        return temp
+    temp = Js(numpy.full(0, 0, dtype=numpy.uint8), Clamped=True)
+    temp.put('length', Js(0))
+    return temp
+
+
+Uint8ClampedArray.create = Uint8ClampedArray
+Uint8ClampedArray.own['length']['value'] = Js(3)
+
+Uint8ClampedArray.define_own_property(
+    'prototype', {
+        'value': Uint8ClampedArrayPrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+Uint8ClampedArrayPrototype.define_own_property(
+    'constructor', {
+        'value': Uint8ClampedArray,
+        'enumerable': False,
+        'writable': True,
+        'configurable': True
+    })
+
+Uint8ClampedArrayPrototype.define_own_property('BYTES_PER_ELEMENT', {
+    'value': Js(1),
+    'enumerable': False,
+    'writable': False,
+    'configurable': False
+})
@@ -0,0 +1,207 @@
+# NOTE: t must be INT!!!
+import time
+import datetime
+import warnings
+
+try:
+    from tzlocal import get_localzone
+    LOCAL_ZONE = get_localzone()
+except:  # except all problems...
+    warnings.warn(
+        'Please install or fix tzlocal library (pip install tzlocal) in order to make Date object work better. Otherwise I will assume DST is in effect all the time'
+    )
+
+    class LOCAL_ZONE:
+        @staticmethod
+        def dst(*args):
+            return 1
+
+
+from js2py.base import MakeError
+CUM = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365)
+msPerDay = 86400000
+msPerYear = int(86400000 * 365.242)
+msPerSecond = 1000
+msPerMinute = 60000
+msPerHour = 3600000
+HoursPerDay = 24
+MinutesPerHour = 60
+SecondsPerMinute = 60
+NaN = float('nan')
+LocalTZA = -time.timezone * msPerSecond
+
+
+def DaylightSavingTA(t):
+    if t is NaN:
+        return t
+    try:
+        return int(
+            LOCAL_ZONE.dst(datetime.datetime.utcfromtimestamp(
+                t // 1000)).seconds) * 1000
+    except:
+        warnings.warn(
+            'Invalid datetime date, assumed DST time, may be inaccurate...',
+            Warning)
+        return 1
+        #raise MakeError('TypeError', 'date not supported by python.datetime. I will solve it in future versions')
+
+
+def GetTimeZoneName(t):
+    return time.tzname[DaylightSavingTA(t) > 0]
+
+
+def LocalToUTC(t):
+    return t - LocalTZA - DaylightSavingTA(t - LocalTZA)
+
+
+def UTCToLocal(t):
+    return t + LocalTZA + DaylightSavingTA(t)
+
+
+def Day(t):
+    return t // 86400000
+
+
+def TimeWithinDay(t):
+    return t % 86400000
+
+
+def DaysInYear(y):
+    if y % 4:
+        return 365
+    elif y % 100:
+        return 366
+    elif y % 400:
+        return 365
+    else:
+        return 366
+
+
+def DayFromYear(y):
+    return 365 * (y - 1970) + (y - 1969) // 4 - (y - 1901) // 100 + (
+        y - 1601) // 400
+
+
+def TimeFromYear(y):
+    return 86400000 * DayFromYear(y)
+
+
+def YearFromTime(t):
+    guess = 1970 - t // 31556908800  # msPerYear
+    gt = TimeFromYear(guess)
+    if gt <= t:
+        while gt <= t:
+            guess += 1
+            gt = TimeFromYear(guess)
+        return guess - 1
+    else:
+        while gt > t:
+            guess -= 1
+            gt = TimeFromYear(guess)
+        return guess
+
+
+def DayWithinYear(t):
+    return Day(t) - DayFromYear(YearFromTime(t))
+
+
+def InLeapYear(t):
+    y = YearFromTime(t)
+    if y % 4:
+        return 0
+    elif y % 100:
+        return 1
+    elif y % 400:
+        return 0
+    else:
+        return 1
+
+
+def MonthFromTime(t):
+    day = DayWithinYear(t)
+    leap = InLeapYear(t)
+    if day < 31:
+        return 0
+    day -= leap
+    if day < 59:
+        return 1
+    elif day < 90:
+        return 2
+    elif day < 120:
+        return 3
+    elif day < 151:
+        return 4
+    elif day < 181:
+        return 5
+    elif day < 212:
+        return 6
+    elif day < 243:
+        return 7
+    elif day < 273:
+        return 8
+    elif day < 304:
+        return 9
+    elif day < 334:
+        return 10
+    else:
+        return 11
+
+
+def DateFromTime(t):
+    mon = MonthFromTime(t)
+    day = DayWithinYear(t)
+    return day - CUM[mon] - (1 if InLeapYear(t) and mon >= 2 else 0) + 1
+
+
+def WeekDay(t):
+    # 0 == sunday
+    return (Day(t) + 4) % 7
+
+
+def msFromTime(t):
+    return t % 1000
+
+
+def SecFromTime(t):
+    return (t // 1000) % 60
+
+
+def MinFromTime(t):
+    return (t // 60000) % 60
+
+
+def HourFromTime(t):
+    return (t // 3600000) % 24
+
+
+def MakeTime(hour, Min, sec, ms):
+    # takes PyJs objects and returns t
+    if not (hour.is_finite() and Min.is_finite() and sec.is_finite()
+            and ms.is_finite()):
+        return NaN
+    h, m, s, milli = hour.to_int(), Min.to_int(), sec.to_int(), ms.to_int()
+    return h * 3600000 + m * 60000 + s * 1000 + milli
+
+
+def MakeDay(year, month, date):
+    # takes PyJs objects and returns t
+    if not (year.is_finite() and month.is_finite() and date.is_finite()):
+        return NaN
+    y, m, dt = year.to_int(), month.to_int(), date.to_int()
+    y += m // 12
+    mn = m % 12
+    d = DayFromYear(y) + CUM[mn] + dt - 1 + (1 if DaysInYear(y) == 366
+                                             and mn >= 2 else 0)
+    return d  # ms per day
+
+
+def MakeDate(day, time):
+    return 86400000 * day + time
+
+
+def TimeClip(t):
+    if t != t or abs(t) == float('inf'):
+        return NaN
+    if abs(t) > 8.64 * 10**15:
+        return NaN
+    return int(t)
@@ -0,0 +1,41 @@
+INITIALISED = False
+babel = None
+babelPresetEs2015 = None
+
+
+def js6_to_js5(code):
+    global INITIALISED, babel, babelPresetEs2015
+    if not INITIALISED:
+        import signal, warnings, time
+        warnings.warn(
+            '\nImporting babel.py for the first time - this can take some time. \nPlease note that currently Javascript 6 in Js2Py is unstable and slow. Use only for tiny scripts!'
+        )
+
+        from .babel import babel as _babel
+        babel = _babel.Object.babel
+        babelPresetEs2015 = _babel.Object.babelPresetEs2015
+
+        # very weird hack. Somehow this helps babel to initialise properly!
+        try:
+            babel.transform('warmup', {'presets': {}})
+            signal.alarm(2)
+
+            def kill_it(a, b):
+                raise KeyboardInterrupt('Better work next time!')
+
+            signal.signal(signal.SIGALRM, kill_it)
+            babel.transform('stuckInALoop', {
+                'presets': babelPresetEs2015
+            }).code
+            for n in range(3):
+                time.sleep(1)
+        except:
+            print("Initialised babel!")
+        INITIALISED = True
+    return babel.transform(code, {'presets': babelPresetEs2015}).code
+
+
+if __name__ == '__main__':
+    print(js6_to_js5('obj={}; obj.x = function() {return () => this}'))
+    print()
+    print(js6_to_js5('const a = 1;'))
@@ -0,0 +1,6 @@
+// run buildBabel in this folder to convert this code to python!
+var babel = require("babel-core");
+var babelPresetEs2015 = require("babel-preset-es2015");
+
+Object.babelPresetEs2015 = babelPresetEs2015;
+Object.babel = babel;
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+
+# install all the dependencies and pack everything into one file babel_bundle.js (converted to es2015).
+npm install babel-core babel-cli babel-preset-es2015 browserify
+browserify babel.js -o babel_bundle.js -t [ babelify --presets [ es2015 ] ]
+
+# translate babel_bundle.js using js2py -> generates babel.py
+echo "Generating babel.py..."
+python -c "import js2py;js2py.translate_file('babel_bundle.js', 'babel.py');"
+rm babel_bundle.js
+
@@ -0,0 +1,267 @@
+# coding=utf-8
+from .translators import translate_js, DEFAULT_HEADER
+from .es6 import js6_to_js5
+import sys
+import time
+import json
+import six
+import os
+import hashlib
+import codecs
+
+__all__ = [
+    'EvalJs', 'translate_js', 'import_js', 'eval_js', 'translate_file',
+    'eval_js6', 'translate_js6', 'run_file', 'disable_pyimport',
+    'get_file_contents', 'write_file_contents'
+]
+DEBUG = False
+
+
+def disable_pyimport():
+    import pyjsparser.parser
+    pyjsparser.parser.ENABLE_PYIMPORT = False
+
+
+def path_as_local(path):
+    if os.path.isabs(path):
+        return path
+    # relative to cwd
+    return os.path.join(os.getcwd(), path)
+
+
+def import_js(path, lib_name, globals):
+    """Imports from javascript source file.
+      globals is your globals()"""
+    with codecs.open(path_as_local(path), "r", "utf-8") as f:
+        js = f.read()
+    e = EvalJs()
+    e.execute(js)
+    var = e.context['var']
+    globals[lib_name] = var.to_python()
+
+
+def get_file_contents(path_or_file):
+    if hasattr(path_or_file, 'read'):
+        js = path_or_file.read()
+    else:
+        with codecs.open(path_as_local(path_or_file), "r", "utf-8") as f:
+            js = f.read()
+    return js
+
+
+def write_file_contents(path_or_file, contents):
+    if hasattr(path_or_file, 'write'):
+        path_or_file.write(contents)
+    else:
+        with open(path_as_local(path_or_file), 'w') as f:
+            f.write(contents)
+
+
+def translate_file(input_path, output_path):
+    '''
+    Translates input JS file to python and saves the it to the output path.
+    It appends some convenience code at the end so that it is easy to import JS objects.
+
+    For example we have a file 'example.js' with:   var a = function(x) {return x}
+    translate_file('example.js', 'example.py')
+
+    Now example.py can be easily importend and used:
+    >>> from example import example
+    >>> example.a(30)
+    30
+    '''
+    js = get_file_contents(input_path)
+
+    py_code = translate_js(js)
+    lib_name = os.path.basename(output_path).split('.')[0]
+    head = '__all__ = [%s]\n\n# Don\'t look below, you will not understand this Python code :) I don\'t.\n\n' % repr(
+        lib_name)
+    tail = '\n\n# Add lib to the module scope\n%s = var.to_python()' % lib_name
+    out = head + py_code + tail
+    write_file_contents(output_path, out)
+
+
+def run_file(path_or_file, context=None):
+    ''' Context must be EvalJS object. Runs given path as a JS program. Returns (eval_value, context).
+    '''
+    if context is None:
+        context = EvalJs()
+    if not isinstance(context, EvalJs):
+        raise TypeError('context must be the instance of EvalJs')
+    eval_value = context.eval(get_file_contents(path_or_file))
+    return eval_value, context
+
+
+def eval_js(js):
+    """Just like javascript eval. Translates javascript to python,
+       executes and returns python object.
+       js is javascript source code
+
+       EXAMPLE:
+        >>> import js2py
+        >>> add = js2py.eval_js('function add(a, b) {return a + b}')
+        >>> add(1, 2) + 3
+        6
+        >>> add('1', 2, 3)
+        u'12'
+        >>> add.constructor
+        function Function() { [python code] }
+
+       NOTE: For Js Number, String, Boolean and other base types returns appropriate python BUILTIN type.
+       For Js functions and objects, returns Python wrapper - basically behaves like normal python object.
+       If you really want to convert object to python dict you can use to_dict method.
+       """
+    e = EvalJs()
+    return e.eval(js)
+
+
+def eval_js6(js):
+    """Just like eval_js but with experimental support for js6 via babel."""
+    return eval_js(js6_to_js5(js))
+
+
+def translate_js6(js):
+    """Just like translate_js but with experimental support for js6 via babel."""
+    return translate_js(js6_to_js5(js))
+
+
+class EvalJs(object):
+    """This class supports continuous execution of javascript under same context.
+
+        >>> js = EvalJs()
+        >>> js.execute('var a = 10;function f(x) {return x*x};')
+        >>> js.f(9)
+        81
+        >>> js.a
+        10
+
+        context is a python dict or object that contains python variables that should be available to JavaScript
+        For example:
+        >>> js = EvalJs({'a': 30})
+        >>> js.execute('var x = a')
+        >>> js.x
+        30
+
+       You can run interactive javascript console with console method!"""
+
+    def __init__(self, context={}):
+        self.__dict__['_context'] = {}
+        exec (DEFAULT_HEADER, self._context)
+        self.__dict__['_var'] = self._context['var'].to_python()
+        if not isinstance(context, dict):
+            try:
+                context = context.__dict__
+            except:
+                raise TypeError(
+                    'context has to be either a dict or have __dict__ attr')
+        for k, v in six.iteritems(context):
+            setattr(self._var, k, v)
+
+    def execute(self, js=None, use_compilation_plan=False):
+        """executes javascript js in current context
+
+        During initial execute() the converted js is cached for re-use. That means next time you
+        run the same javascript snippet you save many instructions needed to parse and convert the
+        js code to python code.
+
+        This cache causes minor overhead (a cache dicts is updated) but the Js=>Py conversion process
+        is typically expensive compared to actually running the generated python code.
+
+        Note that the cache is just a dict, it has no expiration or cleanup so when running this
+        in automated situations with vast amounts of snippets it might increase memory usage.
+        """
+        try:
+            cache = self.__dict__['cache']
+        except KeyError:
+            cache = self.__dict__['cache'] = {}
+        hashkey = hashlib.md5(js.encode('utf-8')).digest()
+        try:
+            compiled = cache[hashkey]
+        except KeyError:
+            code = translate_js(
+                js, '', use_compilation_plan=use_compilation_plan)
+            compiled = cache[hashkey] = compile(code, '<EvalJS snippet>',
+                                                'exec')
+        exec (compiled, self._context)
+
+    def eval(self, expression, use_compilation_plan=False):
+        """evaluates expression in current context and returns its value"""
+        code = 'PyJsEvalResult = eval(%s)' % json.dumps(expression)
+        self.execute(code, use_compilation_plan=use_compilation_plan)
+        return self['PyJsEvalResult']
+
+    def execute_debug(self, js):
+        """executes javascript js in current context
+        as opposed to the (faster) self.execute method, you can use your regular debugger
+        to set breakpoints and inspect the generated python code
+        """
+        code = translate_js(js, '')
+        # make sure you have a temp folder:
+        filename = 'temp' + os.sep + '_' + hashlib.md5(
+            code.encode("utf-8")).hexdigest() + '.py'
+        try:
+            with open(filename, mode='w') as f:
+                f.write(code)
+            with open(filename, "r") as f:
+                pyCode = compile(f.read(), filename, 'exec')
+                exec(pyCode, self._context)
+                
+        except Exception as err:
+            raise err
+        finally:
+            os.remove(filename)
+            try:
+                os.remove(filename + 'c')
+            except:
+                pass
+
+    def eval_debug(self, expression):
+        """evaluates expression in current context and returns its value
+        as opposed to the (faster) self.execute method, you can use your regular debugger
+        to set breakpoints and inspect the generated python code
+        """
+        code = 'PyJsEvalResult = eval(%s)' % json.dumps(expression)
+        self.execute_debug(code)
+        return self['PyJsEvalResult']
+
+    def __getattr__(self, var):
+        return getattr(self._var, var)
+
+    def __getitem__(self, var):
+        return getattr(self._var, var)
+
+    def __setattr__(self, var, val):
+        return setattr(self._var, var, val)
+
+    def __setitem__(self, var, val):
+        return setattr(self._var, var, val)
+
+    def console(self):
+        """starts to interact (starts interactive console) Something like code.InteractiveConsole"""
+        while True:
+            if six.PY2:
+                code = raw_input('>>> ')
+            else:
+                code = input('>>>')
+            try:
+                print(self.eval(code))
+            except KeyboardInterrupt:
+                break
+            except Exception as e:
+                import traceback
+                if DEBUG:
+                    sys.stderr.write(traceback.format_exc())
+                else:
+                    sys.stderr.write('EXCEPTION: ' + str(e) + '\n')
+                time.sleep(0.01)
+
+
+#print x
+
+if __name__ == '__main__':
+    #with open('C:\Users\Piotrek\Desktop\esprima.js', 'rb') as f:
+    #    x = f.read()
+    e = EvalJs()
+    e.execute('square(x)')
+    #e.execute(x)
+    e.console()
@@ -0,0 +1,15 @@
+from ..base import *
+
+@Js
+def console():
+    pass
+
+@Js
+def log():
+    print(arguments[0])
+
+console.put('log', log)
+console.put('debug', log)
+console.put('info', log)
+console.put('warn', log)
+console.put('error', log)
@@ -0,0 +1,51 @@
+from ..base import *
+import inspect
+try:
+    from js2py.translators.translator import translate_js
+except:
+    pass
+
+
+@Js
+def Eval(code):
+    local_scope = inspect.stack()[3][0].f_locals['var']
+    global_scope = this.GlobalObject
+    # todo fix scope - we have to behave differently if called through variable other than eval
+    # we will use local scope (default)
+    globals()['var'] = local_scope
+    try:
+        py_code = translate_js(code.to_string().value, '')
+    except SyntaxError as syn_err:
+        raise MakeError('SyntaxError', str(syn_err))
+    lines = py_code.split('\n')
+    # a simple way to return value from eval. Will not work in complex cases.
+    has_return = False
+    for n in xrange(len(lines)):
+        line = lines[len(lines) - n - 1]
+        if line.strip():
+            if line.startswith(' '):
+                break
+            elif line.strip() == 'pass':
+                continue
+            elif any(
+                    line.startswith(e)
+                    for e in ['return ', 'continue ', 'break', 'raise ']):
+                break
+            else:
+                has_return = True
+                cand = 'EVAL_RESULT = (%s)\n' % line
+                try:
+                    compile(cand, '', 'exec')
+                except SyntaxError:
+                    break
+                lines[len(lines) - n - 1] = cand
+                py_code = '\n'.join(lines)
+                break
+    #print py_code
+    executor(py_code)
+    if has_return:
+        return globals()['EVAL_RESULT']
+
+
+def executor(code):
+    exec (code, globals())
@@ -0,0 +1,176 @@
+from ..base import *
+from six.moves.urllib.parse import quote, unquote
+
+RADIX_CHARS = {
+    '1': 1,
+    '0': 0,
+    '3': 3,
+    '2': 2,
+    '5': 5,
+    '4': 4,
+    '7': 7,
+    '6': 6,
+    '9': 9,
+    '8': 8,
+    'a': 10,
+    'c': 12,
+    'b': 11,
+    'e': 14,
+    'd': 13,
+    'g': 16,
+    'f': 15,
+    'i': 18,
+    'h': 17,
+    'k': 20,
+    'j': 19,
+    'm': 22,
+    'l': 21,
+    'o': 24,
+    'n': 23,
+    'q': 26,
+    'p': 25,
+    's': 28,
+    'r': 27,
+    'u': 30,
+    't': 29,
+    'w': 32,
+    'v': 31,
+    'y': 34,
+    'x': 33,
+    'z': 35,
+    'A': 10,
+    'C': 12,
+    'B': 11,
+    'E': 14,
+    'D': 13,
+    'G': 16,
+    'F': 15,
+    'I': 18,
+    'H': 17,
+    'K': 20,
+    'J': 19,
+    'M': 22,
+    'L': 21,
+    'O': 24,
+    'N': 23,
+    'Q': 26,
+    'P': 25,
+    'S': 28,
+    'R': 27,
+    'U': 30,
+    'T': 29,
+    'W': 32,
+    'V': 31,
+    'Y': 34,
+    'X': 33,
+    'Z': 35
+}
+
+
+@Js
+def parseInt(string, radix):
+    string = string.to_string().value.lstrip()
+    sign = 1
+    if string and string[0] in ('+', '-'):
+        if string[0] == '-':
+            sign = -1
+        string = string[1:]
+    r = radix.to_int32()
+    strip_prefix = True
+    if r:
+        if r < 2 or r > 36:
+            return NaN
+        if r != 16:
+            strip_prefix = False
+    else:
+        r = 10
+    if strip_prefix:
+        if len(string) >= 2 and string[:2] in ('0x', '0X'):
+            string = string[2:]
+            r = 16
+    n = 0
+    num = 0
+    while n < len(string):
+        cand = RADIX_CHARS.get(string[n])
+        if cand is None or not cand < r:
+            break
+        num = cand + num * r
+        n += 1
+    if not n:
+        return NaN
+    return sign * num
+
+
+@Js
+def parseFloat(string):
+    string = string.to_string().value.strip()
+    sign = 1
+    if string and string[0] in ('+', '-'):
+        if string[0] == '-':
+            sign = -1
+        string = string[1:]
+    num = None
+    length = 1
+    max_len = None
+    failed = 0
+    while length <= len(string):
+        try:
+            num = float(string[:length])
+            max_len = length
+            failed = 0
+        except:
+            failed += 1
+            if failed > 4:  # cant be a number anymore
+                break
+        length += 1
+    if num is None:
+        return NaN
+    return sign * float(string[:max_len])
+
+
+@Js
+def isNaN(number):
+    if number.to_number().is_nan():
+        return true
+    return false
+
+
+@Js
+def isFinite(number):
+    num = number.to_number()
+    if num.is_nan() or num.is_infinity():
+        return false
+    return true
+
+
+# todo test them properly
+
+
+@Js
+def escape(text):
+    return quote(text.to_string().value)
+
+
+@Js
+def unescape(text):
+    return unquote(text.to_string().value)
+
+
+@Js
+def encodeURI(text):
+    return quote(text.to_string().value, safe='~@#$&()*!+=:;,.?/\'')
+
+
+@Js
+def decodeURI(text):
+    return unquote(text.to_string().value)
+
+
+@Js
+def encodeURIComponent(text):
+    return quote(text.to_string().value, safe='~()*!.\'')
+
+
+@Js
+def decodeURIComponent(text):
+    return unquote(text.to_string().value)
@@ -0,0 +1,929 @@
+from __future__ import unicode_literals
+import re
+
+import datetime
+
+from .desc import *
+from .simplex import *
+from .conversions import *
+
+from pyjsparser import PyJsParser
+
+import six
+if six.PY2:
+    from itertools import izip
+else:
+    izip = zip
+
+
+
+
+def Type(obj):
+    return obj.TYPE
+
+
+# 8.6.2
+class PyJs(object):
+    TYPE = 'Object'
+    IS_CONSTRUCTOR = False
+
+    prototype = None
+    Class = None
+    extensible = True
+    value = None
+
+    own = {}
+
+    def get_member(self, unconverted_prop):
+        return self.get(to_string(unconverted_prop))
+
+    def put_member(self, unconverted_prop, val):
+        return self.put(to_string(unconverted_prop), val)
+
+    def get(self, prop):
+        assert type(prop) == unicode
+        cand = self.get_property(prop)
+        if cand is None:
+            return undefined
+        if is_data_descriptor(cand):
+            return cand['value']
+        if is_undefined(cand['get']):
+            return undefined
+        return cand['get'].call(self)
+
+    def get_own_property(self, prop):
+        assert type(prop) == unicode
+        # takes py returns py
+        return self.own.get(prop)
+
+    def get_property(self, prop):
+        assert type(prop) == unicode
+        # take py returns py
+        cand = self.get_own_property(prop)
+        if cand:
+            return cand
+        if self.prototype is not None:
+            return self.prototype.get_property(prop)
+
+    def put(self, prop, val, throw=False):
+        assert type(prop) == unicode
+        # takes py, returns none
+        if not self.can_put(prop):
+            if throw:
+                raise MakeError('TypeError', 'Could not define own property')
+            return
+        own_desc = self.get_own_property(prop)
+        if is_data_descriptor(own_desc):
+            self.own[prop]['value'] = val
+            return
+        desc = self.get_property(prop)
+        if is_accessor_descriptor(desc):
+            desc['set'].call(
+                self, (val, ))  # calling setter on own or inherited element
+        else:  # new property
+            self.own[prop] = {
+                'value': val,
+                'writable': True,
+                'configurable': True,
+                'enumerable': True
+            }
+
+    def can_put(self, prop):  # to check
+        assert type(prop) == unicode, type(prop)
+        # takes py returns py
+        desc = self.get_own_property(prop)
+        if desc:  # if we have this property
+            if is_accessor_descriptor(desc):
+                return is_callable(
+                    desc['set'])  # Check if setter method is defined
+            else:  # data desc
+                return desc['writable']
+        if self.prototype is None:
+            return self.extensible
+        inherited = self.prototype.get_property(prop)
+        if inherited is None:
+            return self.extensible
+        if is_accessor_descriptor(inherited):
+            return not is_undefined(inherited['set'])
+        elif self.extensible:
+            return inherited['writable']  # weird...
+        return False
+
+    def has_property(self, prop):
+        assert type(prop) == unicode
+        # takes py returns Py
+        return self.get_property(prop) is not None
+
+    def delete(self, prop, throw=False):
+        assert type(prop) == unicode
+        # takes py, returns py
+        desc = self.get_own_property(prop)
+        if desc is None:
+            return True
+        if desc['configurable']:
+            del self.own[prop]
+            return True
+        if throw:
+            raise MakeError('TypeError', 'Could not define own property')
+        return False
+
+    def default_value(self, hint=None):
+        order = ('valueOf', 'toString')
+        if hint == 'String' or (hint is None and self.Class == 'Date'):
+            order = ('toString', 'valueOf')
+        for meth_name in order:
+            method = self.get(meth_name)
+            if method is not None and is_callable(method):
+                cand = method.call(self, ())
+                if is_primitive(cand):
+                    return cand
+        raise MakeError('TypeError',
+                        'Cannot convert object to primitive value')
+
+    def define_own_property(
+            self, prop, desc,
+            throw):  # Internal use only. External through Object
+        assert type(prop) == unicode
+        # takes Py, returns Py
+        # prop must be a Py string. Desc is either a descriptor or accessor.
+        # Messy method -  raw translation from Ecma spec to prevent any bugs. # todo check this
+        current = self.get_own_property(prop)
+
+        extensible = self.extensible
+        if not current:  # We are creating a new OWN property
+            if not extensible:
+                if throw:
+                    raise MakeError('TypeError',
+                                    'Could not define own property')
+                return False
+            # extensible must be True
+            if is_data_descriptor(desc) or is_generic_descriptor(desc):
+                DEFAULT_DATA_DESC = {
+                    'value': undefined,  # undefined
+                    'writable': False,
+                    'enumerable': False,
+                    'configurable': False
+                }
+                DEFAULT_DATA_DESC.update(desc)
+                self.own[prop] = DEFAULT_DATA_DESC
+            else:
+                DEFAULT_ACCESSOR_DESC = {
+                    'get': undefined,  # undefined
+                    'set': undefined,  # undefined
+                    'enumerable': False,
+                    'configurable': False
+                }
+                DEFAULT_ACCESSOR_DESC.update(desc)
+                self.own[prop] = DEFAULT_ACCESSOR_DESC
+            return True
+        # therefore current exists!
+        if not desc or desc == current:  # We don't need to change anything.
+            return True
+        configurable = current['configurable']
+        if not configurable:  # Prevent changing params
+            if desc.get('configurable'):
+                if throw:
+                    raise MakeError('TypeError',
+                                    'Could not define own property')
+                return False
+            if 'enumerable' in desc and desc['enumerable'] != current[
+                    'enumerable']:
+                if throw:
+                    raise MakeError('TypeError',
+                                    'Could not define own property')
+                return False
+        if is_generic_descriptor(desc):
+            pass
+        elif is_data_descriptor(current) != is_data_descriptor(desc):
+            # we want to change the current type of property
+            if not configurable:
+                if throw:
+                    raise MakeError('TypeError',
+                                    'Could not define own property')
+                return False
+            if is_data_descriptor(current):  # from data to setter
+                del current['value']
+                del current['writable']
+                current['set'] = undefined  # undefined
+                current['get'] = undefined  # undefined
+            else:  # from setter to data
+                del current['set']
+                del current['get']
+                current['value'] = undefined  # undefined
+                current['writable'] = False
+        elif is_data_descriptor(current) and is_data_descriptor(desc):
+            if not configurable:
+                if not current['writable'] and desc.get('writable'):
+                    if throw:
+                        raise MakeError('TypeError',
+                                        'Could not define own property')
+                    return False
+            if not current['writable'] and 'value' in desc and current[
+                    'value'] != desc['value']:
+                if throw:
+                    raise MakeError('TypeError',
+                                    'Could not define own property')
+                return False
+        elif is_accessor_descriptor(current) and is_accessor_descriptor(desc):
+            if not configurable:
+                if 'set' in desc and desc['set'] != current['set']:
+                    if throw:
+                        raise MakeError('TypeError',
+                                        'Could not define own property')
+                    return False
+                if 'get' in desc and desc['get'] != current['get']:
+                    if throw:
+                        raise MakeError('TypeError',
+                                        'Could not define own property')
+                    return False
+        current.update(desc)
+        return True
+
+    def create(self, args, space):
+        '''Generally not a constructor, raise an error'''
+        raise MakeError('TypeError', '%s is not a constructor' % self.Class)
+
+
+def get_member(
+        self, prop, space
+):  # general member getter, prop has to be unconverted prop. it is it can be any value
+    typ = type(self)
+    if typ not in PRIMITIVES:  # most likely getter for object
+        return self.get_member(
+            prop
+        )  # <- object can implement this to support faster prop getting. ex array.
+    elif typ == unicode:  # then probably a String
+        if type(prop) == float and is_finite(prop):
+            index = int(prop)
+            if index == prop and 0 <= index < len(self):
+                return self[index]
+        s_prop = to_string(prop)
+        if s_prop == 'length':
+            return float(len(self))
+        elif s_prop.isdigit():
+            index = int(s_prop)
+            if 0 <= index < len(self):
+                return self[index]
+        # use standard string prototype
+        return space.StringPrototype.get(s_prop)
+        # maybe an index
+    elif typ == float:
+        # use standard number prototype
+        return space.NumberPrototype.get(to_string(prop))
+    elif typ == bool:
+        return space.BooleanPrototype.get(to_string(prop))
+    elif typ is UNDEFINED_TYPE:
+        raise MakeError('TypeError',
+                        "Cannot read property '%s' of undefined" % prop)
+    elif typ is NULL_TYPE:
+        raise MakeError('TypeError',
+                        "Cannot read property '%s' of null" % prop)
+    else:
+        raise RuntimeError('Unknown type! - ' + repr(typ))
+
+
+def get_member_dot(self, prop, space):
+    # dot member getter, prop has to be unicode
+    typ = type(self)
+    if typ not in PRIMITIVES:  # most likely getter for object
+        return self.get(prop)
+    elif typ == unicode:  # then probably a String
+        if prop == 'length':
+            return float(len(self))
+        elif prop.isdigit():
+            index = int(prop)
+            if 0 <= index < len(self):
+                return self[index]
+        else:
+            # use standard string prototype
+            return space.StringPrototype.get(prop)
+            # maybe an index
+    elif typ == float:
+        # use standard number prototype
+        return space.NumberPrototype.get(prop)
+    elif typ == bool:
+        return space.BooleanPrototype.get(prop)
+    elif typ in (UNDEFINED_TYPE, NULL_TYPE):
+        raise MakeError('TypeError',
+                        "Cannot read property '%s' of undefined" % prop)
+    else:
+        raise RuntimeError('Unknown type! - ' + repr(typ))
+
+
+# Object
+
+
+class PyJsObject(PyJs):
+    TYPE = 'Object'
+    Class = 'Object'
+
+    def __init__(self, prototype=None):
+        self.prototype = prototype
+        self.own = {}
+
+    def _init(self, props, vals):
+        i = 0
+        for prop, kind in props:
+            if prop in self.own:  # just check... probably will not happen very often.
+                if is_data_descriptor(self.own[prop]):
+                    if kind != 'i':
+                        raise MakeError(
+                            'SyntaxError',
+                            'Invalid object initializer! Duplicate property name "%s"'
+                            % prop)
+                else:
+                    if kind == 'i' or (kind == 'g' and 'get' in self.own[prop]
+                                       ) or (kind == 's'
+                                             and 'set' in self.own[prop]):
+                        raise MakeError(
+                            'SyntaxError',
+                            'Invalid object initializer! Duplicate setter/getter of prop: "%s"'
+                            % prop)
+
+            if kind == 'i':  # init
+                self.own[prop] = {
+                    'value': vals[i],
+                    'writable': True,
+                    'enumerable': True,
+                    'configurable': True
+                }
+            elif kind == 'g':  # get
+                self.define_own_property(prop, {
+                    'get': vals[i],
+                    'enumerable': True,
+                    'configurable': True
+                }, False)
+            elif kind == 's':  # get
+                self.define_own_property(prop, {
+                    'get': vals[i],
+                    'enumerable': True,
+                    'configurable': True
+                }, False)
+            else:
+                raise RuntimeError(
+                    'Invalid property kind - %s. Expected one of i, g, s.' %
+                    repr(kind))
+            i += 1
+
+    def _set_props(self, prop_descs):
+        for prop, desc in six.iteritems(prop_descs):
+            self.define_own_property(prop, desc)
+
+
+# Array
+
+
+# todo Optimise Array - extremely slow due to index conversions from str to int and back etc.
+# solution - make get and put methods callable with any type of prop and handle conversions from inside
+# if not array then use to_string(prop). In array if prop is integer then just use it
+# also consider removal of these stupid writable, enumerable etc for ints.
+class PyJsArray(PyJs):
+    Class = 'Array'
+
+    def __init__(self, length, prototype=None):
+        self.prototype = prototype
+        self.own = {
+            'length': {
+                'value': float(length),
+                'writable': True,
+                'enumerable': False,
+                'configurable': False
+            }
+        }
+
+    def _init(self, elements):
+        for i, ele in enumerate(elements):
+            if ele is None: continue
+            self.own[unicode(i)] = {
+                'value': ele,
+                'writable': True,
+                'enumerable': True,
+                'configurable': True
+            }
+
+    def put(self, prop, val, throw=False):
+        assert type(val) != int
+        # takes py, returns none
+        if not self.can_put(prop):
+            if throw:
+                raise MakeError('TypeError', 'Could not define own property')
+            return
+        own_desc = self.get_own_property(prop)
+        if is_data_descriptor(own_desc):
+            self.define_own_property(prop, {'value': val}, False)
+            return
+        desc = self.get_property(prop)
+        if is_accessor_descriptor(desc):
+            desc['set'].call(
+                self, (val, ))  # calling setter on own or inherited element
+        else:  # new property
+            self.define_own_property(
+                prop, {
+                    'value': val,
+                    'writable': True,
+                    'configurable': True,
+                    'enumerable': True
+                }, False)
+
+    def define_own_property(self, prop, desc, throw):
+        assert type(desc.get('value')) != int
+        old_len_desc = self.get_own_property('length')
+        old_len = old_len_desc['value']  #  value is js type so convert to py.
+        if prop == 'length':
+            if 'value' not in desc:
+                return PyJs.define_own_property(self, prop, desc, False)
+            new_len = to_uint32(desc['value'])
+            if new_len != to_number(desc['value']):
+                raise MakeError('RangeError', 'Invalid range!')
+            new_desc = dict((k, v) for k, v in six.iteritems(desc))
+            new_desc['value'] = float(new_len)
+            if new_len >= old_len:
+                return PyJs.define_own_property(self, prop, new_desc, False)
+            if not old_len_desc['writable']:
+                return False
+            if 'writable' not in new_desc or new_desc['writable'] == True:
+                new_writable = True
+            else:
+                new_writable = False
+                new_desc['writable'] = True
+            if not PyJs.define_own_property(self, prop, new_desc, False):
+                return False
+            if new_len < old_len:
+                # not very efficient for sparse arrays, so using different method for sparse:
+                if old_len > 30 * len(self.own):
+                    for ele in self.own.keys():
+                        if ele.isdigit() and int(ele) >= new_len:
+                            if not self.delete(
+                                    ele
+                            ):  # if failed to delete set len to current len and reject.
+                                new_desc['value'] = old_len + 1.
+                                if not new_writable:
+                                    new_desc['writable'] = False
+                                PyJs.define_own_property(
+                                    self, prop, new_desc, False)
+                                return False
+                    old_len = new_len
+                else:  # standard method
+                    while new_len < old_len:
+                        old_len -= 1
+                        if not self.delete(
+                                unicode(int(old_len))
+                        ):  # if failed to delete set len to current len and reject.
+                            new_desc['value'] = old_len + 1.
+                            if not new_writable:
+                                new_desc['writable'] = False
+                            PyJs.define_own_property(self, prop, new_desc,
+                                                     False)
+                            return False
+            if not new_writable:
+                self.own['length']['writable'] = False
+            return True
+
+        elif prop.isdigit():
+            index = to_uint32(prop)
+            if index >= old_len and not old_len_desc['writable']:
+                return False
+            if not PyJs.define_own_property(self, prop, desc, False):
+                return False
+            if index >= old_len:
+                old_len_desc['value'] = index + 1.
+            return True
+        else:
+            return PyJs.define_own_property(self, prop, desc, False)
+
+    def to_list(self):
+        return [
+            self.get(str(e)) for e in xrange(self.get('length').to_uint32())
+        ]
+
+
+# database with compiled patterns. Js pattern -> Py pattern.
+REGEXP_DB = {}
+
+
+class PyJsRegExp(PyJs):
+    Class = 'RegExp'
+
+    def __init__(self, body, flags, prototype=None):
+        self.prototype = prototype
+        self.glob = True if 'g' in flags else False
+        self.ignore_case = re.IGNORECASE if 'i' in flags else 0
+        self.multiline = re.MULTILINE if 'm' in flags else 0
+        self.value = body
+
+        if (body, flags) in REGEXP_DB:
+            self.pat = REGEXP_DB[body, flags]
+        else:
+            comp = None
+            try:
+                # converting JS regexp pattern to Py pattern.
+                possible_fixes = [(u'[]', u'[\0]'), (u'[^]', u'[^\0]'),
+                                  (u'nofix1791', u'nofix1791')]
+                reg = self.value
+                for fix, rep in possible_fixes:
+                    comp = PyJsParser()._interpret_regexp(reg, flags)
+                    #print 'reg -> comp', reg, '->', comp
+                    try:
+                        self.pat = re.compile(
+                            comp, self.ignore_case | self.multiline)
+                        #print reg, '->', comp
+                        break
+                    except:
+                        reg = reg.replace(fix, rep)
+                    # print 'Fix', fix, '->', rep, '=', reg
+                else:
+                    raise Exception()
+                REGEXP_DB[body, flags] = self.pat
+            except:
+                #print 'Invalid pattern...', self.value, comp
+                raise MakeError(
+                    'SyntaxError',
+                    'Invalid RegExp pattern: %s -> %s' % (repr(self.value),
+                                                          repr(comp)))
+        # now set own properties:
+        self.own = {
+            'source': {
+                'value': self.value,
+                'enumerable': False,
+                'writable': False,
+                'configurable': False
+            },
+            'global': {
+                'value': self.glob,
+                'enumerable': False,
+                'writable': False,
+                'configurable': False
+            },
+            'ignoreCase': {
+                'value': bool(self.ignore_case),
+                'enumerable': False,
+                'writable': False,
+                'configurable': False
+            },
+            'multiline': {
+                'value': bool(self.multiline),
+                'enumerable': False,
+                'writable': False,
+                'configurable': False
+            },
+            'lastIndex': {
+                'value': 0.,
+                'enumerable': False,
+                'writable': True,
+                'configurable': False
+            }
+        }
+
+    def match(self, string, pos):
+        '''string is of course a py string'''
+        return self.pat.match(string, int(pos))
+
+
+class PyJsError(PyJs):
+    Class = 'Error'
+    extensible = True
+
+    def __init__(self, message=None, prototype=None):
+        self.prototype = prototype
+        self.own = {}
+        if message is not None:
+            self.put('message', to_string(message))
+            self.own['message']['enumerable'] = False
+
+
+class PyJsDate(PyJs):
+    Class = 'Date'
+    UTCToLocal = None  # todo UTC to local should be imported!
+
+    def __init__(self, value, prototype=None):
+        self.value = value
+        self.own = {}
+        self.prototype = prototype
+
+    # todo fix this problematic datetime part
+    def to_local_dt(self):
+        return datetime.datetime.utcfromtimestamp(
+            self.UTCToLocal(self.value) // 1000)
+
+    def to_utc_dt(self):
+        return datetime.datetime.utcfromtimestamp(self.value // 1000)
+
+    def local_strftime(self, pattern):
+        if self.value is NaN:
+            return 'Invalid Date'
+        try:
+            dt = self.to_local_dt()
+        except:
+            raise MakeError(
+                'TypeError',
+                'unsupported date range. Will fix in future versions')
+        try:
+            return dt.strftime(pattern)
+        except:
+            raise MakeError(
+                'TypeError',
+                'Could not generate date string from this date (limitations of python.datetime)'
+            )
+
+    def utc_strftime(self, pattern):
+        if self.value is NaN:
+            return 'Invalid Date'
+        try:
+            dt = self.to_utc_dt()
+        except:
+            raise MakeError(
+                'TypeError',
+                'unsupported date range. Will fix in future versions')
+        try:
+            return dt.strftime(pattern)
+        except:
+            raise MakeError(
+                'TypeError',
+                'Could not generate date string from this date (limitations of python.datetime)'
+            )
+
+
+# Scope class it will hold all the variables accessible to user
+class Scope(PyJs):
+    Class = 'Global'
+    extensible = True
+    IS_CHILD_SCOPE = True
+    THIS_BINDING = None
+    space = None
+    exe = None
+
+    # todo speed up!
+    # in order to speed up this very important class the top scope should behave differently than
+    # child scopes, child scope should not have this property descriptor thing because they cant be changed anyway
+    # they are all confugurable= False
+
+    def __init__(self, scope, space, parent=None):
+        """Doc"""
+        self.space = space
+        self.prototype = parent
+        if type(scope) is not dict:
+            assert parent is not None, 'You initialised the WITH_SCOPE without a parent scope.'
+            self.own = scope
+            self.is_with_scope = True
+        else:
+            self.is_with_scope = False
+        if parent is None:
+            # global, top level scope
+            self.own = {}
+            for k, v in six.iteritems(scope):
+                # set all the global items
+                self.define_own_property(
+                    k, {
+                        'value': v,
+                        'configurable': False,
+                        'writable': False,
+                        'enumerable': False
+                    }, False)
+        else:
+            # not global, less powerful but faster closure.
+            self.own = scope  # simple dictionary which maps name directly to js object.
+
+        self.par = super(Scope, self)
+        self.stack = []
+
+    def register(self, var):
+        # registered keeps only global registered variables
+        if self.prototype is None:
+            # define in global scope
+            if var in self.own:
+                self.own[var]['configurable'] = False
+            else:
+                self.define_own_property(
+                    var, {
+                        'value': undefined,
+                        'configurable': False,
+                        'writable': True,
+                        'enumerable': True
+                    }, False)
+        elif var not in self.own:
+            # define in local scope since it has not been defined yet
+            self.own[var] = undefined  # default value
+
+    def registers(self, vars):
+        """register multiple variables"""
+        for var in vars:
+            self.register(var)
+
+    def put(self, var, val, throw=False):
+        if self.prototype is None:
+            desc = self.own.get(var)  # global scope
+            if desc is None:
+                self.par.put(var, val, False)
+            else:
+                if desc['writable']:  # todo consider getters/setters
+                    desc['value'] = val
+        else:
+            if self.is_with_scope:
+                if self.own.has_property(var):
+                    return self.own.put(var, val, throw=throw)
+                else:
+                    return self.prototype.put(var, val)
+            # trying to put in local scope
+            # we dont know yet in which scope we should place this var
+            elif var in self.own:
+                self.own[var] = val
+                return val
+            else:
+                # try to put in the lower scope since we cant put in this one (var wasn't registered)
+                return self.prototype.put(var, val)
+
+    def get(self, var, throw=False):
+        if self.prototype is not None:
+            if self.is_with_scope:
+                cand = None if not self.own.has_property(
+                    var) else self.own.get(var)
+            else:
+                # fast local scope
+                cand = self.own.get(var)
+            if cand is None:
+                return self.prototype.get(var, throw)
+            return cand
+        # slow, global scope
+        if var not in self.own:
+            # try in ObjectPrototype...
+            if var in self.space.ObjectPrototype.own:
+                return self.space.ObjectPrototype.get(var)
+            if throw:
+                raise MakeError('ReferenceError', '%s is not defined' % var)
+            return undefined
+        cand = self.own[var].get('value')
+        return cand if cand is not None else self.own[var]['get'].call(self)
+
+    def delete(self, var, throw=False):
+        if self.prototype is not None:
+            if self.is_with_scope:
+                if self.own.has_property(var):
+                    return self.own.delete(var)
+            elif var in self.own:
+                return False
+            return self.prototype.delete(var)
+        # we are in global scope here. Must exist and be configurable to delete
+        if var not in self.own:
+            # this var does not exist, why do you want to delete it???
+            return True
+        if self.own[var]['configurable']:
+            del self.own[var]
+            return True
+        # not configurable, cant delete
+        return False
+
+
+def get_new_arguments_obj(args, space):
+    obj = space.NewObject()
+    obj.Class = 'Arguments'
+    obj.define_own_property(
+        'length', {
+            'value': float(len(args)),
+            'writable': True,
+            'enumerable': False,
+            'configurable': True
+        }, False)
+    for i, e in enumerate(args):
+        obj.put(unicode(i), e)
+    return obj
+
+
+#Function
+class PyJsFunction(PyJs):
+    Class = 'Function'
+    source = '{ [native code] }'
+    IS_CONSTRUCTOR = True
+
+    def __init__(self,
+                 code,
+                 ctx,
+                 params,
+                 name,
+                 space,
+                 is_declaration,
+                 definitions,
+                 prototype=None):
+        self.prototype = prototype
+        self.own = {}
+
+        self.code = code
+        if type(
+                self.code
+        ) == int:  # just a label pointing to the beginning of the code.
+            self.is_native = False
+        else:
+            self.is_native = True  # python function
+
+        self.ctx = ctx
+
+        self.params = params
+        self.arguments_in_params = 'arguments' in params
+        self.definitions = definitions
+
+        # todo remove this check later
+        for p in params:
+            assert p in self.definitions
+
+        self.name = name
+        self.space = space
+        self.is_declaration = is_declaration
+
+        #set own property length to the number of arguments
+        self.own['length'] = {
+            'value': float(len(params)),
+            'writable': False,
+            'enumerable': False,
+            'configurable': False
+        }
+
+        if name:
+            self.own['name'] = {
+                'value': name,
+                'writable': False,
+                'enumerable': False,
+                'configurable': True
+            }
+
+        if not self.is_native:  # set prototype for user defined functions
+            # constructor points to this function
+            proto = space.NewObject()
+            proto.own['constructor'] = {
+                'value': self,
+                'writable': True,
+                'enumerable': False,
+                'configurable': True
+            }
+            self.own['prototype'] = {
+                'value': proto,
+                'writable': True,
+                'enumerable': False,
+                'configurable': False
+            }
+        # todo set up throwers on callee and arguments if in strict mode
+
+    def call(self, this, args=()):
+        ''' Dont use this method from inside bytecode to call other bytecode. '''
+        if self.is_native:
+            _args = SpaceTuple(
+                args
+            )  # we have to do that unfortunately to pass all the necessary info to the funcs
+            _args.space = self.space
+            return self.code(
+                this, _args
+            )  # must return valid js object - undefined, null, float, unicode, bool, or PyJs
+        else:
+            return self.space.exe._call(self, this,
+                                        args)  # will run inside bytecode
+
+    def has_instance(self, other):
+        # I am not sure here so instanceof may not work lol.
+        if not is_object(other):
+            return False
+        proto = self.get('prototype')
+        if not is_object(proto):
+            raise MakeError(
+                'TypeError',
+                'Function has non-object prototype in instanceof check')
+        while True:
+            other = other.prototype
+            if not other:  # todo make sure that the condition is not None or null
+                return False
+            if other is proto:
+                return True
+
+    def create(self, args, space):
+        proto = self.get('prototype')
+        if not is_object(proto):
+            proto = space.ObjectPrototype
+        new = PyJsObject(prototype=proto)
+        res = self.call(new, args)
+        if is_object(res):
+            return res
+        return new
+
+    def _generate_my_context(self, this, args):
+        my_ctx = Scope(
+            dict(izip(self.params, args)), self.space, parent=self.ctx)
+        my_ctx.registers(self.definitions)
+        my_ctx.THIS_BINDING = this
+        if not self.arguments_in_params:
+            my_ctx.own['arguments'] = get_new_arguments_obj(args, self.space)
+        if not self.is_declaration and self.name and self.name not in my_ctx.own:
+            my_ctx.own[
+                self.
+                name] = self  # this should be immutable binding but come on!
+        return my_ctx
+
+
+class SpaceTuple:
+    def __init__(self, tup):
+        self.tup = tup
+
+    def __len__(self):
+        return len(self.tup)
+
+    def __getitem__(self, item):
+        return self.tup[item]
+
+    def __iter__(self):
+        return iter(self.tup)
@@ -0,0 +1,753 @@
+from .code import Code
+from .simplex import MakeError
+from .opcodes import *
+from .operations import *
+from .trans_utils import *
+
+SPECIAL_IDENTIFIERS = {'true', 'false', 'this'}
+
+
+class ByteCodeGenerator:
+    def __init__(self, exe):
+        self.exe = exe
+
+        self.declared_continue_labels = {}
+        self.declared_break_labels = {}
+
+        self.implicit_breaks = []
+        self.implicit_continues = []
+
+        self.declared_vars = []
+
+        self.function_declaration_tape = []
+
+        self.states = []
+
+    def record_state(self):
+        self.states.append(
+            (self.declared_continue_labels, self.declared_break_labels,
+             self.implicit_breaks, self.implicit_continues, self.declared_vars,
+             self.function_declaration_tape))
+        self.declared_continue_labels, self.declared_break_labels, \
+        self.implicit_breaks, self.implicit_continues, \
+        self.declared_vars, self.function_declaration_tape = {}, {}, [], [], [], []
+
+    def restore_state(self):
+        self.declared_continue_labels, self.declared_break_labels, \
+        self.implicit_breaks, self.implicit_continues, \
+        self.declared_vars, self.function_declaration_tape = self.states.pop()
+
+    def ArrayExpression(self, elements, **kwargs):
+        for e in elements:
+            if e is None:
+                self.emit('LOAD_NONE')
+            else:
+                self.emit(e)
+        self.emit('LOAD_ARRAY', len(elements))
+
+    def AssignmentExpression(self, operator, left, right, **kwargs):
+        operator = operator[:-1]
+        if left['type'] == 'MemberExpression':
+            self.emit(left['object'])
+            if left['computed']:
+                self.emit(left['property'])
+                self.emit(right)
+                if operator:
+                    self.emit('STORE_MEMBER_OP', operator)
+                else:
+                    self.emit('STORE_MEMBER')
+            else:
+                self.emit(right)
+                if operator:
+                    self.emit('STORE_MEMBER_DOT_OP', left['property']['name'],
+                              operator)
+                else:
+                    self.emit('STORE_MEMBER_DOT', left['property']['name'])
+        elif left['type'] == 'Identifier':
+            if left['name'] in SPECIAL_IDENTIFIERS:
+                raise MakeError('SyntaxError',
+                                'Invalid left-hand side in assignment')
+            self.emit(right)
+            if operator:
+                self.emit('STORE_OP', left['name'], operator)
+            else:
+                self.emit('STORE', left['name'])
+        else:
+            raise MakeError('SyntaxError',
+                            'Invalid left-hand side in assignment')
+
+    def BinaryExpression(self, operator, left, right, **kwargs):
+        self.emit(left)
+        self.emit(right)
+        self.emit('BINARY_OP', operator)
+
+    def BlockStatement(self, body, **kwargs):
+        self._emit_statement_list(body)
+
+    def BreakStatement(self, label, **kwargs):
+        if label is None:
+            self.emit('JUMP', self.implicit_breaks[-1])
+        else:
+            label = label.get('name')
+            if label not in self.declared_break_labels:
+                raise MakeError('SyntaxError',
+                                'Undefined label \'%s\'' % label)
+            else:
+                self.emit('JUMP', self.declared_break_labels[label])
+
+    def CallExpression(self, callee, arguments, **kwargs):
+        if callee['type'] == 'MemberExpression':
+            self.emit(callee['object'])
+            if callee['computed']:
+                self.emit(callee['property'])
+                if arguments:
+                    for e in arguments:
+                        self.emit(e)
+                    self.emit('LOAD_N_TUPLE', len(arguments))
+                    self.emit('CALL_METHOD')
+                else:
+                    self.emit('CALL_METHOD_NO_ARGS')
+            else:
+                prop_name = to_key(callee['property'])
+                if arguments:
+                    for e in arguments:
+                        self.emit(e)
+                    self.emit('LOAD_N_TUPLE', len(arguments))
+                    self.emit('CALL_METHOD_DOT', prop_name)
+                else:
+                    self.emit('CALL_METHOD_DOT_NO_ARGS', prop_name)
+        else:
+            self.emit(callee)
+            if arguments:
+                for e in arguments:
+                    self.emit(e)
+                self.emit('LOAD_N_TUPLE', len(arguments))
+                self.emit('CALL')
+            else:
+                self.emit('CALL_NO_ARGS')
+
+    def ClassBody(self, body, **kwargs):
+        raise NotImplementedError('Not available in ECMA 5.1')
+
+    def ClassDeclaration(self, id, superClass, body, **kwargs):
+        raise NotImplementedError('Not available in ECMA 5.1')
+
+    def ClassExpression(self, id, superClass, body, **kwargs):
+        raise NotImplementedError('Classes not available in ECMA 5.1')
+
+    def ConditionalExpression(self, test, consequent, alternate, **kwargs):
+        alt = self.exe.get_new_label()
+        end = self.exe.get_new_label()
+        # ?
+        self.emit(test)
+        self.emit('JUMP_IF_FALSE', alt)
+        # first val
+        self.emit(consequent)
+        self.emit('JUMP', end)
+        # second val
+        self.emit('LABEL', alt)
+        self.emit(alternate)
+        # end of ?: statement
+        self.emit('LABEL', end)
+
+    def ContinueStatement(self, label, **kwargs):
+        if label is None:
+            self.emit('JUMP', self.implicit_continues[-1])
+        else:
+            label = label.get('name')
+            if label not in self.declared_continue_labels:
+                raise MakeError('SyntaxError',
+                                'Undefined label \'%s\'' % label)
+            else:
+                self.emit('JUMP', self.declared_continue_labels[label])
+
+    def DebuggerStatement(self, **kwargs):
+        self.EmptyStatement(**kwargs)
+
+    def DoWhileStatement(self, body, test, **kwargs):
+        continue_label = self.exe.get_new_label()
+        break_label = self.exe.get_new_label()
+        initial_do = self.exe.get_new_label()
+
+        self.emit('JUMP', initial_do)
+        self.emit('LABEL', continue_label)
+        self.emit(test)
+        self.emit('JUMP_IF_FALSE', break_label)
+        self.emit('LABEL', initial_do)
+
+        # translate the body, remember to add and afterwards remove implicit break/continue labels
+
+        self.implicit_continues.append(continue_label)
+        self.implicit_breaks.append(break_label)
+        self.emit(body)
+        self.implicit_continues.pop()
+        self.implicit_breaks.pop()
+
+        self.emit('JUMP', continue_label)  # loop back
+        self.emit('LABEL', break_label)
+
+    def EmptyStatement(self, **kwargs):
+        # do nothing
+        pass
+
+    def ExpressionStatement(self, expression, **kwargs):
+        # change the final stack value
+        # pop the previous value and execute expression
+        self.emit('POP')
+        self.emit(expression)
+
+    def ForStatement(self, init, test, update, body, **kwargs):
+        continue_label = self.exe.get_new_label()
+        break_label = self.exe.get_new_label()
+        first_start = self.exe.get_new_label()
+
+        if init is not None:
+            self.emit(init)
+            if init['type'] != 'VariableDeclaration':
+                self.emit('POP')
+
+        # skip first update and go straight to test
+        self.emit('JUMP', first_start)
+
+        self.emit('LABEL', continue_label)
+        if update:
+            self.emit(update)
+            self.emit('POP')
+        self.emit('LABEL', first_start)
+        if test:
+            self.emit(test)
+            self.emit('JUMP_IF_FALSE', break_label)
+
+        # translate the body, remember to add and afterwards to remove implicit break/continue labels
+
+        self.implicit_continues.append(continue_label)
+        self.implicit_breaks.append(break_label)
+        self.emit(body)
+        self.implicit_continues.pop()
+        self.implicit_breaks.pop()
+
+        self.emit('JUMP', continue_label)  # loop back
+        self.emit('LABEL', break_label)
+
+    def ForInStatement(self, left, right, body, **kwargs):
+        # prepare the needed labels
+        body_start_label = self.exe.get_new_label()
+        continue_label = self.exe.get_new_label()
+        break_label = self.exe.get_new_label()
+
+        # prepare the name
+        if left['type'] == 'VariableDeclaration':
+            if len(left['declarations']) != 1:
+                raise MakeError(
+                    'SyntaxError',
+                    ' Invalid left-hand side in for-in loop: Must have a single binding.'
+                )
+            self.emit(left)
+            name = left['declarations'][0]['id']['name']
+        elif left['type'] == 'Identifier':
+            name = left['name']
+        else:
+            raise MakeError('SyntaxError',
+                            'Invalid left-hand side in for-loop')
+
+        # prepare the iterable
+        self.emit(right)
+
+        # emit ForIn Opcode
+        self.emit('FOR_IN', name, body_start_label, continue_label,
+                  break_label)
+
+        # a special continue position
+        self.emit('LABEL', continue_label)
+        self.emit('NOP')
+
+        self.emit('LABEL', body_start_label)
+        self.implicit_continues.append(continue_label)
+        self.implicit_breaks.append(break_label)
+        self.emit('LOAD_UNDEFINED')
+        self.emit(body)
+        self.implicit_continues.pop()
+        self.implicit_breaks.pop()
+        self.emit('NOP')
+        self.emit('LABEL', break_label)
+        self.emit('NOP')
+
+    def FunctionDeclaration(self, id, params, defaults, body, **kwargs):
+        if defaults:
+            raise NotImplementedError('Defaults not available in ECMA 5.1')
+
+        # compile function
+        self.record_state(
+        )  # cleans translator state and appends it to the stack so that it can be later restored
+        function_start = self.exe.get_new_label()
+        function_declarations = self.exe.get_new_label()
+        declarations_done = self.exe.get_new_label(
+        )  # put jump to this place at the and of function tape!
+        function_end = self.exe.get_new_label()
+
+        # skip the function if encountered externally
+        self.emit('JUMP', function_end)
+
+        self.emit('LABEL', function_start)
+        # call is made with empty stack so load undefined to fill it
+        self.emit('LOAD_UNDEFINED')
+        # declare all functions
+        self.emit('JUMP', function_declarations)
+        self.emit('LABEL', declarations_done)
+        self.function_declaration_tape.append(LABEL(function_declarations))
+
+        self.emit(body)
+        self.ReturnStatement(None)
+
+        self.function_declaration_tape.append(JUMP(declarations_done))
+        self.exe.tape.extend(self.function_declaration_tape)
+
+        self.emit('LABEL', function_end)
+        declared_vars = self.declared_vars
+        self.restore_state()
+
+        # create function object and append to stack
+        name = id.get('name')
+        assert name is not None
+        self.declared_vars.append(name)
+        self.function_declaration_tape.append(
+            LOAD_FUNCTION(function_start, tuple(p['name'] for p in params),
+                          name, True, tuple(declared_vars)))
+        self.function_declaration_tape.append(STORE(name))
+        self.function_declaration_tape.append(POP())
+
+    def FunctionExpression(self, id, params, defaults, body, **kwargs):
+        if defaults:
+            raise NotImplementedError('Defaults not available in ECMA 5.1')
+
+        # compile function
+        self.record_state(
+        )  # cleans translator state and appends it to the stack so that it can be later restored
+        function_start = self.exe.get_new_label()
+        function_declarations = self.exe.get_new_label()
+        declarations_done = self.exe.get_new_label(
+        )  # put jump to this place at the and of function tape!
+        function_end = self.exe.get_new_label()
+
+        # skip the function if encountered externally
+        self.emit('JUMP', function_end)
+
+        self.emit('LABEL', function_start)
+        # call is made with empty stack so load undefined to fill it
+        self.emit('LOAD_UNDEFINED')
+        # declare all functions
+        self.emit('JUMP', function_declarations)
+        self.emit('LABEL', declarations_done)
+        self.function_declaration_tape.append(LABEL(function_declarations))
+
+        self.emit(body)
+        self.ReturnStatement(None)
+
+        self.function_declaration_tape.append(JUMP(declarations_done))
+        self.exe.tape.extend(self.function_declaration_tape)
+
+        self.emit('LABEL', function_end)
+        declared_vars = self.declared_vars
+        self.restore_state()
+
+        # create function object and append to stack
+        name = id.get('name') if id else None
+        self.emit('LOAD_FUNCTION', function_start,
+                  tuple(p['name'] for p in params), name, False,
+                  tuple(declared_vars))
+
+    def Identifier(self, name, **kwargs):
+        if name == 'true':
+            self.emit('LOAD_BOOLEAN', 1)
+        elif name == 'false':
+            self.emit('LOAD_BOOLEAN', 0)
+        elif name == 'undefined':
+            self.emit('LOAD_UNDEFINED')
+        else:
+            self.emit('LOAD', name)
+
+    def IfStatement(self, test, consequent, alternate, **kwargs):
+        alt = self.exe.get_new_label()
+        end = self.exe.get_new_label()
+        # if
+        self.emit(test)
+        self.emit('JUMP_IF_FALSE', alt)
+        # consequent
+        self.emit(consequent)
+        self.emit('JUMP', end)
+        # alternate
+        self.emit('LABEL', alt)
+        if alternate is not None:
+            self.emit(alternate)
+        # end of if statement
+        self.emit('LABEL', end)
+
+    def LabeledStatement(self, label, body, **kwargs):
+        label = label['name']
+        if body['type'] in ('WhileStatement', 'DoWhileStatement',
+                            'ForStatement', 'ForInStatement'):
+            # Continue label available... Simply take labels defined by the loop.
+            # It is important that they request continue label first
+            self.declared_continue_labels[label] = self.exe._label_count + 1
+            self.declared_break_labels[label] = self.exe._label_count + 2
+            self.emit(body)
+            del self.declared_break_labels[label]
+            del self.declared_continue_labels[label]
+        else:
+            # only break label available
+            lbl = self.exe.get_new_label()
+            self.declared_break_labels[label] = lbl
+            self.emit(body)
+            self.emit('LABEL', lbl)
+            del self.declared_break_labels[label]
+
+    def Literal(self, value, **kwargs):
+        if value is None:
+            self.emit('LOAD_NULL')
+        elif isinstance(value, bool):
+            self.emit('LOAD_BOOLEAN', int(value))
+        elif isinstance(value, basestring):
+            self.emit('LOAD_STRING', unicode(value))
+        elif isinstance(value, (float, int, long)):
+            self.emit('LOAD_NUMBER', float(value))
+        elif isinstance(value, tuple):
+            self.emit('LOAD_REGEXP', *value)
+        else:
+            raise RuntimeError('Unsupported literal')
+
+    def LogicalExpression(self, left, right, operator, **kwargs):
+        end = self.exe.get_new_label()
+        if operator == '&&':
+            # AND
+            self.emit(left)
+            self.emit('JUMP_IF_FALSE_WITHOUT_POP', end)
+            self.emit('POP')
+            self.emit(right)
+            self.emit('LABEL', end)
+        elif operator == '||':
+            # OR
+            self.emit(left)
+            self.emit('JUMP_IF_TRUE_WITHOUT_POP', end)
+            self.emit('POP')
+            self.emit(right)
+            self.emit('LABEL', end)
+        else:
+            raise RuntimeError("Unknown logical expression: %s" % operator)
+
+    def MemberExpression(self, computed, object, property, **kwargs):
+        if computed:
+            self.emit(object)
+            self.emit(property)
+            self.emit('LOAD_MEMBER')
+        else:
+            self.emit(object)
+            self.emit('LOAD_MEMBER_DOT', property['name'])
+
+    def NewExpression(self, callee, arguments, **kwargs):
+        self.emit(callee)
+        if arguments:
+            n = len(arguments)
+            for e in arguments:
+                self.emit(e)
+            self.emit('LOAD_N_TUPLE', n)
+            self.emit('NEW')
+        else:
+            self.emit('NEW_NO_ARGS')
+
+    def ObjectExpression(self, properties, **kwargs):
+        data = []
+        for prop in properties:
+            self.emit(prop['value'])
+            if prop['computed']:
+                raise NotImplementedError(
+                    'ECMA 5.1 does not support computed object properties!')
+            data.append((to_key(prop['key']), prop['kind'][0]))
+        self.emit('LOAD_OBJECT', tuple(data))
+
+    def Program(self, body, **kwargs):
+        old_tape_len = len(self.exe.tape)
+        self.emit('LOAD_UNDEFINED')
+        self.emit(body)
+        # add function tape !
+        self.exe.tape = self.exe.tape[:old_tape_len] + self.function_declaration_tape + self.exe.tape[old_tape_len:]
+
+    def Pyimport(self, imp, **kwargs):
+        raise NotImplementedError(
+            'Not available for bytecode interpreter yet, use the Js2Py translator.'
+        )
+
+    def Property(self, kind, key, computed, value, method, shorthand,
+                 **kwargs):
+        raise NotImplementedError('Not available in ECMA 5.1')
+
+    def RestElement(self, argument, **kwargs):
+        raise NotImplementedError('Not available in ECMA 5.1')
+
+    def ReturnStatement(self, argument, **kwargs):
+        self.emit('POP')  # pop result of expression statements
+        if argument is None:
+            self.emit('LOAD_UNDEFINED')
+        else:
+            self.emit(argument)
+        self.emit('RETURN')
+
+    def SequenceExpression(self, expressions, **kwargs):
+        for e in expressions:
+            self.emit(e)
+            self.emit('POP')
+        del self.exe.tape[-1]
+
+    def SwitchCase(self, test, consequent, **kwargs):
+        raise NotImplementedError('Already implemented in SwitchStatement')
+
+    def SwitchStatement(self, discriminant, cases, **kwargs):
+        self.emit(discriminant)
+        labels = [self.exe.get_new_label() for case in cases]
+        tests = [case['test'] for case in cases]
+        consequents = [case['consequent'] for case in cases]
+        end_of_switch = self.exe.get_new_label()
+
+        # translate test cases
+        for test, label in zip(tests, labels):
+            if test is not None:
+                self.emit(test)
+                self.emit('JUMP_IF_EQ', label)
+            else:
+                self.emit('POP')
+                self.emit('JUMP', label)
+        # this will be executed if none of the cases worked
+        self.emit('POP')
+        self.emit('JUMP', end_of_switch)
+
+        # translate consequents
+        self.implicit_breaks.append(end_of_switch)
+        for consequent, label in zip(consequents, labels):
+            self.emit('LABEL', label)
+            self._emit_statement_list(consequent)
+        self.implicit_breaks.pop()
+
+        self.emit('LABEL', end_of_switch)
+
+    def ThisExpression(self, **kwargs):
+        self.emit('LOAD_THIS')
+
+    def ThrowStatement(self, argument, **kwargs):
+        # throw with the empty stack
+        self.emit('POP')
+        self.emit(argument)
+        self.emit('THROW')
+
+    def TryStatement(self, block, handler, finalizer, **kwargs):
+        try_label = self.exe.get_new_label()
+        catch_label = self.exe.get_new_label()
+        finally_label = self.exe.get_new_label()
+        end_label = self.exe.get_new_label()
+
+        self.emit('JUMP', end_label)
+
+        # try block
+        self.emit('LABEL', try_label)
+        self.emit('LOAD_UNDEFINED')
+        self.emit(block)
+        self.emit(
+            'NOP'
+        )  # needed to distinguish from break/continue vs some internal jumps
+
+        # catch block
+        self.emit('LABEL', catch_label)
+        self.emit('LOAD_UNDEFINED')
+        if handler:
+            self.emit(handler['body'])
+        self.emit('NOP')
+
+        # finally block
+        self.emit('LABEL', finally_label)
+        self.emit('LOAD_UNDEFINED')
+        if finalizer:
+            self.emit(finalizer)
+        self.emit('NOP')
+
+        self.emit('LABEL', end_label)
+
+        # give life to the code
+        self.emit('TRY_CATCH_FINALLY', try_label, catch_label,
+                  handler['param']['name'] if handler else None, finally_label,
+                  bool(finalizer), end_label)
+
+    def UnaryExpression(self, operator, argument, **kwargs):
+        if operator == 'typeof' and argument[
+                'type'] == 'Identifier':  # todo fix typeof
+            self.emit('TYPEOF', argument['name'])
+        elif operator == 'delete':
+            if argument['type'] == 'MemberExpression':
+                self.emit(argument['object'])
+                if argument['property']['type'] == 'Identifier':
+                    self.emit('LOAD_STRING',
+                              unicode(argument['property']['name']))
+                else:
+                    self.emit(argument['property'])
+                self.emit('DELETE_MEMBER')
+            elif argument['type'] == 'Identifier':
+                self.emit('DELETE', argument['name'])
+            else:
+                self.emit('LOAD_BOOLEAN', 1)
+        elif operator in UNARY_OPERATIONS:
+            self.emit(argument)
+            self.emit('UNARY_OP', operator)
+        else:
+            raise MakeError('SyntaxError',
+                            'Unknown unary operator %s' % operator)
+
+    def UpdateExpression(self, operator, argument, prefix, **kwargs):
+        incr = int(operator == "++")
+        post = int(not prefix)
+        if argument['type'] == 'MemberExpression':
+            if argument['computed']:
+                self.emit(argument['object'])
+                self.emit(argument['property'])
+                self.emit('POSTFIX_MEMBER', post, incr)
+            else:
+                self.emit(argument['object'])
+                name = to_key(argument['property'])
+                self.emit('POSTFIX_MEMBER_DOT', post, incr, name)
+        elif argument['type'] == 'Identifier':
+            name = to_key(argument)
+            self.emit('POSTFIX', post, incr, name)
+        else:
+            raise MakeError('SyntaxError',
+                            'Invalid left-hand side in assignment')
+
+    def VariableDeclaration(self, declarations, kind, **kwargs):
+        if kind != 'var':
+            raise NotImplementedError(
+                'Only var variable declaration is supported by ECMA 5.1')
+        for d in declarations:
+            self.emit(d)
+
+    def LexicalDeclaration(self, declarations, kind, **kwargs):
+        raise NotImplementedError('Not supported by ECMA 5.1')
+
+    def VariableDeclarator(self, id, init, **kwargs):
+        name = id['name']
+        if name in SPECIAL_IDENTIFIERS:
+            raise MakeError('Invalid left-hand side in assignment')
+        self.declared_vars.append(name)
+        if init is not None:
+            self.emit(init)
+            self.emit('STORE', name)
+            self.emit('POP')
+
+    def WhileStatement(self, test, body, **kwargs):
+        continue_label = self.exe.get_new_label()
+        break_label = self.exe.get_new_label()
+
+        self.emit('LABEL', continue_label)
+        self.emit(test)
+        self.emit('JUMP_IF_FALSE', break_label)
+
+        # translate the body, remember to add and afterwards remove implicit break/continue labels
+
+        self.implicit_continues.append(continue_label)
+        self.implicit_breaks.append(break_label)
+        self.emit(body)
+        self.implicit_continues.pop()
+        self.implicit_breaks.pop()
+
+        self.emit('JUMP', continue_label)  # loop back
+        self.emit('LABEL', break_label)
+
+    def WithStatement(self, object, body, **kwargs):
+        beg_label = self.exe.get_new_label()
+        end_label = self.exe.get_new_label()
+        # scope
+        self.emit(object)
+
+        # now the body
+        self.emit('JUMP', end_label)
+        self.emit('LABEL', beg_label)
+        self.emit('LOAD_UNDEFINED')
+        self.emit(body)
+        self.emit('NOP')
+        self.emit('LABEL', end_label)
+
+        # with statement implementation
+        self.emit('WITH', beg_label, end_label)
+
+    def _emit_statement_list(self, statements):
+        for statement in statements:
+            self.emit(statement)
+
+    def emit(self, what, *args):
+        ''' what can be either name of the op, or node, or a list of statements.'''
+        if isinstance(what, basestring):
+            return self.exe.emit(what, *args)
+        elif isinstance(what, list):
+            self._emit_statement_list(what)
+        else:
+            return getattr(self, what['type'])(**what)
+
+
+import os, codecs
+
+
+def path_as_local(path):
+    if os.path.isabs(path):
+        return path
+    # relative to cwd
+    return os.path.join(os.getcwd(), path)
+
+
+def get_file_contents(path_or_file):
+    if hasattr(path_or_file, 'read'):
+        js = path_or_file.read()
+    else:
+        with codecs.open(path_as_local(path_or_file), "r", "utf-8") as f:
+            js = f.read()
+    return js
+
+
+def main():
+    from space import Space
+    import fill_space
+
+    from pyjsparser import parse
+    import json
+    a = ByteCodeGenerator(Code())
+
+    s = Space()
+    fill_space.fill_space(s, a)
+
+    a.exe.space = s
+    s.exe = a.exe
+    con = get_file_contents('internals/esprima.js')
+    d = parse(con + (
+        ''';JSON.stringify(exports.parse(%s), 4, 4)''' % json.dumps(con)))
+    # d = parse('''
+    # function x(n) {
+    #     log(n)
+    #     return x(n+1)
+    # }
+    # x(0)
+    # ''')
+
+    # var v = 333333;
+    # while (v) {
+    #     v--
+    #
+    # }
+    a.emit(d)
+    print(a.declared_vars)
+    print(a.exe.tape)
+    print(len(a.exe.tape))
+
+    a.exe.compile()
+
+    def log(this, args):
+        print(args[0])
+        return 999
+
+    print(a.exe.run(a.exe.space.GlobalObj))
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,227 @@
+from .opcodes import *
+from .space import *
+from .base import *
+
+
+class Code:
+    '''Can generate, store and run sequence of ops representing js code'''
+
+    def __init__(self, is_strict=False, debug_mode=False):
+        self.tape = []
+        self.compiled = False
+        self.label_locs = None
+        self.is_strict = is_strict
+        self.debug_mode = debug_mode
+
+        self.contexts = []
+        self.current_ctx = None
+        self.return_locs = []
+        self._label_count = 0
+        self.label_locs = None
+
+        # useful references
+        self.GLOBAL_THIS = None
+        self.space = None
+
+        # dbg
+        self.ctx_depth = 0
+
+
+    def get_new_label(self):
+        self._label_count += 1
+        return self._label_count
+
+    def emit(self, op_code, *args):
+        ''' Adds op_code with specified args to tape '''
+        self.tape.append(OP_CODES[op_code](*args))
+
+    def compile(self, start_loc=0):
+        ''' Records locations of labels and compiles the code '''
+        self.label_locs = {} if self.label_locs is None else self.label_locs
+        loc = start_loc
+        while loc < len(self.tape):
+            if type(self.tape[loc]) == LABEL:
+                self.label_locs[self.tape[loc].num] = loc
+                del self.tape[loc]
+                continue
+            loc += 1
+        self.compiled = True
+
+    def _call(self, func, this, args):
+        ''' Calls a bytecode function func
+            NOTE:  use !ONLY! when calling functions from native methods! '''
+        assert not func.is_native
+        # fake call - the the runner to return to the end of the file
+        old_contexts = self.contexts
+        old_return_locs = self.return_locs
+        old_curr_ctx = self.current_ctx
+
+        self.contexts = [FakeCtx()]
+        self.return_locs = [len(self.tape)]  # target line after return
+
+        # prepare my ctx
+        my_ctx = func._generate_my_context(this, args)
+        self.current_ctx = my_ctx
+
+        # execute dunction
+        ret = self.run(my_ctx, starting_loc=self.label_locs[func.code])
+
+        # bring back old execution
+        self.current_ctx = old_curr_ctx
+        self.contexts = old_contexts
+        self.return_locs = old_return_locs
+
+        return ret
+
+    def execute_fragment_under_context(self, ctx, start_label, end_label):
+        ''' just like run but returns if moved outside of the specified fragment
+            # 4 different exectution results
+            # 0=normal, 1=return, 2=jump_outside, 3=errors
+            # execute_fragment_under_context returns:
+            # (return_value, typ, return_value/jump_loc/py_error)
+            # IMPARTANT: It is guaranteed that the length of the ctx.stack is unchanged.
+        '''
+        old_curr_ctx = self.current_ctx
+        self.ctx_depth += 1
+        old_stack_len = len(ctx.stack)
+        old_ret_len = len(self.return_locs)
+        old_ctx_len = len(self.contexts)
+        try:
+            self.current_ctx = ctx
+            return self._execute_fragment_under_context(
+                ctx, start_label, end_label)
+        except JsException as err:
+            if self.debug_mode:
+                self._on_fragment_exit("js errors")
+            # undo the things that were put on the stack (if any) to ensure a proper error recovery
+            del ctx.stack[old_stack_len:]
+            del self.return_locs[old_ret_len:]
+            del self.contexts[old_ctx_len :]
+            return undefined, 3, err
+        finally:
+            self.ctx_depth -= 1
+            self.current_ctx = old_curr_ctx
+            assert old_stack_len == len(ctx.stack)
+
+    def _get_dbg_indent(self):
+        return self.ctx_depth * '  '
+
+    def _on_fragment_exit(self, mode):
+        print(self._get_dbg_indent() + 'ctx exit (%s)' % mode)
+
+    def _execute_fragment_under_context(self, ctx, start_label, end_label):
+        start, end = self.label_locs[start_label], self.label_locs[end_label]
+        initial_len = len(ctx.stack)
+        loc = start
+        entry_level = len(self.contexts)
+        # for e in self.tape[start:end]:
+        #     print e
+        if self.debug_mode:
+            print(self._get_dbg_indent() + 'ctx entry (from:%d, to:%d)' % (start, end))
+        while loc < len(self.tape):
+            if len(self.contexts) == entry_level and loc >= end:
+                if self.debug_mode:
+                    self._on_fragment_exit('normal')
+                assert loc == end
+                delta_stack = len(ctx.stack) - initial_len
+                assert delta_stack == +1, 'Stack change must be equal to +1! got %d' % delta_stack
+                return ctx.stack.pop(), 0, None  # means normal return
+
+            # execute instruction
+            if self.debug_mode:
+                print(self._get_dbg_indent() + str(loc), self.tape[loc])
+            status = self.tape[loc].eval(ctx)
+
+            # check status for special actions
+            if status is not None:
+                if type(status) == int:  # jump to label
+                    loc = self.label_locs[status]
+                    if len(self.contexts) == entry_level:
+                        # check if jumped outside of the fragment and break if so
+                        if not start <= loc < end:
+                            if self.debug_mode:
+                                self._on_fragment_exit('jump outside loc:%d label:%d' % (loc, status))
+                            delta_stack = len(ctx.stack) - initial_len
+                            assert delta_stack == +1, 'Stack change must be equal to +1! got %d' % delta_stack
+                            return ctx.stack.pop(), 2, status  # jump outside
+                    continue
+
+                elif len(status) == 2:  # a call or a return!
+                    # call: (new_ctx, func_loc_label_num)
+                    if status[0] is not None:
+                        # append old state to the stack
+                        self.contexts.append(ctx)
+                        self.return_locs.append(loc + 1)
+                        # set new state
+                        loc = self.label_locs[status[1]]
+                        ctx = status[0]
+                        self.current_ctx = ctx
+                        continue
+
+                    # return: (None, None)
+                    else:
+                        if len(self.contexts) == entry_level:
+                            if self.debug_mode:
+                                self._on_fragment_exit('return')
+                            delta_stack = len(ctx.stack) - initial_len
+                            assert delta_stack == +1, 'Stack change must be equal to +1! got %d' % delta_stack
+                            return undefined, 1, ctx.stack.pop(
+                            )  # return signal
+                        return_value = ctx.stack.pop()
+                        ctx = self.contexts.pop()
+                        self.current_ctx = ctx
+                        ctx.stack.append(return_value)
+
+                        loc = self.return_locs.pop()
+                        continue
+            # next instruction
+            loc += 1
+        if self.debug_mode:
+            self._on_fragment_exit('internal error - unexpected end of tape, will crash')
+        assert False, 'Remember to add NOP at the end!'
+
+    def run(self, ctx, starting_loc=0):
+        loc = starting_loc
+        self.current_ctx = ctx
+        while loc < len(self.tape):
+            # execute instruction
+            if self.debug_mode:
+                print(loc, self.tape[loc])
+            status = self.tape[loc].eval(ctx)
+
+            # check status for special actions
+            if status is not None:
+                if type(status) == int:  # jump to label
+                    loc = self.label_locs[status]
+                    continue
+
+                elif len(status) == 2:  # a call or a return!
+                    # call: (new_ctx, func_loc_label_num)
+                    if status[0] is not None:
+                        # append old state to the stack
+                        self.contexts.append(ctx)
+                        self.return_locs.append(loc + 1)
+                        # set new state
+                        loc = self.label_locs[status[1]]
+                        ctx = status[0]
+                        self.current_ctx = ctx
+                        continue
+
+                    # return: (None, None)
+                    else:
+                        return_value = ctx.stack.pop()
+                        ctx = self.contexts.pop()
+                        self.current_ctx = ctx
+                        ctx.stack.append(return_value)
+
+                        loc = self.return_locs.pop()
+                        continue
+            # next instruction
+            loc += 1
+        assert len(ctx.stack) == 1, ctx.stack
+        return ctx.stack.pop()
+
+
+class FakeCtx(object):
+    def __init__(self):
+        self.stack = []
@@ -0,0 +1 @@
+__author__ = 'Piotr Dabkowski'
@@ -0,0 +1,28 @@
+from ..conversions import *
+from ..func_utils import *
+
+
+def Array(this, args):
+    return ArrayConstructor(args, args.space)
+
+
+def ArrayConstructor(args, space):
+    if len(args) == 1:
+        l = get_arg(args, 0)
+        if type(l) == float:
+            if to_uint32(l) == l:
+                return space.NewArray(l)
+            else:
+                raise MakeError(
+                    'RangeError',
+                    'Invalid length specified for Array constructor (must be uint32)'
+                )
+        else:
+            return space.ConstructArray([l])
+    else:
+        return space.ConstructArray(list(args))
+
+
+def isArray(this, args):
+    x = get_arg(args, 0)
+    return is_object(x) and x.Class == u'Array'
@@ -0,0 +1,14 @@
+from ..conversions import *
+from ..func_utils import *
+
+
+def Boolean(this, args):
+    return to_boolean(get_arg(args, 0))
+
+
+def BooleanConstructor(args, space):
+    temp = space.NewObject()
+    temp.prototype = space.BooleanPrototype
+    temp.Class = 'Boolean'
+    temp.value = to_boolean(get_arg(args, 0))
+    return temp
@@ -0,0 +1,11 @@
+from __future__ import unicode_literals
+
+from js2py.internals.conversions import *
+from js2py.internals.func_utils import *
+
+
+class ConsoleMethods:
+    def log(this, args):
+        x = ' '.join(to_string(e) for e in args)
+        print(x)
+        return undefined
@@ -0,0 +1,405 @@
+from ..base import *
+from .time_helpers import *
+
+TZ_OFFSET = (time.altzone // 3600)
+ABS_OFFSET = abs(TZ_OFFSET)
+TZ_NAME = time.tzname[1]
+ISO_FORMAT = '%s-%s-%sT%s:%s:%s.%sZ'
+
+
+@Js
+def Date(year, month, date, hours, minutes, seconds, ms):
+    return now().to_string()
+
+
+Date.Class = 'Date'
+
+
+def now():
+    return PyJsDate(int(time.time() * 1000), prototype=DatePrototype)
+
+
+@Js
+def UTC(year, month, date, hours, minutes, seconds, ms):  # todo complete this
+    args = arguments
+    y = args[0].to_number()
+    m = args[1].to_number()
+    l = len(args)
+    dt = args[2].to_number() if l > 2 else Js(1)
+    h = args[3].to_number() if l > 3 else Js(0)
+    mi = args[4].to_number() if l > 4 else Js(0)
+    sec = args[5].to_number() if l > 5 else Js(0)
+    mili = args[6].to_number() if l > 6 else Js(0)
+    if not y.is_nan() and 0 <= y.value <= 99:
+        y = y + Js(1900)
+    t = TimeClip(MakeDate(MakeDay(y, m, dt), MakeTime(h, mi, sec, mili)))
+    return PyJsDate(t, prototype=DatePrototype)
+
+
+@Js
+def parse(string):
+    return PyJsDate(
+        TimeClip(parse_date(string.to_string().value)),
+        prototype=DatePrototype)
+
+
+Date.define_own_property('now', {
+    'value': Js(now),
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
+
+Date.define_own_property('parse', {
+    'value': parse,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
+
+Date.define_own_property('UTC', {
+    'value': UTC,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
+
+
+class PyJsDate(PyJs):
+    Class = 'Date'
+    extensible = True
+
+    def __init__(self, value, prototype=None):
+        self.value = value
+        self.own = {}
+        self.prototype = prototype
+
+    # todo fix this problematic datetime part
+    def to_local_dt(self):
+        return datetime.datetime.utcfromtimestamp(
+            UTCToLocal(self.value) // 1000)
+
+    def to_utc_dt(self):
+        return datetime.datetime.utcfromtimestamp(self.value // 1000)
+
+    def local_strftime(self, pattern):
+        if self.value is NaN:
+            return 'Invalid Date'
+        try:
+            dt = self.to_local_dt()
+        except:
+            raise MakeError(
+                'TypeError',
+                'unsupported date range. Will fix in future versions')
+        try:
+            return dt.strftime(pattern)
+        except:
+            raise MakeError(
+                'TypeError',
+                'Could not generate date string from this date (limitations of python.datetime)'
+            )
+
+    def utc_strftime(self, pattern):
+        if self.value is NaN:
+            return 'Invalid Date'
+        try:
+            dt = self.to_utc_dt()
+        except:
+            raise MakeError(
+                'TypeError',
+                'unsupported date range. Will fix in future versions')
+        try:
+            return dt.strftime(pattern)
+        except:
+            raise MakeError(
+                'TypeError',
+                'Could not generate date string from this date (limitations of python.datetime)'
+            )
+
+
+def parse_date(py_string):  # todo support all date string formats
+    try:
+        try:
+            dt = datetime.datetime.strptime(py_string, "%Y-%m-%dT%H:%M:%S.%fZ")
+        except:
+            dt = datetime.datetime.strptime(py_string, "%Y-%m-%dT%H:%M:%SZ")
+        return MakeDate(
+            MakeDay(Js(dt.year), Js(dt.month - 1), Js(dt.day)),
+            MakeTime(
+                Js(dt.hour), Js(dt.minute), Js(dt.second),
+                Js(dt.microsecond // 1000)))
+    except:
+        raise MakeError(
+            'TypeError',
+            'Could not parse date %s - unsupported date format. Currently only supported format is RFC3339 utc. Sorry!'
+            % py_string)
+
+
+def date_constructor(*args):
+    if len(args) >= 2:
+        return date_constructor2(*args)
+    elif len(args) == 1:
+        return date_constructor1(args[0])
+    else:
+        return date_constructor0()
+
+
+def date_constructor0():
+    return now()
+
+
+def date_constructor1(value):
+    v = value.to_primitive()
+    if v._type() == 'String':
+        v = parse_date(v.value)
+    else:
+        v = v.to_int()
+    return PyJsDate(TimeClip(v), prototype=DatePrototype)
+
+
+def date_constructor2(*args):
+    y = args[0].to_number()
+    m = args[1].to_number()
+    l = len(args)
+    dt = args[2].to_number() if l > 2 else Js(1)
+    h = args[3].to_number() if l > 3 else Js(0)
+    mi = args[4].to_number() if l > 4 else Js(0)
+    sec = args[5].to_number() if l > 5 else Js(0)
+    mili = args[6].to_number() if l > 6 else Js(0)
+    if not y.is_nan() and 0 <= y.value <= 99:
+        y = y + Js(1900)
+    t = TimeClip(
+        LocalToUTC(MakeDate(MakeDay(y, m, dt), MakeTime(h, mi, sec, mili))))
+    return PyJsDate(t, prototype=DatePrototype)
+
+
+Date.create = date_constructor
+
+DatePrototype = PyJsDate(float('nan'), prototype=ObjectPrototype)
+
+
+def check_date(obj):
+    if obj.Class != 'Date':
+        raise MakeError('TypeError', 'this is not a Date object')
+
+
+class DateProto:
+    def toString():
+        check_date(this)
+        if this.value is NaN:
+            return 'Invalid Date'
+        offset = (UTCToLocal(this.value) - this.value) // msPerHour
+        return this.local_strftime(
+            '%a %b %d %Y %H:%M:%S GMT') + '%s00 (%s)' % (pad(
+                offset, 2, True), GetTimeZoneName(this.value))
+
+    def toDateString():
+        check_date(this)
+        return this.local_strftime('%d %B %Y')
+
+    def toTimeString():
+        check_date(this)
+        return this.local_strftime('%H:%M:%S')
+
+    def toLocaleString():
+        check_date(this)
+        return this.local_strftime('%d %B %Y %H:%M:%S')
+
+    def toLocaleDateString():
+        check_date(this)
+        return this.local_strftime('%d %B %Y')
+
+    def toLocaleTimeString():
+        check_date(this)
+        return this.local_strftime('%H:%M:%S')
+
+    def valueOf():
+        check_date(this)
+        return this.value
+
+    def getTime():
+        check_date(this)
+        return this.value
+
+    def getFullYear():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return YearFromTime(UTCToLocal(this.value))
+
+    def getUTCFullYear():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return YearFromTime(this.value)
+
+    def getMonth():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return MonthFromTime(UTCToLocal(this.value))
+
+    def getDate():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return DateFromTime(UTCToLocal(this.value))
+
+    def getUTCMonth():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return MonthFromTime(this.value)
+
+    def getUTCDate():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return DateFromTime(this.value)
+
+    def getDay():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return WeekDay(UTCToLocal(this.value))
+
+    def getUTCDay():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return WeekDay(this.value)
+
+    def getHours():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return HourFromTime(UTCToLocal(this.value))
+
+    def getUTCHours():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return HourFromTime(this.value)
+
+    def getMinutes():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return MinFromTime(UTCToLocal(this.value))
+
+    def getUTCMinutes():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return MinFromTime(this.value)
+
+    def getSeconds():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return SecFromTime(UTCToLocal(this.value))
+
+    def getUTCSeconds():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return SecFromTime(this.value)
+
+    def getMilliseconds():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return msFromTime(UTCToLocal(this.value))
+
+    def getUTCMilliseconds():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return msFromTime(this.value)
+
+    def getTimezoneOffset():
+        check_date(this)
+        if this.value is NaN:
+            return NaN
+        return (this.value - UTCToLocal(this.value)) // 60000
+
+    def setTime(time):
+        check_date(this)
+        this.value = TimeClip(time.to_number().to_int())
+        return this.value
+
+    def setMilliseconds(ms):
+        check_date(this)
+        t = UTCToLocal(this.value)
+        tim = MakeTime(
+            HourFromTime(t), MinFromTime(t), SecFromTime(t), ms.to_int())
+        u = TimeClip(LocalToUTC(MakeDate(Day(t), tim)))
+        this.value = u
+        return u
+
+    def setUTCMilliseconds(ms):
+        check_date(this)
+        t = this.value
+        tim = MakeTime(
+            HourFromTime(t), MinFromTime(t), SecFromTime(t), ms.to_int())
+        u = TimeClip(MakeDate(Day(t), tim))
+        this.value = u
+        return u
+
+    # todo Complete all setters!
+
+    def toUTCString():
+        check_date(this)
+        return this.utc_strftime('%d %B %Y %H:%M:%S')
+
+    def toISOString():
+        check_date(this)
+        t = this.value
+        year = YearFromTime(t)
+        month, day, hour, minute, second, milli = pad(
+            MonthFromTime(t) + 1), pad(DateFromTime(t)), pad(
+                HourFromTime(t)), pad(MinFromTime(t)), pad(
+                    SecFromTime(t)), pad(msFromTime(t))
+        return ISO_FORMAT % (unicode(year) if 0 <= year <= 9999 else pad(
+            year, 6, True), month, day, hour, minute, second, milli)
+
+    def toJSON(key):
+        o = this.to_object()
+        tv = o.to_primitive('Number')
+        if tv.Class == 'Number' and not tv.is_finite():
+            return this.null
+        toISO = o.get('toISOString')
+        if not toISO.is_callable():
+            raise this.MakeError('TypeError', 'toISOString is not callable')
+        return toISO.call(o, ())
+
+
+def pad(num, n=2, sign=False):
+    '''returns n digit string representation of the num'''
+    s = unicode(abs(num))
+    if len(s) < n:
+        s = '0' * (n - len(s)) + s
+    if not sign:
+        return s
+    if num >= 0:
+        return '+' + s
+    else:
+        return '-' + s
+
+
+fill_prototype(DatePrototype, DateProto, default_attrs)
+
+Date.define_own_property(
+    'prototype', {
+        'value': DatePrototype,
+        'enumerable': False,
+        'writable': False,
+        'configurable': False
+    })
+
+DatePrototype.define_own_property('constructor', {
+    'value': Date,
+    'enumerable': False,
+    'writable': True,
+    'configurable': True
+})
@@ -0,0 +1,76 @@
+from ..base import *
+from ..conversions import *
+from ..func_utils import *
+from pyjsparser import parse
+from ..byte_trans import ByteCodeGenerator, Code
+
+
+def Function(this, args):
+    # convert arguments to python list of strings
+    a = map(to_string, tuple(args))
+    _body = u';'
+    _args = ()
+    if len(a):
+        _body = u'%s;' % a[-1]
+        _args = a[:-1]
+    return executable_function(_body, _args, args.space, global_context=True)
+
+
+def executable_function(_body, _args, space, global_context=True):
+    func_str = u'(function (%s) { ; %s ; });' % (u', '.join(_args), _body)
+
+    co = executable_code(
+        code_str=func_str, space=space, global_context=global_context)
+    return co()
+
+
+# you can use this one lovely piece of function to compile and execute code on the fly! Watch out though as it may generate lots of code.
+# todo tape cleanup? we dont know which pieces are needed and which are not so rather impossible without smarter machinery something like GC,
+# a one solution would be to have a separate tape for functions
+def executable_code(code_str, space, global_context=True):
+    # parse first to check if any SyntaxErrors
+    parsed = parse(code_str)
+
+    old_tape_len = len(space.byte_generator.exe.tape)
+    space.byte_generator.record_state()
+    start = space.byte_generator.exe.get_new_label()
+    skip = space.byte_generator.exe.get_new_label()
+    space.byte_generator.emit('JUMP', skip)
+    space.byte_generator.emit('LABEL', start)
+    space.byte_generator.emit(parsed)
+    space.byte_generator.emit('NOP')
+    space.byte_generator.emit('LABEL', skip)
+    space.byte_generator.emit('NOP')
+    space.byte_generator.restore_state()
+
+    space.byte_generator.exe.compile(
+        start_loc=old_tape_len
+    )  # dont read the code from the beginning, dont be stupid!
+
+    ctx = space.GlobalObj if global_context else space.exe.current_ctx
+
+    def ex_code():
+        ret, status, token = space.byte_generator.exe.execute_fragment_under_context(
+            ctx, start, skip)
+        # todo Clean up the tape!
+        # this is NOT a way to do that because the fragment may contain the executable code! We dont want to remove it
+        #del space.byte_generator.exe.tape[old_tape_len:]
+        if status == 0:
+            return ret
+        elif status == 3:
+            raise token
+        else:
+            raise RuntimeError(
+                'Unexpected return status during JIT execution: %d' % status)
+
+    return ex_code
+
+
+def _eval(this, args):
+    code_str = to_string(get_arg(args, 0))
+    return executable_code(code_str, args.space, global_context=True)()
+
+
+def log(this, args):
+    print(' '.join(map(to_string, args)))
+    return undefined
@@ -0,0 +1,157 @@
+from __future__ import unicode_literals
+
+from ..conversions import *
+from ..func_utils import *
+
+import math
+import random
+
+CONSTANTS = {
+    'E': 2.7182818284590452354,
+    'LN10': 2.302585092994046,
+    'LN2': 0.6931471805599453,
+    'LOG2E': 1.4426950408889634,
+    'LOG10E': 0.4342944819032518,
+    'PI': 3.1415926535897932,
+    'SQRT1_2': 0.7071067811865476,
+    'SQRT2': 1.4142135623730951
+}
+
+
+class MathFunctions:
+    def abs(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if a != a:  # it must be a nan
+            return NaN
+        return abs(a)
+
+    def acos(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if a != a:  # it must be a nan
+            return NaN
+        try:
+            return math.acos(a)
+        except:
+            return NaN
+
+    def asin(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if a != a:  # it must be a nan
+            return NaN
+        try:
+            return math.asin(a)
+        except:
+            return NaN
+
+    def atan(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if a != a:  # it must be a nan
+            return NaN
+        return math.atan(a)
+
+    def atan2(this, args):
+        x = get_arg(args, 0)
+        y = get_arg(args, 1)
+        a = to_number(x)
+        b = to_number(y)
+        if a != a or b != b:  # it must be a nan
+            return NaN
+        return math.atan2(a, b)
+
+    def ceil(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if a != a:  # it must be a nan
+            return NaN
+        return float(math.ceil(a))
+
+    def floor(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if a != a:  # it must be a nan
+            return NaN
+        return float(math.floor(a))
+
+    def round(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if a != a:  # it must be a nan
+            return NaN
+        return float(round(a))
+
+    def sin(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if not is_finite(a):  # it must be a nan
+            return NaN
+        return math.sin(a)
+
+    def cos(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if not is_finite(a):  # it must be a nan
+            return NaN
+        return math.cos(a)
+
+    def tan(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if not is_finite(a):  # it must be a nan
+            return NaN
+        return math.tan(a)
+
+    def log(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if a != a:  # it must be a nan
+            return NaN
+        try:
+            return math.log(a)
+        except:
+            return NaN
+
+    def exp(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if a != a:  # it must be a nan
+            return NaN
+        return math.exp(a)
+
+    def pow(this, args):
+        x = get_arg(args, 0)
+        y = get_arg(args, 1)
+        a = to_number(x)
+        b = to_number(y)
+        if a != a or b != b:  # it must be a nan
+            return NaN
+        try:
+            return a**b
+        except:
+            return NaN
+
+    def sqrt(this, args):
+        x = get_arg(args, 0)
+        a = to_number(x)
+        if a != a:  # it must be a nan
+            return NaN
+        try:
+            return a**0.5
+        except:
+            return NaN
+
+    def min(this, args):
+        if len(args) == 0:
+            return Infinity
+        return min(map(to_number, tuple(args)))
+
+    def max(this, args):
+        if len(args) == 0:
+            return -Infinity
+        return max(map(to_number, tuple(args)))
+
+    def random(this, args):
+        return random.random()
@@ -0,0 +1,27 @@
+from __future__ import unicode_literals
+
+from ..conversions import *
+from ..func_utils import *
+
+
+def Number(this, args):
+    if len(args) == 0:
+        return 0.
+    return to_number(args[0])
+
+
+def NumberConstructor(args, space):
+    temp = space.NewObject()
+    temp.prototype = space.NumberPrototype
+    temp.Class = 'Number'
+    temp.value = float(to_number(get_arg(args, 0)) if len(args) > 0 else 0.)
+    return temp
+
+
+CONSTS = {
+    'MAX_VALUE': 1.7976931348623157e308,
+    'MIN_VALUE': 5.0e-324,
+    'NaN': NaN,
+    'NEGATIVE_INFINITY': Infinity,
+    'POSITIVE_INFINITY': -Infinity
+}
@@ -0,0 +1,204 @@
+from __future__ import unicode_literals
+from ..conversions import *
+from ..func_utils import *
+from ..base import is_data_descriptor
+import six
+
+
+def Object(this, args):
+    val = get_arg(args, 0)
+    if is_null(val) or is_undefined(val):
+        return args.space.NewObject()
+    return to_object(val, args.space)
+
+
+def ObjectCreate(args, space):
+    if len(args):
+        val = get_arg(args, 0)
+        if is_object(val):
+            #  Implementation dependent, but my will simply return :)
+            return val
+        elif type(val) in (NUMBER_TYPE, STRING_TYPE, BOOLEAN_TYPE):
+            return to_object(val, space)
+    return space.NewObject()
+
+
+class ObjectMethods:
+    def getPrototypeOf(this, args):
+        obj = get_arg(args, 0)
+        if not is_object(obj):
+            raise MakeError('TypeError',
+                            'Object.getPrototypeOf called on non-object')
+        return null if obj.prototype is None else obj.prototype
+
+    def getOwnPropertyDescriptor(this, args):
+        obj = get_arg(args, 0)
+        prop = get_arg(args, 1)
+        if not is_object(obj):
+            raise MakeError(
+                'TypeError',
+                'Object.getOwnPropertyDescriptor called on non-object')
+        desc = obj.own.get(to_string(prop))
+        return convert_to_js_type(desc, args.space)
+
+    def getOwnPropertyNames(this, args):
+        obj = get_arg(args, 0)
+        if not is_object(obj):
+            raise MakeError(
+                'TypeError',
+                'Object.getOwnPropertyDescriptor called on non-object')
+        return args.space.ConstructArray(obj.own.keys())
+
+    def create(this, args):
+        obj = get_arg(args, 0)
+        if not (is_object(obj) or is_null(obj)):
+            raise MakeError('TypeError',
+                            'Object prototype may only be an Object or null')
+        temp = args.space.NewObject()
+        temp.prototype = None if is_null(obj) else obj
+        if len(args) > 1 and not is_undefined(args[1]):
+            if six.PY2:
+                args.tup = (args[1], )
+                ObjectMethods.defineProperties.__func__(temp, args)
+            else:
+                args.tup = (args[1], )
+                ObjectMethods.defineProperties(temp, args)
+        return temp
+
+    def defineProperty(this, args):
+        obj = get_arg(args, 0)
+        prop = get_arg(args, 1)
+        attrs = get_arg(args, 2)
+        if not is_object(obj):
+            raise MakeError('TypeError',
+                            'Object.defineProperty called on non-object')
+        name = to_string(prop)
+        if not obj.define_own_property(name, ToPropertyDescriptor(attrs),
+                                       False):
+            raise MakeError('TypeError', 'Cannot redefine property: %s' % name)
+        return obj
+
+    def defineProperties(this, args):
+        obj = get_arg(args, 0)
+        properties = get_arg(args, 1)
+        if not is_object(obj):
+            raise MakeError('TypeError',
+                            'Object.defineProperties called on non-object')
+        props = to_object(properties, args.space)
+        for k, v in props.own.items():
+            if not v.get('enumerable'):
+                continue
+            desc = ToPropertyDescriptor(props.get(unicode(k)))
+            if not obj.define_own_property(unicode(k), desc, False):
+                raise MakeError('TypeError',
+                                'Failed to define own property: %s' % k)
+        return obj
+
+    def seal(this, args):
+        obj = get_arg(args, 0)
+        if not is_object(obj):
+            raise MakeError('TypeError', 'Object.seal called on non-object')
+        for desc in obj.own.values():
+            desc['configurable'] = False
+        obj.extensible = False
+        return obj
+
+    def freeze(this, args):
+        obj = get_arg(args, 0)
+        if not is_object(obj):
+            raise MakeError('TypeError', 'Object.freeze called on non-object')
+        for desc in obj.own.values():
+            desc['configurable'] = False
+            if is_data_descriptor(desc):
+                desc['writable'] = False
+        obj.extensible = False
+        return obj
+
+    def preventExtensions(this, args):
+        obj = get_arg(args, 0)
+        if not is_object(obj):
+            raise MakeError('TypeError',
+                            'Object.preventExtensions on non-object')
+        obj.extensible = False
+        return obj
+
+    def isSealed(this, args):
+        obj = get_arg(args, 0)
+        if not is_object(obj):
+            raise MakeError('TypeError',
+                            'Object.isSealed called on non-object')
+        if obj.extensible:
+            return False
+        for desc in obj.own.values():
+            if desc.get('configurable'):
+                return False
+        return True
+
+    def isFrozen(this, args):
+        obj = get_arg(args, 0)
+        if not is_object(obj):
+            raise MakeError('TypeError',
+                            'Object.isFrozen called on non-object')
+        if obj.extensible:
+            return False
+        for desc in obj.own.values():
+            if desc.get('configurable'):
+                return False
+            if is_data_descriptor(desc) and desc.get('writable'):
+                return False
+        return True
+
+    def isExtensible(this, args):
+        obj = get_arg(args, 0)
+        if not is_object(obj):
+            raise MakeError('TypeError',
+                            'Object.isExtensible called on non-object')
+        return obj.extensible
+
+    def keys(this, args):
+        obj = get_arg(args, 0)
+        if not is_object(obj):
+            raise MakeError('TypeError', 'Object.keys called on non-object')
+        return args.space.ConstructArray([
+            unicode(e) for e, d in six.iteritems(obj.own)
+            if d.get('enumerable')
+        ])
+
+
+# some utility functions:
+
+
+def ToPropertyDescriptor(obj):  # page 38 (50 absolute)
+    if not is_object(obj):
+        raise MakeError('TypeError',
+                        'Can\'t convert non-object to property descriptor')
+    desc = {}
+    if obj.has_property('enumerable'):
+        desc['enumerable'] = to_boolean(obj.get('enumerable'))
+    if obj.has_property('configurable'):
+        desc['configurable'] = to_boolean(obj.get('configurable'))
+    if obj.has_property('value'):
+        desc['value'] = obj.get('value')
+    if obj.has_property('writable'):
+        desc['writable'] = to_boolean(obj.get('writable'))
+    if obj.has_property('get'):
+        cand = obj.get('get')
+        if not (is_undefined(cand) or is_callable(cand)):
+            raise MakeError(
+                'TypeError',
+                'Invalid getter (it has to be a function or undefined)')
+        desc['get'] = cand
+    if obj.has_property('set'):
+        cand = obj.get('set')
+        if not (is_undefined(cand) or is_callable(cand)):
+            raise MakeError(
+                'TypeError',
+                'Invalid setter (it has to be a function or undefined)')
+        desc['set'] = cand
+    if ('get' in desc or 'set' in desc) and ('value' in desc
+                                             or 'writable' in desc):
+        raise MakeError(
+            'TypeError',
+            'Invalid property.  A property cannot both have accessors and be writable or have a value.'
+        )
+    return desc
@@ -0,0 +1,41 @@
+from __future__ import unicode_literals
+from ..conversions import *
+from ..func_utils import *
+from ..base import SpaceTuple
+
+REG_EXP_FLAGS = ('g', 'i', 'm')
+
+
+def RegExp(this, args):
+    pattern = get_arg(args, 0)
+    flags = get_arg(args, 1)
+    if GetClass(pattern) == 'RegExp':
+        if not is_undefined(flags):
+            raise MakeError(
+                'TypeError',
+                'Cannot supply flags when constructing one RegExp from another'
+            )
+        # return unchanged
+        return pattern
+    #pattern is not a regexp
+    if is_undefined(pattern):
+        pattern = u''
+    else:
+        pattern = to_string(pattern)
+    flags = to_string(flags) if not is_undefined(flags) else u''
+    for flag in flags:
+        if flag not in REG_EXP_FLAGS:
+            raise MakeError(
+                'SyntaxError',
+                'Invalid flags supplied to RegExp constructor "%s"' % flag)
+    if len(set(flags)) != len(flags):
+        raise MakeError(
+            'SyntaxError',
+            'Invalid flags supplied to RegExp constructor "%s"' % flags)
+    return args.space.NewRegExp(pattern, flags)
+
+
+def RegExpCreate(args, space):
+    _args = SpaceTuple(args)
+    _args.space = space
+    return RegExp(undefined, _args)
@@ -0,0 +1,23 @@
+from ..conversions import *
+from ..func_utils import *
+
+
+def fromCharCode(this, args):
+    res = u''
+    for e in args:
+        res += unichr(to_uint16(e))
+    return res
+
+
+def String(this, args):
+    if len(args) == 0:
+        return u''
+    return to_string(args[0])
+
+
+def StringConstructor(args, space):
+    temp = space.NewObject()
+    temp.prototype = space.StringPrototype
+    temp.Class = 'String'
+    temp.value = to_string(get_arg(args, 0)) if len(args) > 0 else u''
+    return temp
@@ -0,0 +1,209 @@
+from __future__ import unicode_literals
+
+# NOTE: t must be INT!!!
+import time
+import datetime
+import warnings
+
+try:
+    from tzlocal import get_localzone
+    LOCAL_ZONE = get_localzone()
+except:  # except all problems...
+    warnings.warn(
+        'Please install or fix tzlocal library (pip install tzlocal) in order to make Date object work better. Otherwise I will assume DST is in effect all the time'
+    )
+
+    class LOCAL_ZONE:
+        @staticmethod
+        def dst(*args):
+            return 1
+
+
+from js2py.base import MakeError
+CUM = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365)
+msPerDay = 86400000
+msPerYear = int(86400000 * 365.242)
+msPerSecond = 1000
+msPerMinute = 60000
+msPerHour = 3600000
+HoursPerDay = 24
+MinutesPerHour = 60
+SecondsPerMinute = 60
+NaN = float('nan')
+LocalTZA = -time.timezone * msPerSecond
+
+
+def DaylightSavingTA(t):
+    if t is NaN:
+        return t
+    try:
+        return int(
+            LOCAL_ZONE.dst(datetime.datetime.utcfromtimestamp(
+                t // 1000)).seconds) * 1000
+    except:
+        warnings.warn(
+            'Invalid datetime date, assumed DST time, may be inaccurate...',
+            Warning)
+        return 1
+        #raise MakeError('TypeError', 'date not supported by python.datetime. I will solve it in future versions')
+
+
+def GetTimeZoneName(t):
+    return time.tzname[DaylightSavingTA(t) > 0]
+
+
+def LocalToUTC(t):
+    return t - LocalTZA - DaylightSavingTA(t - LocalTZA)
+
+
+def UTCToLocal(t):
+    return t + LocalTZA + DaylightSavingTA(t)
+
+
+def Day(t):
+    return t // 86400000
+
+
+def TimeWithinDay(t):
+    return t % 86400000
+
+
+def DaysInYear(y):
+    if y % 4:
+        return 365
+    elif y % 100:
+        return 366
+    elif y % 400:
+        return 365
+    else:
+        return 366
+
+
+def DayFromYear(y):
+    return 365 * (y - 1970) + (y - 1969) // 4 - (y - 1901) // 100 + (
+        y - 1601) // 400
+
+
+def TimeFromYear(y):
+    return 86400000 * DayFromYear(y)
+
+
+def YearFromTime(t):
+    guess = 1970 - t // 31556908800  # msPerYear
+    gt = TimeFromYear(guess)
+    if gt <= t:
+        while gt <= t:
+            guess += 1
+            gt = TimeFromYear(guess)
+        return guess - 1
+    else:
+        while gt > t:
+            guess -= 1
+            gt = TimeFromYear(guess)
+        return guess
+
+
+def DayWithinYear(t):
+    return Day(t) - DayFromYear(YearFromTime(t))
+
+
+def InLeapYear(t):
+    y = YearFromTime(t)
+    if y % 4:
+        return 0
+    elif y % 100:
+        return 1
+    elif y % 400:
+        return 0
+    else:
+        return 1
+
+
+def MonthFromTime(t):
+    day = DayWithinYear(t)
+    leap = InLeapYear(t)
+    if day < 31:
+        return 0
+    day -= leap
+    if day < 59:
+        return 1
+    elif day < 90:
+        return 2
+    elif day < 120:
+        return 3
+    elif day < 151:
+        return 4
+    elif day < 181:
+        return 5
+    elif day < 212:
+        return 6
+    elif day < 243:
+        return 7
+    elif day < 273:
+        return 8
+    elif day < 304:
+        return 9
+    elif day < 334:
+        return 10
+    else:
+        return 11
+
+
+def DateFromTime(t):
+    mon = MonthFromTime(t)
+    day = DayWithinYear(t)
+    return day - CUM[mon] - (1 if InLeapYear(t) and mon >= 2 else 0) + 1
+
+
+def WeekDay(t):
+    # 0 == sunday
+    return (Day(t) + 4) % 7
+
+
+def msFromTime(t):
+    return t % 1000
+
+
+def SecFromTime(t):
+    return (t // 1000) % 60
+
+
+def MinFromTime(t):
+    return (t // 60000) % 60
+
+
+def HourFromTime(t):
+    return (t // 3600000) % 24
+
+
+def MakeTime(hour, Min, sec, ms):
+    # takes PyJs objects and returns t
+    if not (hour.is_finite() and Min.is_finite() and sec.is_finite()
+            and ms.is_finite()):
+        return NaN
+    h, m, s, milli = hour.to_int(), Min.to_int(), sec.to_int(), ms.to_int()
+    return h * 3600000 + m * 60000 + s * 1000 + milli
+
+
+def MakeDay(year, month, date):
+    # takes PyJs objects and returns t
+    if not (year.is_finite() and month.is_finite() and date.is_finite()):
+        return NaN
+    y, m, dt = year.to_int(), month.to_int(), date.to_int()
+    y += m // 12
+    mn = m % 12
+    d = DayFromYear(y) + CUM[mn] + dt - 1 + (1 if DaysInYear(y) == 366
+                                             and mn >= 2 else 0)
+    return d  # ms per day
+
+
+def MakeDate(day, time):
+    return 86400000 * day + time
+
+
+def TimeClip(t):
+    if t != t or abs(t) == float('inf'):
+        return NaN
+    if abs(t) > 8.64 * 10**15:
+        return NaN
+    return int(t)
@@ -0,0 +1,141 @@
+from __future__ import unicode_literals
+# Type Conversions. to_type. All must return PyJs subclass instance
+from .simplex import *
+
+
+def to_primitive(self, hint=None):
+    if is_primitive(self):
+        return self
+    if hint is None and (self.Class == 'Number' or self.Class == 'Boolean'):
+        # favour number for Class== Number or Boolean default = String
+        hint = 'Number'
+    return self.default_value(hint)
+
+
+def to_boolean(self):
+    typ = Type(self)
+    if typ == 'Boolean':  # no need to convert
+        return self
+    elif typ == 'Null' or typ == 'Undefined':  # they are both always false
+        return False
+    elif typ == 'Number':  # false only for 0, and NaN
+        return self and self == self  # test for nan (nan -> flase)
+    elif typ == 'String':
+        return bool(self)
+    else:  # object -  always True
+        return True
+
+
+def to_number(self):
+    typ = Type(self)
+    if typ == 'Number':  # or self.Class=='Number':   # no need to convert
+        return self
+    elif typ == 'Null':  # null is 0
+        return 0.
+    elif typ == 'Undefined':  # undefined is NaN
+        return NaN
+    elif typ == 'Boolean':  # 1 for True 0 for false
+        return float(self)
+    elif typ == 'String':
+        s = self.strip()  # Strip white space
+        if not s:  # '' is simply 0
+            return 0.
+        if 'x' in s or 'X' in s[:3]:  # hex (positive only)
+            try:  # try to convert
+                num = int(s, 16)
+            except ValueError:  # could not convert -> NaN
+                return NaN
+            return float(num)
+        sign = 1  # get sign
+        if s[0] in '+-':
+            if s[0] == '-':
+                sign = -1
+            s = s[1:]
+        if s == 'Infinity':  # Check for infinity keyword. 'NaN' will be NaN anyway.
+            return sign * Infinity
+        try:  # decimal try
+            num = sign * float(s)  # Converted
+        except ValueError:
+            return NaN  # could not convert to decimal  > return NaN
+        return float(num)
+    else:  # object -  most likely it will be NaN.
+        return to_number(to_primitive(self, 'Number'))
+
+
+def to_string(self):
+    typ = Type(self)
+    if typ == 'String':
+        return self
+    elif typ == 'Null':
+        return 'null'
+    elif typ == 'Undefined':
+        return 'undefined'
+    elif typ == 'Boolean':
+        return 'true' if self else 'false'
+    elif typ == 'Number':  # or self.Class=='Number':
+        return js_dtoa(self)
+    else:  # object
+        return to_string(to_primitive(self, 'String'))
+
+
+def to_object(self, space):
+    typ = Type(self)
+    if typ == 'Object':
+        return self
+    elif typ == 'Boolean':  # Unsure ... todo check here
+        return space.Boolean.create((self, ), space)
+    elif typ == 'Number':  # ?
+        return space.Number.create((self, ), space)
+    elif typ == 'String':  # ?
+        return space.String.create((self, ), space)
+    elif typ == 'Null' or typ == 'Undefined':
+        raise MakeError('TypeError',
+                        'undefined or null can\'t be converted to object')
+    else:
+        raise RuntimeError()
+
+
+def to_int32(self):
+    num = to_number(self)
+    if is_nan(num) or is_infinity(num):
+        return 0
+    int32 = int(num) % 2**32
+    return int(int32 - 2**32 if int32 >= 2**31 else int32)
+
+
+def to_int(self):
+    num = to_number(self)
+    if is_nan(num):
+        return 0
+    elif is_infinity(num):
+        return 10**20 if num > 0 else -10**20
+    return int(num)
+
+
+def to_uint32(self):
+    num = to_number(self)
+    if is_nan(num) or is_infinity(num):
+        return 0
+    return int(num) % 2**32
+
+
+def to_uint16(self):
+    num = to_number(self)
+    if is_nan(num) or is_infinity(num):
+        return 0
+    return int(num) % 2**16
+
+
+def to_int16(self):
+    num = to_number(self)
+    if is_nan(num) or is_infinity(num):
+        return 0
+    int16 = int(num) % 2**16
+    return int(int16 - 2**16 if int16 >= 2**15 else int16)
+
+
+def cok(self):
+    """Check object coercible"""
+    if type(self) in (UNDEFINED_TYPE, NULL_TYPE):
+        raise MakeError('TypeError',
+                        'undefined or null can\'t be converted to object')
@@ -0,0 +1,90 @@
+# todo make sure what they mean by desc undefined? None or empty? Answer: None :) it can never be empty but None is sometimes returned.
+
+# I am implementing everything as dicts to speed up property creation
+
+# Warning: value, get, set props of dest are PyJs types. Rest is Py!
+
+
+def is_data_descriptor(desc):
+    return desc and ('value' in desc or 'writable' in desc)
+
+
+def is_accessor_descriptor(desc):
+    return desc and ('get' in desc or 'set' in desc)
+
+
+def is_generic_descriptor(
+        desc
+):  # generic means not the data and not the setter - therefore it must be one that changes only enum and conf
+    return desc and not (is_data_descriptor(desc)
+                         or is_accessor_descriptor(desc))
+
+
+def from_property_descriptor(desc, space):
+    if not desc:
+        return {}
+    obj = space.NewObject()
+    if is_data_descriptor(desc):
+        obj.define_own_property(
+            'value', {
+                'value': desc['value'],
+                'writable': True,
+                'enumerable': True,
+                'configurable': True
+            }, False)
+        obj.define_own_property(
+            'writable', {
+                'value': desc['writable'],
+                'writable': True,
+                'enumerable': True,
+                'configurable': True
+            }, False)
+    else:
+        obj.define_own_property(
+            'get', {
+                'value': desc['get'],
+                'writable': True,
+                'enumerable': True,
+                'configurable': True
+            }, False)
+        obj.define_own_property(
+            'set', {
+                'value': desc['set'],
+                'writable': True,
+                'enumerable': True,
+                'configurable': True
+            }, False)
+    obj.define_own_property(
+        'writable', {
+            'value': desc['writable'],
+            'writable': True,
+            'enumerable': True,
+            'configurable': True
+        }, False)
+    obj.define_own_property(
+        'enumerable', {
+            'value': desc['enumerable'],
+            'writable': True,
+            'enumerable': True,
+            'configurable': True
+        }, False)
+    return obj
+
+
+def to_property_descriptor(obj):
+    if obj._type() != 'Object':
+        raise TypeError()
+    desc = {}
+    for e in ('enumerable', 'configurable', 'writable'):
+        if obj.has_property(e):
+            desc[e] = obj.get(e).to_boolean().value
+    if obj.has_property('value'):
+        desc['value'] = obj.get('value')
+    for e in ('get', 'set'):
+        if obj.has_property(e):
+            cand = obj.get(e)
+            if not (cand.is_callable() or cand.is_undefined()):
+                raise TypeError()
+    if ('get' in desc or 'set' in desc) and ('value' in desc
+                                             or 'writable' in desc):
+        raise TypeError()
@@ -0,0 +1,281 @@
+from __future__ import unicode_literals
+
+from .base import Scope
+from .func_utils import *
+from .conversions import *
+import six
+from .prototypes.jsboolean import BooleanPrototype
+from .prototypes.jserror import ErrorPrototype
+from .prototypes.jsfunction import FunctionPrototype
+from .prototypes.jsnumber import NumberPrototype
+from .prototypes.jsobject import ObjectPrototype
+from .prototypes.jsregexp import RegExpPrototype
+from .prototypes.jsstring import StringPrototype
+from .prototypes.jsarray import ArrayPrototype
+from .prototypes import jsjson
+from .prototypes import jsutils
+
+from .constructors import jsnumber, jsstring, jsarray, jsboolean, jsregexp, jsmath, jsobject, jsfunction, jsconsole
+
+
+
+def fill_proto(proto, proto_class, space):
+    for i in dir(proto_class):
+        e = getattr(proto_class, i)
+        if six.PY2:
+            if hasattr(e, '__func__'):
+                meth = e.__func__
+            else:
+                continue
+        else:
+            if hasattr(e, '__call__') and not i.startswith('__'):
+                meth = e
+            else:
+                continue
+        meth_name = meth.__name__.strip('_')  # RexExp._exec -> RegExp.exec
+        js_meth = space.NewFunction(meth, space.ctx, (), meth_name, False, ())
+        set_non_enumerable(proto, meth_name, js_meth)
+    return proto
+
+
+def easy_func(f, space):
+    return space.NewFunction(f, space.ctx, (), f.__name__, False, ())
+
+
+def Empty(this, args):
+    return undefined
+
+
+def set_non_enumerable(obj, name, prop):
+    obj.define_own_property(
+        unicode(name), {
+            'value': prop,
+            'writable': True,
+            'enumerable': False,
+            'configurable': True
+        }, True)
+
+
+def set_protected(obj, name, prop):
+    obj.define_own_property(
+        unicode(name), {
+            'value': prop,
+            'writable': False,
+            'enumerable': False,
+            'configurable': False
+        }, True)
+
+
+def fill_space(space, byte_generator):
+    # set global scope
+    global_scope = Scope({}, space, parent=None)
+    global_scope.THIS_BINDING = global_scope
+    global_scope.registers(byte_generator.declared_vars)
+    space.GlobalObj = global_scope
+
+    space.byte_generator = byte_generator
+
+    # first init all protos, later take care of constructors and details
+
+    # Function must be first obviously, we have to use a small trick to do that...
+    function_proto = space.NewFunction(Empty, space.ctx, (), 'Empty', False,
+                                       ())
+    space.FunctionPrototype = function_proto  # this will fill the prototypes of the methods!
+    fill_proto(function_proto, FunctionPrototype, space)
+
+    # Object next
+    object_proto = space.NewObject()  # no proto
+    fill_proto(object_proto, ObjectPrototype, space)
+    space.ObjectPrototype = object_proto
+    function_proto.prototype = object_proto
+
+    # Number
+    number_proto = space.NewObject()
+    number_proto.prototype = object_proto
+    fill_proto(number_proto, NumberPrototype, space)
+    number_proto.value = 0.
+    number_proto.Class = 'Number'
+    space.NumberPrototype = number_proto
+
+    # String
+    string_proto = space.NewObject()
+    string_proto.prototype = object_proto
+    fill_proto(string_proto, StringPrototype, space)
+    string_proto.value = u''
+    string_proto.Class = 'String'
+    space.StringPrototype = string_proto
+
+    # Boolean
+    boolean_proto = space.NewObject()
+    boolean_proto.prototype = object_proto
+    fill_proto(boolean_proto, BooleanPrototype, space)
+    boolean_proto.value = False
+    boolean_proto.Class = 'Boolean'
+    space.BooleanPrototype = boolean_proto
+
+    # Array
+    array_proto = space.NewArray(0)
+    array_proto.prototype = object_proto
+    fill_proto(array_proto, ArrayPrototype, space)
+    space.ArrayPrototype = array_proto
+
+    # JSON
+    json = space.NewObject()
+    json.put(u'stringify', easy_func(jsjson.stringify, space))
+    json.put(u'parse', easy_func(jsjson.parse, space))
+
+    # Utils
+    parseFloat = easy_func(jsutils.parseFloat, space)
+    parseInt = easy_func(jsutils.parseInt, space)
+    isNaN = easy_func(jsutils.isNaN, space)
+    isFinite = easy_func(jsutils.isFinite, space)
+
+    # Error
+    error_proto = space.NewError(u'Error', u'')
+    error_proto.prototype = object_proto
+    error_proto.put(u'name', u'Error')
+    fill_proto(error_proto, ErrorPrototype, space)
+    space.ErrorPrototype = error_proto
+
+    def construct_constructor(typ):
+        def creator(this, args):
+            message = get_arg(args, 0)
+            if not is_undefined(message):
+                msg = to_string(message)
+            else:
+                msg = u''
+            return space.NewError(typ, msg)
+
+        j = easy_func(creator, space)
+        j.name = unicode(typ)
+
+        set_protected(j, 'prototype', space.ERROR_TYPES[typ])
+
+        set_non_enumerable(space.ERROR_TYPES[typ], 'constructor', j)
+
+        def new_create(args, space):
+            message = get_arg(args, 0)
+            if not is_undefined(message):
+                msg = to_string(message)
+            else:
+                msg = u''
+            return space.NewError(typ, msg)
+
+        j.create = new_create
+        return j
+
+    # fill remaining error types
+    error_constructors = {}
+    for err_type_name in (u'Error', u'EvalError', u'RangeError',
+                          u'ReferenceError', u'SyntaxError', u'TypeError',
+                          u'URIError'):
+        extra_err = space.NewError(u'Error', u'')
+        extra_err.put(u'name', err_type_name)
+        setattr(space, err_type_name + u'Prototype', extra_err)
+        error_constructors[err_type_name] = construct_constructor(
+            err_type_name)
+
+    assert space.TypeErrorPrototype is not None
+
+    # RegExp
+    regexp_proto = space.NewRegExp(u'(?:)', u'')
+    regexp_proto.prototype = object_proto
+    fill_proto(regexp_proto, RegExpPrototype, space)
+    space.RegExpPrototype = regexp_proto
+
+    # Json
+
+    # now all these boring constructors...
+
+    # Number
+    number = easy_func(jsnumber.Number, space)
+    space.Number = number
+    number.create = jsnumber.NumberConstructor
+    set_non_enumerable(number_proto, 'constructor', number)
+    set_protected(number, 'prototype', number_proto)
+    # number has some extra constants
+    for k, v in jsnumber.CONSTS.items():
+        set_protected(number, k, v)
+
+    # String
+    string = easy_func(jsstring.String, space)
+    space.String = string
+    string.create = jsstring.StringConstructor
+    set_non_enumerable(string_proto, 'constructor', string)
+    set_protected(string, 'prototype', string_proto)
+    # string has an extra function
+    set_non_enumerable(string, 'fromCharCode',
+                       easy_func(jsstring.fromCharCode, space))
+
+    # Boolean
+    boolean = easy_func(jsboolean.Boolean, space)
+    space.Boolean = boolean
+    boolean.create = jsboolean.BooleanConstructor
+    set_non_enumerable(boolean_proto, 'constructor', boolean)
+    set_protected(boolean, 'prototype', boolean_proto)
+
+    # Array
+    array = easy_func(jsarray.Array, space)
+    space.Array = array
+    array.create = jsarray.ArrayConstructor
+    set_non_enumerable(array_proto, 'constructor', array)
+    set_protected(array, 'prototype', array_proto)
+    array.put(u'isArray', easy_func(jsarray.isArray, space))
+
+    # RegExp
+    regexp = easy_func(jsregexp.RegExp, space)
+    space.RegExp = regexp
+    regexp.create = jsregexp.RegExpCreate
+    set_non_enumerable(regexp_proto, 'constructor', regexp)
+    set_protected(regexp, 'prototype', regexp_proto)
+
+    # Object
+    _object = easy_func(jsobject.Object, space)
+    space.Object = _object
+    _object.create = jsobject.ObjectCreate
+    set_non_enumerable(object_proto, 'constructor', _object)
+    set_protected(_object, 'prototype', object_proto)
+    fill_proto(_object, jsobject.ObjectMethods, space)
+
+    # Function
+    function = easy_func(jsfunction.Function, space)
+    space.Function = function
+
+    # Math
+    math = space.NewObject()
+    math.Class = 'Math'
+    fill_proto(math, jsmath.MathFunctions, space)
+    for k, v in jsmath.CONSTANTS.items():
+        set_protected(math, k, v)
+
+    console = space.NewObject()
+    fill_proto(console, jsconsole.ConsoleMethods, space)
+
+    # set global object
+    builtins = {
+        'String': string,
+        'Number': number,
+        'Boolean': boolean,
+        'RegExp': regexp,
+        'exports': convert_to_js_type({}, space),
+        'Math': math,
+        #'Date',
+        'Object': _object,
+        'Function': function,
+        'JSON': json,
+        'Array': array,
+        'parseFloat': parseFloat,
+        'parseInt': parseInt,
+        'isFinite': isFinite,
+        'isNaN': isNaN,
+        'eval': easy_func(jsfunction._eval, space),
+        'console': console,
+        'log': console.get(u'log'),
+    }
+
+    builtins.update(error_constructors)
+
+    set_protected(global_scope, 'NaN', NaN)
+    set_protected(global_scope, 'Infinity', Infinity)
+    for k, v in builtins.items():
+        set_non_enumerable(global_scope, k, v)
@@ -0,0 +1,73 @@
+from .simplex import *
+from .conversions import *
+
+import six
+if six.PY3:
+    basestring = str
+    long = int
+    xrange = range
+    unicode = str
+
+
+def get_arg(arguments, n):
+    if len(arguments) <= n:
+        return undefined
+    return arguments[n]
+
+
+def ensure_js_types(args, space=None):
+    return tuple(convert_to_js_type(e, space=space) for e in args)
+
+
+def convert_to_js_type(e, space=None):
+    t = type(e)
+    if is_js_type(e):
+        return e
+    if t in (int, long, float):
+        return float(e)
+    elif isinstance(t, basestring):
+        return unicode(t)
+    elif t in (list, tuple):
+        if space is None:
+            raise MakeError(
+                'TypeError',
+                'Actually an internal error, could not convert to js type because space not specified'
+            )
+        return space.ConstructArray(ensure_js_types(e, space=space))
+    elif t == dict:
+        if space is None:
+            raise MakeError(
+                'TypeError',
+                'Actually an internal error, could not convert to js type because space not specified'
+            )
+        new = {}
+        for k, v in e.items():
+            new[to_string(convert_to_js_type(k, space))] = convert_to_js_type(
+                v, space)
+        return space.ConstructObject(new)
+    else:
+        raise MakeError('TypeError', 'Could not convert to js type!')
+
+
+def is_js_type(e):
+    if type(e) in PRIMITIVES:
+        return True
+    elif hasattr(e, 'Class') and hasattr(e, 'value'):  # not perfect but works
+        return True
+    else:
+        return False
+
+
+# todo optimise these 2!
+def js_array_to_tuple(arr):
+    length = to_uint32(arr.get(u'length'))
+    return tuple(arr.get(unicode(e)) for e in xrange(length))
+
+
+def js_array_to_list(arr):
+    length = to_uint32(arr.get(u'length'))
+    return [arr.get(unicode(e)) for e in xrange(length)]
+
+
+def js_arr_length(arr):
+    return to_uint32(arr.get(u'length'))
@@ -0,0 +1,805 @@
+from .operations import *
+from .base import get_member, get_member_dot, PyJsFunction, Scope
+
+
+class OP_CODE(object):
+    _params = []
+
+    # def eval(self, ctx):
+    #     raise
+
+    def __repr__(self):
+        return self.__class__.__name__ + str(
+            tuple([getattr(self, e) for e in self._params]))
+
+
+# --------------------- UNARY ----------------------
+
+
+class UNARY_OP(OP_CODE):
+    _params = ['operator']
+
+    def __init__(self, operator):
+        self.operator = operator
+
+    def eval(self, ctx):
+        val = ctx.stack.pop()
+        ctx.stack.append(UNARY_OPERATIONS[self.operator](val))
+
+
+# special unary operations
+
+
+class TYPEOF(OP_CODE):
+    _params = ['identifier']
+
+    def __init__(self, identifier):
+        self.identifier = identifier
+
+    def eval(self, ctx):
+        # typeof something_undefined  does not throw reference error
+        val = ctx.get(self.identifier,
+                      False)  # <= this makes it slightly different!
+        ctx.stack.append(typeof_uop(val))
+
+
+class POSTFIX(OP_CODE):
+    _params = ['cb', 'ca', 'identifier']
+
+    def __init__(self, post, incr, identifier):
+        self.identifier = identifier
+        self.cb = 1 if incr else -1
+        self.ca = -self.cb if post else 0
+
+    def eval(self, ctx):
+        target = to_number(ctx.get(self.identifier)) + self.cb
+        ctx.put(self.identifier, target)
+        ctx.stack.append(target + self.ca)
+
+
+class POSTFIX_MEMBER(OP_CODE):
+    _params = ['cb', 'ca']
+
+    def __init__(self, post, incr):
+        self.cb = 1 if incr else -1
+        self.ca = -self.cb if post else 0
+
+    def eval(self, ctx):
+        name = ctx.stack.pop()
+        left = ctx.stack.pop()
+
+        target = to_number(get_member(left, name, ctx.space)) + self.cb
+        if type(left) not in PRIMITIVES:
+            left.put_member(name, target)
+
+        ctx.stack.append(target + self.ca)
+
+
+class POSTFIX_MEMBER_DOT(OP_CODE):
+    _params = ['cb', 'ca', 'prop']
+
+    def __init__(self, post, incr, prop):
+        self.cb = 1 if incr else -1
+        self.ca = -self.cb if post else 0
+        self.prop = prop
+
+    def eval(self, ctx):
+        left = ctx.stack.pop()
+
+        target = to_number(get_member_dot(left, self.prop,
+                                          ctx.space)) + self.cb
+        if type(left) not in PRIMITIVES:
+            left.put(self.prop, target)
+
+        ctx.stack.append(target + self.ca)
+
+
+class DELETE(OP_CODE):
+    _params = ['name']
+
+    def __init__(self, name):
+        self.name = name
+
+    def eval(self, ctx):
+        ctx.stack.append(ctx.delete(self.name))
+
+
+class DELETE_MEMBER(OP_CODE):
+    def eval(self, ctx):
+        prop = to_string(ctx.stack.pop())
+        obj = to_object(ctx.stack.pop(), ctx)
+        ctx.stack.append(obj.delete(prop, False))
+
+
+# --------------------- BITWISE ----------------------
+
+
+class BINARY_OP(OP_CODE):
+    _params = ['operator']
+
+    def __init__(self, operator):
+        self.operator = operator
+
+    def eval(self, ctx):
+        right = ctx.stack.pop()
+        left = ctx.stack.pop()
+        ctx.stack.append(BINARY_OPERATIONS[self.operator](left, right))
+
+
+# &&, || and conditional are implemented in bytecode
+
+# --------------------- JUMPS ----------------------
+
+
+# simple label that will be removed from code after compilation. labels ID will be translated
+# to source code position.
+class LABEL(OP_CODE):
+    _params = ['num']
+
+    def __init__(self, num):
+        self.num = num
+
+
+# I implemented interpreter in the way that when an integer is returned by eval operation the execution will jump
+# to the location of the label (it is loc = label_locations[label])
+
+
+class BASE_JUMP(OP_CODE):
+    _params = ['label']
+
+    def __init__(self, label):
+        self.label = label
+
+
+class JUMP(BASE_JUMP):
+    def eval(self, ctx):
+        return self.label
+
+
+class JUMP_IF_TRUE(BASE_JUMP):
+    def eval(self, ctx):
+        val = ctx.stack.pop()
+        if to_boolean(val):
+            return self.label
+
+
+class JUMP_IF_EQ(BASE_JUMP):
+    # this one is used in switch statement - compares last 2 values using === operator and jumps popping both if true else pops last.
+    def eval(self, ctx):
+        cmp = ctx.stack.pop()
+        if strict_equality_op(ctx.stack[-1], cmp):
+            ctx.stack.pop()
+            return self.label
+
+
+class JUMP_IF_TRUE_WITHOUT_POP(BASE_JUMP):
+    def eval(self, ctx):
+        val = ctx.stack[-1]
+        if to_boolean(val):
+            return self.label
+
+
+class JUMP_IF_FALSE(BASE_JUMP):
+    def eval(self, ctx):
+        val = ctx.stack.pop()
+        if not to_boolean(val):
+            return self.label
+
+
+class JUMP_IF_FALSE_WITHOUT_POP(BASE_JUMP):
+    def eval(self, ctx):
+        val = ctx.stack[-1]
+        if not to_boolean(val):
+            return self.label
+
+
+class POP(OP_CODE):
+    def eval(self, ctx):
+        # todo remove this check later
+        assert len(ctx.stack), 'Popped from empty stack!'
+        del ctx.stack[-1]
+
+
+# class REDUCE(OP_CODE):
+#     def eval(self, ctx):
+#         assert len(ctx.stack)==2
+#         ctx.stack[0] = ctx.stack[1]
+#         del ctx.stack[1]
+
+# --------------- LOADING --------------
+
+
+class LOAD_NONE(OP_CODE):  # be careful with this :)
+    _params = []
+
+    def eval(self, ctx):
+        ctx.stack.append(None)
+
+
+class LOAD_N_TUPLE(
+        OP_CODE
+):  # loads the tuple composed of n last elements on stack. elements are popped.
+    _params = ['n']
+
+    def __init__(self, n):
+        self.n = n
+
+    def eval(self, ctx):
+        tup = tuple(ctx.stack[-self.n:])
+        del ctx.stack[-self.n:]
+        ctx.stack.append(tup)
+
+
+class LOAD_UNDEFINED(OP_CODE):
+    def eval(self, ctx):
+        ctx.stack.append(undefined)
+
+
+class LOAD_NULL(OP_CODE):
+    def eval(self, ctx):
+        ctx.stack.append(null)
+
+
+class LOAD_BOOLEAN(OP_CODE):
+    _params = ['val']
+
+    def __init__(self, val):
+        assert val in (0, 1)
+        self.val = bool(val)
+
+    def eval(self, ctx):
+        ctx.stack.append(self.val)
+
+
+class LOAD_STRING(OP_CODE):
+    _params = ['val']
+
+    def __init__(self, val):
+        assert isinstance(val, basestring)
+        self.val = unicode(val)
+
+    def eval(self, ctx):
+        ctx.stack.append(self.val)
+
+
+class LOAD_NUMBER(OP_CODE):
+    _params = ['val']
+
+    def __init__(self, val):
+        assert isinstance(val, (float, int, long))
+        self.val = float(val)
+
+    def eval(self, ctx):
+        ctx.stack.append(self.val)
+
+
+class LOAD_REGEXP(OP_CODE):
+    _params = ['body', 'flags']
+
+    def __init__(self, body, flags):
+        self.body = body
+        self.flags = flags
+
+    def eval(self, ctx):
+        # we have to generate a new regexp - they are mutable
+        ctx.stack.append(ctx.space.NewRegExp(self.body, self.flags))
+
+
+class LOAD_FUNCTION(OP_CODE):
+    _params = ['start', 'params', 'name', 'is_declaration', 'definitions']
+
+    def __init__(self, start, params, name, is_declaration, definitions):
+        assert type(start) == int
+        self.start = start  # its an ID of label pointing to the beginning of the function bytecode
+        self.params = params
+        self.name = name
+        self.is_declaration = bool(is_declaration)
+        self.definitions = tuple(set(definitions + params))
+
+    def eval(self, ctx):
+        ctx.stack.append(
+            ctx.space.NewFunction(self.start, ctx, self.params, self.name,
+                                  self.is_declaration, self.definitions))
+
+
+class LOAD_OBJECT(OP_CODE):
+    _params = [
+        'props'
+    ]  # props are py string pairs (prop_name, kind): kind can be either i, g or s. (init, get, set)
+
+    def __init__(self, props):
+        self.num = len(props)
+        self.props = props
+
+    def eval(self, ctx):
+        obj = ctx.space.NewObject()
+        if self.num:
+            obj._init(self.props, ctx.stack[-self.num:])
+            del ctx.stack[-self.num:]
+
+        ctx.stack.append(obj)
+
+
+class LOAD_ARRAY(OP_CODE):
+    _params = ['num']
+
+    def __init__(self, num):
+        self.num = num
+
+    def eval(self, ctx):
+        arr = ctx.space.NewArray(self.num)
+        if self.num:
+            arr._init(ctx.stack[-self.num:])
+            del ctx.stack[-self.num:]
+        ctx.stack.append(arr)
+
+
+class LOAD_THIS(OP_CODE):
+    def eval(self, ctx):
+        ctx.stack.append(ctx.THIS_BINDING)
+
+
+class LOAD(OP_CODE):  # todo check!
+    _params = ['identifier']
+
+    def __init__(self, identifier):
+        self.identifier = identifier
+
+    # 11.1.2
+    def eval(self, ctx):
+        ctx.stack.append(ctx.get(self.identifier, throw=True))
+
+
+class LOAD_MEMBER(OP_CODE):
+    def eval(self, ctx):
+        prop = ctx.stack.pop()
+        obj = ctx.stack.pop()
+        ctx.stack.append(get_member(obj, prop, ctx.space))
+
+
+class LOAD_MEMBER_DOT(OP_CODE):
+    _params = ['prop']
+
+    def __init__(self, prop):
+        self.prop = prop
+
+    def eval(self, ctx):
+        obj = ctx.stack.pop()
+        ctx.stack.append(get_member_dot(obj, self.prop, ctx.space))
+
+
+# --------------- STORING --------------
+
+
+class STORE(OP_CODE):
+    _params = ['identifier']
+
+    def __init__(self, identifier):
+        self.identifier = identifier
+
+    def eval(self, ctx):
+        value = ctx.stack[-1]  # don't pop
+        ctx.put(self.identifier, value)
+
+
+class STORE_MEMBER(OP_CODE):
+    def eval(self, ctx):
+        value = ctx.stack.pop()
+        name = ctx.stack.pop()
+        left = ctx.stack.pop()
+
+        typ = type(left)
+        if typ in PRIMITIVES:
+            prop = to_string(name)
+            if typ == NULL_TYPE:
+                raise MakeError('TypeError',
+                                "Cannot set property '%s' of null" % prop)
+            elif typ == UNDEFINED_TYPE:
+                raise MakeError('TypeError',
+                                "Cannot set property '%s' of undefined" % prop)
+            # just ignore...
+        else:
+            left.put_member(name, value)
+
+        ctx.stack.append(value)
+
+
+class STORE_MEMBER_DOT(OP_CODE):
+    _params = ['prop']
+
+    def __init__(self, prop):
+        self.prop = prop
+
+    def eval(self, ctx):
+        value = ctx.stack.pop()
+        left = ctx.stack.pop()
+
+        typ = type(left)
+        if typ in PRIMITIVES:
+            if typ == NULL_TYPE:
+                raise MakeError('TypeError',
+                                "Cannot set property '%s' of null" % self.prop)
+            elif typ == UNDEFINED_TYPE:
+                raise MakeError(
+                    'TypeError',
+                    "Cannot set property '%s' of undefined" % self.prop)
+            # just ignore...
+        else:
+            left.put(self.prop, value)
+        ctx.stack.append(value)
+
+
+class STORE_OP(OP_CODE):
+    _params = ['identifier', 'op']
+
+    def __init__(self, identifier, op):
+        self.identifier = identifier
+        self.op = op
+
+    def eval(self, ctx):
+        value = ctx.stack.pop()
+        new_value = BINARY_OPERATIONS[self.op](ctx.get(self.identifier), value)
+        ctx.put(self.identifier, new_value)
+        ctx.stack.append(new_value)
+
+
+class STORE_MEMBER_OP(OP_CODE):
+    _params = ['op']
+
+    def __init__(self, op):
+        self.op = op
+
+    def eval(self, ctx):
+        value = ctx.stack.pop()
+        name = ctx.stack.pop()
+        left = ctx.stack.pop()
+
+        typ = type(left)
+        if typ in PRIMITIVES:
+            if typ is NULL_TYPE:
+                raise MakeError(
+                    'TypeError',
+                    "Cannot set property '%s' of null" % to_string(name))
+            elif typ is UNDEFINED_TYPE:
+                raise MakeError(
+                    'TypeError',
+                    "Cannot set property '%s' of undefined" % to_string(name))
+            ctx.stack.append(BINARY_OPERATIONS[self.op](get_member(
+                left, name, ctx.space), value))
+            return
+        else:
+            ctx.stack.append(BINARY_OPERATIONS[self.op](get_member(
+                left, name, ctx.space), value))
+            left.put_member(name, ctx.stack[-1])
+
+
+class STORE_MEMBER_DOT_OP(OP_CODE):
+    _params = ['prop', 'op']
+
+    def __init__(self, prop, op):
+        self.prop = prop
+        self.op = op
+
+    def eval(self, ctx):
+        value = ctx.stack.pop()
+        left = ctx.stack.pop()
+
+        typ = type(left)
+        if typ in PRIMITIVES:
+            if typ == NULL_TYPE:
+                raise MakeError('TypeError',
+                                "Cannot set property '%s' of null" % self.prop)
+            elif typ == UNDEFINED_TYPE:
+                raise MakeError(
+                    'TypeError',
+                    "Cannot set property '%s' of undefined" % self.prop)
+            ctx.stack.append(BINARY_OPERATIONS[self.op](get_member_dot(
+                left, self.prop, ctx.space), value))
+            return
+        else:
+            ctx.stack.append(BINARY_OPERATIONS[self.op](get_member_dot(
+                left, self.prop, ctx.space), value))
+            left.put(self.prop, ctx.stack[-1])
+
+
+# --------------- CALLS --------------
+
+
+def bytecode_call(ctx, func, this, args):
+    if type(func) is not PyJsFunction:
+        raise MakeError('TypeError', "%s is not a function" % Type(func))
+    if func.is_native:  # call to built-in function or method
+        ctx.stack.append(func.call(this, args))
+        return None
+
+    # therefore not native. we have to return (new_context, function_label) to instruct interpreter to call
+    return func._generate_my_context(this, args), func.code
+
+
+class CALL(OP_CODE):
+    def eval(self, ctx):
+        args = ctx.stack.pop()
+        func = ctx.stack.pop()
+
+        return bytecode_call(ctx, func, ctx.space.GlobalObj, args)
+
+
+class CALL_METHOD(OP_CODE):
+    def eval(self, ctx):
+        args = ctx.stack.pop()
+        prop = ctx.stack.pop()
+        base = ctx.stack.pop()
+
+        func = get_member(base, prop, ctx.space)
+
+        return bytecode_call(ctx, func, base, args)
+
+
+class CALL_METHOD_DOT(OP_CODE):
+    _params = ['prop']
+
+    def __init__(self, prop):
+        self.prop = prop
+
+    def eval(self, ctx):
+        args = ctx.stack.pop()
+        base = ctx.stack.pop()
+
+        func = get_member_dot(base, self.prop, ctx.space)
+
+        return bytecode_call(ctx, func, base, args)
+
+
+class CALL_NO_ARGS(OP_CODE):
+    def eval(self, ctx):
+        func = ctx.stack.pop()
+
+        return bytecode_call(ctx, func, ctx.space.GlobalObj, ())
+
+
+class CALL_METHOD_NO_ARGS(OP_CODE):
+    def eval(self, ctx):
+        prop = ctx.stack.pop()
+        base = ctx.stack.pop()
+
+        func = get_member(base, prop, ctx.space)
+
+        return bytecode_call(ctx, func, base, ())
+
+
+class CALL_METHOD_DOT_NO_ARGS(OP_CODE):
+    _params = ['prop']
+
+    def __init__(self, prop):
+        self.prop = prop
+
+    def eval(self, ctx):
+        base = ctx.stack.pop()
+
+        func = get_member_dot(base, self.prop, ctx.space)
+
+        return bytecode_call(ctx, func, base, ())
+
+
+class NOP(OP_CODE):
+    def eval(self, ctx):
+        pass
+
+
+class RETURN(OP_CODE):
+    def eval(
+            self, ctx
+    ):  # remember to load the return value on stack before using RETURN op.
+        return (None, None)
+
+
+class NEW(OP_CODE):
+    def eval(self, ctx):
+        args = ctx.stack.pop()
+        constructor = ctx.stack.pop()
+        if type(constructor) in PRIMITIVES or not hasattr(
+                constructor, 'create'):
+            raise MakeError('TypeError',
+                            '%s is not a constructor' % Type(constructor))
+        ctx.stack.append(constructor.create(args, space=ctx.space))
+
+
+class NEW_NO_ARGS(OP_CODE):
+    def eval(self, ctx):
+        constructor = ctx.stack.pop()
+        if type(constructor) in PRIMITIVES or not hasattr(
+                constructor, 'create'):
+            raise MakeError('TypeError',
+                            '%s is not a constructor' % Type(constructor))
+        ctx.stack.append(constructor.create((), space=ctx.space))
+
+
+# --------------- EXCEPTIONS --------------
+
+
+class THROW(OP_CODE):
+    def eval(self, ctx):
+        raise MakeError(None, None, ctx.stack.pop())
+
+
+class TRY_CATCH_FINALLY(OP_CODE):
+    _params = [
+        'try_label', 'catch_label', 'catch_variable', 'finally_label',
+        'finally_present', 'end_label'
+    ]
+
+    def __init__(self, try_label, catch_label, catch_variable, finally_label,
+                 finally_present, end_label):
+        self.try_label = try_label
+        self.catch_label = catch_label
+        self.catch_variable = catch_variable
+        self.finally_label = finally_label
+        self.finally_present = finally_present
+        self.end_label = end_label
+
+    def eval(self, ctx):
+        # 4 different exectution results
+        # 0=normal, 1=return, 2=jump_outside, 3=errors
+        # execute_fragment_under_context returns:
+        # (return_value, typ, jump_loc/error)
+
+        ctx.stack.pop()
+
+        # execute try statement
+        try_status = ctx.space.exe.execute_fragment_under_context(
+            ctx, self.try_label, self.catch_label)
+
+        errors = try_status[1] == 3
+
+        # catch
+        if errors and self.catch_variable is not None:
+            # generate catch block context...
+            catch_context = Scope({
+                self.catch_variable:
+                try_status[2].get_thrown_value(ctx.space)
+            }, ctx.space, ctx)
+            catch_context.THIS_BINDING = ctx.THIS_BINDING
+            catch_status = ctx.space.exe.execute_fragment_under_context(
+                catch_context, self.catch_label, self.finally_label)
+        else:
+            catch_status = None
+
+        # finally
+        if self.finally_present:
+            finally_status = ctx.space.exe.execute_fragment_under_context(
+                ctx, self.finally_label, self.end_label)
+        else:
+            finally_status = None
+
+        # now return controls
+        other_status = catch_status or try_status
+        if finally_status is None or (finally_status[1] == 0
+                                      and other_status[1] != 0):
+            winning_status = other_status
+        else:
+            winning_status = finally_status
+
+        val, typ, spec = winning_status
+        if typ == 0:  # normal
+            ctx.stack.append(val)
+            return
+        elif typ == 1:  # return
+            ctx.stack.append(spec)
+            return None, None  # send return signal
+        elif typ == 2:  # jump outside
+            ctx.stack.append(val)
+            return spec
+        elif typ == 3:
+            # throw is made with empty stack as usual
+            raise spec
+        else:
+            raise RuntimeError('Invalid return code')
+
+
+# ------------ WITH + ITERATORS ----------
+
+
+class WITH(OP_CODE):
+    _params = ['beg_label', 'end_label']
+
+    def __init__(self, beg_label, end_label):
+        self.beg_label = beg_label
+        self.end_label = end_label
+
+    def eval(self, ctx):
+        obj = to_object(ctx.stack.pop(), ctx.space)
+
+        with_context = Scope(
+            obj, ctx.space, ctx)  # todo actually use the obj to modify the ctx
+        with_context.THIS_BINDING = ctx.THIS_BINDING
+        status = ctx.space.exe.execute_fragment_under_context(
+            with_context, self.beg_label, self.end_label)
+
+        val, typ, spec = status
+
+        if typ != 3:  # exception
+            ctx.stack.pop()
+
+        if typ == 0:  # normal
+            ctx.stack.append(val)
+            return
+        elif typ == 1:  # return
+            ctx.stack.append(spec)
+            return None, None  # send return signal
+        elif typ == 2:  # jump outside
+            ctx.stack.append(val)
+            return spec
+        elif typ == 3:  # exception
+            # throw is made with empty stack as usual
+            raise spec
+        else:
+            raise RuntimeError('Invalid return code')
+
+
+class FOR_IN(OP_CODE):
+    _params = ['name', 'body_start_label', 'continue_label', 'break_label']
+
+    def __init__(self, name, body_start_label, continue_label, break_label):
+        self.name = name
+        self.body_start_label = body_start_label
+        self.continue_label = continue_label
+        self.break_label = break_label
+
+    def eval(self, ctx):
+        iterable = ctx.stack.pop()
+        if is_null(iterable) or is_undefined(iterable):
+            ctx.stack.pop()
+            ctx.stack.append(undefined)
+            return self.break_label
+
+        obj = to_object(iterable, ctx.space)
+
+        for e in sorted(obj.own):
+            if not obj.own[e]['enumerable']:
+                continue
+
+            ctx.put(
+                self.name, e
+            )  # JS would have been so much nicer if this was ctx.space.put(self.name, obj.get(e))
+
+            # evaluate the body
+            status = ctx.space.exe.execute_fragment_under_context(
+                ctx, self.body_start_label, self.break_label)
+
+            val, typ, spec = status
+
+            if typ != 3:  # exception
+                ctx.stack.pop()
+
+            if typ == 0:  # normal
+                ctx.stack.append(val)
+                continue
+            elif typ == 1:  # return
+                ctx.stack.append(spec)
+                return None, None  # send return signal
+            elif typ == 2:  # jump outside
+                # now have to figure out whether this is a continue or something else...
+                ctx.stack.append(val)
+                if spec == self.continue_label:
+                    # just a continue, perform next iteration as normal
+                    continue
+                return spec  # break or smth, go there and finish the iteration
+            elif typ == 3:  # exception
+                # throw is made with empty stack as usual
+                raise spec
+            else:
+                raise RuntimeError('Invalid return code')
+
+        return self.break_label
+
+
+# all opcodes...
+OP_CODES = {}
+g = ''
+for g in globals():
+    try:
+        if not issubclass(globals()[g], OP_CODE) or g is 'OP_CODE':
+            continue
+    except:
+        continue
+    OP_CODES[g] = globals()[g]
@@ -0,0 +1,314 @@
+from __future__ import unicode_literals
+from .simplex import *
+from .conversions import *
+
+# ------------------------------------------------------------------------------
+# Unary operations
+
+
+# -x
+def minus_uop(self):
+    return -to_number(self)
+
+
+# +x
+def plus_uop(self):  # +u
+    return to_number(self)
+
+
+# !x
+def logical_negation_uop(self):  # !u  cant do 'not u' :(
+    return not to_boolean(self)
+
+
+# typeof x
+def typeof_uop(self):
+    if is_callable(self):
+        return u'function'
+    typ = Type(self).lower()
+    if typ == u'null':
+        typ = u'object'  # absolutely idiotic...
+    return typ
+
+
+# ~u
+def bit_invert_uop(self):
+    return float(to_int32(float(~to_int32(self))))
+
+
+# void
+def void_op(self):
+    return undefined
+
+
+UNARY_OPERATIONS = {
+    '+': plus_uop,
+    '-': minus_uop,
+    '!': logical_negation_uop,
+    '~': bit_invert_uop,
+    'void': void_op,
+    'typeof':
+    typeof_uop,  # this one only for member expressions! for identifiers its slightly different...
+}
+
+# ------------------------------------------------------------------------------
+# ----- binary ops -------
+
+# Bitwise operators
+#  <<, >>,  &, ^, |, ~
+
+
+# <<
+def bit_lshift_op(self, other):
+    lnum = to_int32(self)
+    rnum = to_uint32(other)
+    shiftCount = rnum & 0x1F
+    return float(to_int32(float(lnum << shiftCount)))
+
+
+# >>
+def bit_rshift_op(self, other):
+    lnum = to_int32(self)
+    rnum = to_uint32(other)
+    shiftCount = rnum & 0x1F
+    return float(to_int32(float(lnum >> shiftCount)))
+
+
+# >>>
+def bit_bshift_op(self, other):
+    lnum = to_uint32(self)
+    rnum = to_uint32(other)
+    shiftCount = rnum & 0x1F
+    return float(to_uint32(float(lnum >> shiftCount)))
+
+
+# &
+def bit_and_op(self, other):
+    lnum = to_int32(self)
+    rnum = to_int32(other)
+    return float(to_int32(float(lnum & rnum)))
+
+
+# ^
+def bit_xor_op(self, other):
+    lnum = to_int32(self)
+    rnum = to_int32(other)
+    return float(to_int32(float(lnum ^ rnum)))
+
+
+# |
+def bit_or_op(self, other):
+    lnum = to_int32(self)
+    rnum = to_int32(other)
+    return float(to_int32(float(lnum | rnum)))
+
+
+# Additive operators
+# + and - are implemented here
+
+
+# +
+def add_op(self, other):
+    if type(self) is float and type(other) is float:
+        return self + other
+    if type(self) is unicode and type(other) is unicode:
+        return self + other
+    # standard way...
+    a = to_primitive(self)
+    b = to_primitive(other)
+    if type(a) is unicode or type(b) is unicode:  # string wins hehe
+        return to_string(a) + to_string(b)
+    return to_number(a) + to_number(b)
+
+
+# -
+def sub_op(self, other):
+    return to_number(self) - to_number(other)
+
+
+# Multiplicative operators
+# *, / and % are implemented here
+
+
+# *
+def mul_op(self, other):
+    return to_number(self) * to_number(other)
+
+
+# /
+def div_op(self, other):
+    a = to_number(self)
+    b = to_number(other)
+    if b:
+        return a / float(b)  # ensure at least one is a float.
+    if not a or a != a:
+        return NaN
+    return Infinity if a > 0 else -Infinity
+
+
+# %
+def mod_op(self, other):
+    a = to_number(self)
+    b = to_number(other)
+    if abs(a) == Infinity or not b:
+        return NaN
+    if abs(b) == Infinity:
+        return a
+    pyres = a % b  # different signs in python and javascript
+    # python has the same sign as b and js has the same
+    # sign as a.
+    if a < 0 and pyres > 0:
+        pyres -= abs(b)
+    elif a > 0 and pyres < 0:
+        pyres += abs(b)
+    return float(pyres)
+
+
+# Comparisons
+# <, <=, !=, ==, >=, > are implemented here.
+def abstract_relational_comparison(self, other,
+                                   self_first=True):  # todo speed up!
+    ''' self<other if self_first else other<self.
+       Returns the result of the question: is self smaller than other?
+       in case self_first is false it returns the answer of:
+                                           is other smaller than self.
+       result is PyJs type: bool or undefined'''
+
+    px = to_primitive(self, 'Number')
+    py = to_primitive(other, 'Number')
+    if not self_first:  # reverse order
+        px, py = py, px
+    if not (Type(px) == 'String' and Type(py) == 'String'):
+        px, py = to_number(px), to_number(py)
+        if is_nan(px) or is_nan(py):
+            return None  # watch out here!
+        return px < py  # same cmp algorithm
+    else:
+        # I am pretty sure that python has the same
+        # string cmp algorithm but I have to confirm it
+        return px < py
+
+
+# <
+def less_op(self, other):
+    res = abstract_relational_comparison(self, other, True)
+    if res is None:
+        return False
+    return res
+
+
+# <=
+def less_eq_op(self, other):
+    res = abstract_relational_comparison(self, other, False)
+    if res is None:
+        return False
+    return not res
+
+
+# >=
+def greater_eq_op(self, other):
+    res = abstract_relational_comparison(self, other, True)
+    if res is None:
+        return False
+    return not res
+
+
+# >
+def greater_op(self, other):
+    res = abstract_relational_comparison(self, other, False)
+    if res is None:
+        return False
+    return res
+
+
+# equality
+
+
+def abstract_equality_op(self, other):
+    ''' returns the result of JS == compare.
+       result is PyJs type: bool'''
+    tx, ty = Type(self), Type(other)
+    if tx == ty:
+        if tx == 'Undefined' or tx == 'Null':
+            return True
+        if tx == 'Number' or tx == 'String' or tx == 'Boolean':
+            return self == other
+        return self is other  # Object
+    elif (tx == 'Undefined' and ty == 'Null') or (ty == 'Undefined'
+                                                  and tx == 'Null'):
+        return True
+    elif tx == 'Number' and ty == 'String':
+        return abstract_equality_op(self, to_number(other))
+    elif tx == 'String' and ty == 'Number':
+        return abstract_equality_op(to_number(self), other)
+    elif tx == 'Boolean':
+        return abstract_equality_op(to_number(self), other)
+    elif ty == 'Boolean':
+        return abstract_equality_op(self, to_number(other))
+    elif (tx == 'String' or tx == 'Number') and is_object(other):
+        return abstract_equality_op(self, to_primitive(other))
+    elif (ty == 'String' or ty == 'Number') and is_object(self):
+        return abstract_equality_op(to_primitive(self), other)
+    else:
+        return False
+
+
+def abstract_inequality_op(self, other):
+    return not abstract_equality_op(self, other)
+
+
+def strict_equality_op(self, other):
+    typ = Type(self)
+    if typ != Type(other):
+        return False
+    if typ == 'Undefined' or typ == 'Null':
+        return True
+    if typ == 'Boolean' or typ == 'String' or typ == 'Number':
+        return self == other
+    else:  # object
+        return self is other  # Id compare.
+
+
+def strict_inequality_op(self, other):
+    return not strict_equality_op(self, other)
+
+
+def instanceof_op(self, other):
+    '''checks if self is instance of other'''
+    if not hasattr(other, 'has_instance'):
+        return False
+    return other.has_instance(self)
+
+
+def in_op(self, other):
+    '''checks if self is in other'''
+    if not is_object(other):
+        raise MakeError(
+            'TypeError',
+            "You can\'t use 'in' operator to search in non-objects")
+    return other.has_property(to_string(self))
+
+
+BINARY_OPERATIONS = {
+    '+': add_op,
+    '-': sub_op,
+    '*': mul_op,
+    '/': div_op,
+    '%': mod_op,
+    '<<': bit_lshift_op,
+    '>>': bit_rshift_op,
+    '>>>': bit_bshift_op,
+    '|': bit_or_op,
+    '&': bit_and_op,
+    '^': bit_xor_op,
+    '==': abstract_equality_op,
+    '!=': abstract_inequality_op,
+    '===': strict_equality_op,
+    '!==': strict_inequality_op,
+    '<': less_op,
+    '<=': less_eq_op,
+    '>': greater_op,
+    '>=': greater_eq_op,
+    'in': in_op,
+    'instanceof': instanceof_op,
+}
@@ -0,0 +1 @@
+__author__ = 'Piotr Dabkowski'
@@ -0,0 +1,489 @@
+from __future__ import unicode_literals
+from ..conversions import *
+from ..func_utils import *
+from ..operations import strict_equality_op
+
+import six
+
+if six.PY3:
+    xrange = range
+    import functools
+
+ARR_STACK = set({})
+
+
+class ArrayPrototype:
+    def toString(this, args):
+        arr = to_object(this, args.space)
+        func = arr.get('join')
+        if not is_callable(func):
+            return u'[object %s]' % GetClass(arr)
+        return func.call(this, ())
+
+    def toLocaleString(this, args):
+        array = to_object(this, args.space)
+        arr_len = js_arr_length(array)
+        # separator is simply a comma ','
+        if not arr_len:
+            return ''
+        res = []
+        for i in xrange(arr_len):
+            element = array.get(unicode(i))
+            if is_undefined(element) or is_null(element):
+                res.append('')
+            else:
+                cand = to_object(element, args.space)
+                str_func = cand.get('toLocaleString')
+                if not is_callable(str_func):
+                    raise MakeError(
+                        'TypeError',
+                        'toLocaleString method of item at index %d is not callable'
+                        % i)
+                res.append(to_string(str_func.call(cand, ())))
+        return ','.join(res)
+
+    def concat(this, args):
+        array = to_object(this, args.space)
+        items = [array]
+        items.extend(tuple(args))
+        A = []
+        for E in items:
+            if GetClass(E) == 'Array':
+                k = 0
+                e_len = js_arr_length(E)
+                while k < e_len:
+                    if E.has_property(unicode(k)):
+                        A.append(E.get(unicode(k)))
+                    k += 1
+            else:
+                A.append(E)
+        return args.space.ConstructArray(A)
+
+    def join(this, args):
+        ARR_STACK.add(this)
+        array = to_object(this, args.space)
+        separator = get_arg(args, 0)
+        arr_len = js_arr_length(array)
+        separator = ',' if is_undefined(separator) else to_string(separator)
+        elems = []
+        for e in xrange(arr_len):
+            elem = array.get(unicode(e))
+            if elem in ARR_STACK:
+                s = ''
+            else:
+                s = to_string(elem)
+            elems.append(
+                s if not (is_undefined(elem) or is_null(elem)) else '')
+        res = separator.join(elems)
+        ARR_STACK.remove(this)
+        return res
+
+    def pop(this, args):  #todo check
+        array = to_object(this, args.space)
+        arr_len = js_arr_length(array)
+        if not arr_len:
+            array.put('length', float(arr_len))
+            return undefined
+        ind = unicode(arr_len - 1)
+        element = array.get(ind)
+        array.delete(ind)
+        array.put('length', float(arr_len - 1))
+        return element
+
+    def push(this, args):
+        array = to_object(this, args.space)
+        arr_len = js_arr_length(array)
+        to_put = tuple(args)
+        i = arr_len
+        for i, e in enumerate(to_put, arr_len):
+            array.put(unicode(i), e, True)
+        array.put('length', float(arr_len + len(to_put)), True)
+        return float(i)
+
+    def reverse(this, args):
+        array = to_object(this, args.space)
+        vals = js_array_to_list(array)
+        has_props = [
+            array.has_property(unicode(e))
+            for e in xrange(js_arr_length(array))
+        ]
+        vals.reverse()
+        has_props.reverse()
+        for i, val in enumerate(vals):
+            if has_props[i]:
+                array.put(unicode(i), val)
+            else:
+                array.delete(unicode(i))
+        return array
+
+    def shift(this, args):
+        array = to_object(this, args.space)
+        arr_len = js_arr_length(array)
+        if not arr_len:
+            array.put('length', 0.)
+            return undefined
+        first = array.get('0')
+        for k in xrange(1, arr_len):
+            from_s, to_s = unicode(k), unicode(k - 1)
+            if array.has_property(from_s):
+                array.put(to_s, array.get(from_s))
+            else:
+                array.delete(to_s)
+        array.delete(unicode(arr_len - 1))
+        array.put('length', float(arr_len - 1))
+        return first
+
+    def slice(this, args):  # todo check
+        array = to_object(this, args.space)
+        start = get_arg(args, 0)
+        end = get_arg(args, 1)
+        arr_len = js_arr_length(array)
+        relative_start = to_int(start)
+        k = max((arr_len + relative_start), 0) if relative_start < 0 else min(
+            relative_start, arr_len)
+        relative_end = arr_len if is_undefined(end) else to_int(end)
+        final = max((arr_len + relative_end), 0) if relative_end < 0 else min(
+            relative_end, arr_len)
+        res = []
+        n = 0
+        while k < final:
+            pk = unicode(k)
+            if array.has_property(pk):
+                res.append(array.get(pk))
+            k += 1
+            n += 1
+        return args.space.ConstructArray(res)
+
+    def sort(
+            this, args
+    ):  # todo: this assumes array continous (not sparse) - fix for sparse arrays
+        cmpfn = get_arg(args, 0)
+        if not GetClass(this) in ('Array', 'Arguments'):
+            return to_object(this, args.space)  # do nothing
+        arr_len = js_arr_length(this)
+        if not arr_len:
+            return this
+        arr = [
+            (this.get(unicode(e)) if this.has_property(unicode(e)) else None)
+            for e in xrange(arr_len)
+        ]
+        if not is_callable(cmpfn):
+            cmpfn = None
+        cmp = lambda a, b: sort_compare(a, b, cmpfn)
+        if six.PY3:
+            key = functools.cmp_to_key(cmp)
+            arr.sort(key=key)
+        else:
+            arr.sort(cmp=cmp)
+        for i in xrange(arr_len):
+            if arr[i] is None:
+                this.delete(unicode(i))
+            else:
+                this.put(unicode(i), arr[i])
+        return this
+
+    def splice(this, args):
+        # 1-8
+        array = to_object(this, args.space)
+        start = get_arg(args, 0)
+        deleteCount = get_arg(args, 1)
+        arr_len = js_arr_length(this)
+        relative_start = to_int(start)
+        actual_start = max(
+            (arr_len + relative_start), 0) if relative_start < 0 else min(
+                relative_start, arr_len)
+        actual_delete_count = min(
+            max(to_int(deleteCount), 0), arr_len - actual_start)
+        k = 0
+        A = args.space.NewArray(0)
+        # 9
+        while k < actual_delete_count:
+            if array.has_property(unicode(actual_start + k)):
+                A.put(unicode(k), array.get(unicode(actual_start + k)))
+            k += 1
+        # 10-11
+        items = list(args)[2:]
+        items_len = len(items)
+        # 12
+        if items_len < actual_delete_count:
+            k = actual_start
+            while k < (arr_len - actual_delete_count):
+                fr = unicode(k + actual_delete_count)
+                to = unicode(k + items_len)
+                if array.has_property(fr):
+                    array.put(to, array.get(fr))
+                else:
+                    array.delete(to)
+                k += 1
+            k = arr_len
+            while k > (arr_len - actual_delete_count + items_len):
+                array.delete(unicode(k - 1))
+                k -= 1
+        # 13
+        elif items_len > actual_delete_count:
+            k = arr_len - actual_delete_count
+            while k > actual_start:
+                fr = unicode(k + actual_delete_count - 1)
+                to = unicode(k + items_len - 1)
+                if array.has_property(fr):
+                    array.put(to, array.get(fr))
+                else:
+                    array.delete(to)
+                k -= 1
+        # 14-17
+        k = actual_start
+        while items:
+            E = items.pop(0)
+            array.put(unicode(k), E)
+            k += 1
+        array.put('length', float(arr_len - actual_delete_count + items_len))
+        return A
+
+    def unshift(this, args):
+        array = to_object(this, args.space)
+        arr_len = js_arr_length(array)
+        argCount = len(args)
+        k = arr_len
+        while k > 0:
+            fr = unicode(k - 1)
+            to = unicode(k + argCount - 1)
+            if array.has_property(fr):
+                array.put(to, array.get(fr))
+            else:
+                array.delete(to)
+            k -= 1
+        items = tuple(args)
+        for j, e in enumerate(items):
+            array.put(unicode(j), e)
+        array.put('length', float(arr_len + argCount))
+        return float(arr_len + argCount)
+
+    def indexOf(this, args):
+        array = to_object(this, args.space)
+        searchElement = get_arg(args, 0)
+        arr_len = js_arr_length(array)
+        if arr_len == 0:
+            return -1.
+        if len(args) > 1:
+            n = to_int(args[1])
+        else:
+            n = 0
+        if n >= arr_len:
+            return -1.
+        if n >= 0:
+            k = n
+        else:
+            k = arr_len - abs(n)
+            if k < 0:
+                k = 0
+        while k < arr_len:
+            if array.has_property(unicode(k)):
+                elementK = array.get(unicode(k))
+                if strict_equality_op(searchElement, elementK):
+                    return float(k)
+            k += 1
+        return -1.
+
+    def lastIndexOf(this, args):
+        array = to_object(this, args.space)
+        searchElement = get_arg(args, 0)
+        arr_len = js_arr_length(array)
+        if arr_len == 0:
+            return -1.
+        if len(args) > 1:
+            n = to_int(args[1])
+        else:
+            n = arr_len - 1
+        if n >= 0:
+            k = min(n, arr_len - 1)
+        else:
+            k = arr_len - abs(n)
+        while k >= 0:
+            if array.has_property(unicode(k)):
+                elementK = array.get(unicode(k))
+                if strict_equality_op(searchElement, elementK):
+                    return float(k)
+            k -= 1
+        return -1.
+
+    def every(this, args):
+        array = to_object(this, args.space)
+        callbackfn = get_arg(args, 0)
+        arr_len = js_arr_length(array)
+        if not is_callable(callbackfn):
+            raise MakeError('TypeError', 'callbackfn must be a function')
+        T = get_arg(args, 1)
+        k = 0
+        while k < arr_len:
+            if array.has_property(unicode(k)):
+                kValue = array.get(unicode(k))
+                if not to_boolean(
+                        callbackfn.call(T, (kValue, float(k), array))):
+                    return False
+            k += 1
+        return True
+
+    def some(this, args):
+        array = to_object(this, args.space)
+        callbackfn = get_arg(args, 0)
+        arr_len = js_arr_length(array)
+        if not is_callable(callbackfn):
+            raise MakeError('TypeError', 'callbackfn must be a function')
+        T = get_arg(args, 1)
+        k = 0
+        while k < arr_len:
+            if array.has_property(unicode(k)):
+                kValue = array.get(unicode(k))
+                if to_boolean(callbackfn.call(T, (kValue, float(k), array))):
+                    return True
+            k += 1
+        return False
+
+    def forEach(this, args):
+        array = to_object(this, args.space)
+        callbackfn = get_arg(args, 0)
+        arr_len = js_arr_length(array)
+        if not is_callable(callbackfn):
+            raise MakeError('TypeError', 'callbackfn must be a function')
+        _this = get_arg(args, 1)
+        k = 0
+        while k < arr_len:
+            sk = unicode(k)
+            if array.has_property(sk):
+                kValue = array.get(sk)
+                callbackfn.call(_this, (kValue, float(k), array))
+            k += 1
+        return undefined
+
+    def map(this, args):
+        array = to_object(this, args.space)
+        callbackfn = get_arg(args, 0)
+        arr_len = js_arr_length(array)
+        if not is_callable(callbackfn):
+            raise MakeError('TypeError', 'callbackfn must be a function')
+        _this = get_arg(args, 1)
+        k = 0
+        A = args.space.NewArray(0)
+        while k < arr_len:
+            Pk = unicode(k)
+            if array.has_property(Pk):
+                kValue = array.get(Pk)
+                mappedValue = callbackfn.call(_this, (kValue, float(k), array))
+                A.define_own_property(
+                    Pk, {
+                        'value': mappedValue,
+                        'writable': True,
+                        'enumerable': True,
+                        'configurable': True
+                    }, False)
+            k += 1
+        return A
+
+    def filter(this, args):
+        array = to_object(this, args.space)
+        callbackfn = get_arg(args, 0)
+        arr_len = js_arr_length(array)
+        if not is_callable(callbackfn):
+            raise MakeError('TypeError', 'callbackfn must be a function')
+        _this = get_arg(args, 1)
+        k = 0
+        res = []
+        while k < arr_len:
+            if array.has_property(unicode(k)):
+                kValue = array.get(unicode(k))
+                if to_boolean(
+                        callbackfn.call(_this, (kValue, float(k), array))):
+                    res.append(kValue)
+            k += 1
+        return args.space.ConstructArray(res)
+
+    def reduce(this, args):
+        array = to_object(this, args.space)
+        callbackfn = get_arg(args, 0)
+        arr_len = js_arr_length(array)
+        if not is_callable(callbackfn):
+            raise MakeError('TypeError', 'callbackfn must be a function')
+        if not arr_len and len(args) < 2:
+            raise MakeError('TypeError',
+                            'Reduce of empty array with no initial value')
+        k = 0
+        accumulator = undefined
+        if len(args) > 1:  # initial value present
+            accumulator = args[1]
+        else:
+            kPresent = False
+            while not kPresent and k < arr_len:
+                kPresent = array.has_property(unicode(k))
+                if kPresent:
+                    accumulator = array.get(unicode(k))
+                k += 1
+            if not kPresent:
+                raise MakeError('TypeError',
+                                'Reduce of empty array with no initial value')
+        while k < arr_len:
+            if array.has_property(unicode(k)):
+                kValue = array.get(unicode(k))
+                accumulator = callbackfn.call(
+                    undefined, (accumulator, kValue, float(k), array))
+            k += 1
+        return accumulator
+
+    def reduceRight(this, args):
+        array = to_object(this, args.space)
+        callbackfn = get_arg(args, 0)
+        arr_len = js_arr_length(array)
+        if not is_callable(callbackfn):
+            raise MakeError('TypeError', 'callbackfn must be a function')
+        if not arr_len and len(args) < 2:
+            raise MakeError('TypeError',
+                            'Reduce of empty array with no initial value')
+        k = arr_len - 1
+        accumulator = undefined
+
+        if len(args) > 1:  # initial value present
+            accumulator = args[1]
+        else:
+            kPresent = False
+            while not kPresent and k >= 0:
+                kPresent = array.has_property(unicode(k))
+                if kPresent:
+                    accumulator = array.get(unicode(k))
+                k -= 1
+            if not kPresent:
+                raise MakeError('TypeError',
+                                'Reduce of empty array with no initial value')
+        while k >= 0:
+            if array.has_property(unicode(k)):
+                kValue = array.get(unicode(k))
+                accumulator = callbackfn.call(
+                    undefined, (accumulator, kValue, float(k), array))
+            k -= 1
+        return accumulator
+
+
+def sort_compare(a, b, comp):
+    if a is None:
+        if b is None:
+            return 0
+        return 1
+    if b is None:
+        if a is None:
+            return 0
+        return -1
+    if is_undefined(a):
+        if is_undefined(b):
+            return 0
+        return 1
+    if is_undefined(b):
+        if is_undefined(a):
+            return 0
+        return -1
+    if comp is not None:
+        res = comp.call(undefined, (a, b))
+        return to_int(res)
+    x, y = to_string(a), to_string(b)
+    if x < y:
+        return -1
+    elif x > y:
+        return 1
+    return 0
@@ -0,0 +1,22 @@
+from __future__ import unicode_literals
+
+from ..conversions import *
+from ..func_utils import *
+
+
+class BooleanPrototype:
+    def toString(this, args):
+        if GetClass(this) != 'Boolean':
+            raise MakeError('TypeError',
+                            'Boolean.prototype.toString is not generic')
+        if is_object(this):
+            this = this.value
+        return u'true' if this else u'false'
+
+    def valueOf(this, args):
+        if GetClass(this) != 'Boolean':
+            raise MakeError('TypeError',
+                            'Boolean.prototype.valueOf is not generic')
+        if is_object(this):
+            this = this.value
+        return this
@@ -0,0 +1,15 @@
+from __future__ import unicode_literals
+from ..conversions import *
+from ..func_utils import *
+
+
+class ErrorPrototype:
+    def toString(this, args):
+        if Type(this) != 'Object':
+            raise MakeError('TypeError',
+                            'Error.prototype.toString called on non-object')
+        name = this.get('name')
+        name = u'Error' if is_undefined(name) else to_string(name)
+        msg = this.get('message')
+        msg = '' if is_undefined(msg) else to_string(msg)
+        return name + (name and msg and ': ') + msg
@@ -0,0 +1,61 @@
+from __future__ import unicode_literals
+
+from ..conversions import *
+from ..func_utils import *
+
+# python 3 support
+import six
+if six.PY3:
+    basestring = str
+    long = int
+    xrange = range
+    unicode = str
+
+# todo fix apply and bind
+
+
+class FunctionPrototype:
+    def toString(this, args):
+        if not is_callable(this):
+            raise MakeError('TypeError',
+                            'Function.prototype.toString is not generic')
+
+        args = u', '.join(map(unicode, this.params))
+        return u'function %s(%s) { [native code] }' % (this.name if this.name
+                                                       else u'', args)
+
+    def call(this, args):
+        if not is_callable(this):
+            raise MakeError('TypeError',
+                            'Function.prototype.call is not generic')
+        _this = get_arg(args, 0)
+        _args = tuple(args)[1:]
+        return this.call(_this, _args)
+
+    def apply(this, args):
+        if not is_callable(this):
+            raise MakeError('TypeError',
+                            'Function.prototype.apply is not generic')
+        _args = get_arg(args, 1)
+        if not is_object(_args):
+            raise MakeError(
+                'TypeError',
+                'argList argument to Function.prototype.apply must an Object')
+        _this = get_arg(args, 0)
+        return this.call(_this, js_array_to_tuple(_args))
+
+    def bind(this, args):
+        if not is_callable(this):
+            raise MakeError('TypeError',
+                            'Function.prototype.bind is not generic')
+        bound_this = get_arg(args, 0)
+        bound_args = tuple(args)[1:]
+
+        def bound(dummy_this, extra_args):
+            return this.call(bound_this, bound_args + tuple(extra_args))
+
+        js_bound = args.space.NewFunction(bound, this.ctx, (), u'', False, ())
+        js_bound.put(u'length',
+                     float(max(len(this.params) - len(bound_args), 0.)))
+        js_bound.put(u'name', u'boundFunc')
+        return js_bound
@@ -0,0 +1,205 @@
+from __future__ import unicode_literals
+from ..conversions import *
+from ..func_utils import *
+from ..operations import strict_equality_op
+import json
+
+indent = ''
+# python 3 support
+import six
+if six.PY3:
+    basestring = str
+    long = int
+    xrange = range
+    unicode = str
+
+
+def parse(this, args):
+    text, reviver = get_arg(args, 0), get_arg(args, 1)
+    s = to_string(text)
+    try:
+        unfiltered = json.loads(s)
+    except:
+        raise MakeError(
+            'SyntaxError',
+            'JSON.parse could not parse JSON string - Invalid syntax')
+    unfiltered = to_js(unfiltered, args.space)
+    if is_callable(reviver):
+        root = args.space.ConstructObject({'': unfiltered})
+        return walk(root, '', reviver)
+    else:
+        return unfiltered
+
+
+def stringify(this, args):
+    global indent
+    value, replacer, space = get_arg(args, 0), get_arg(args, 1), get_arg(
+        args, 2)
+    stack = set([])
+    indent = ''
+    property_list = replacer_function = undefined
+    if is_object(replacer):
+        if is_callable(replacer):
+            replacer_function = replacer
+        elif replacer.Class == 'Array':
+            property_list = []
+            for e in replacer:
+                v = replacer[e]
+                item = undefined
+                typ = Type(v)
+                if typ == 'Number':
+                    item = to_string(v)
+                elif typ == 'String':
+                    item = v
+                elif typ == 'Object':
+                    if GetClass(v) in ('String', 'Number'):
+                        item = to_string(v)
+                if not is_undefined(item) and item not in property_list:
+                    property_list.append(item)
+    if is_object(space):
+        if GetClass(space) == 'Number':
+            space = to_number(space)
+        elif GetClass(space) == 'String':
+            space = to_string(space)
+    if Type(space) == 'Number':
+        space = min(10, to_int(space))
+        gap = max(int(space), 0) * ' '
+    elif Type(space) == 'String':
+        gap = space[:10]
+    else:
+        gap = ''
+    return Str('', args.space.ConstructObject({
+        '': value
+    }), replacer_function, property_list, gap, stack, space)
+
+
+def Str(key, holder, replacer_function, property_list, gap, stack, space):
+    value = holder.get(key)
+    if is_object(value):
+        to_json = value.get('toJSON')
+        if is_callable(to_json):
+            value = to_json.call(value, (key, ))
+    if not is_undefined(replacer_function):
+        value = replacer_function.call(holder, (key, value))
+
+    if is_object(value):
+        if value.Class == 'String':
+            value = to_string(value)
+        elif value.Class == 'Number':
+            value = to_number(value)
+        elif value.Class == 'Boolean':
+            value = to_boolean(value)
+    typ = Type(value)
+    if is_null(value):
+        return 'null'
+    elif typ == 'Boolean':
+        return 'true' if value else 'false'
+    elif typ == 'String':
+        return Quote(value)
+    elif typ == 'Number':
+        if not is_infinity(value):
+            return to_string(value)
+        return 'null'
+    if is_object(value) and not is_callable(value):
+        if value.Class == 'Array':
+            return ja(value, stack, gap, property_list, replacer_function,
+                      space)
+        else:
+            return jo(value, stack, gap, property_list, replacer_function,
+                      space)
+    return undefined
+
+
+def jo(value, stack, gap, property_list, replacer_function, space):
+    global indent
+    if value in stack:
+        raise MakeError('TypeError', 'Converting circular structure to JSON')
+    stack.add(value)
+    stepback = indent
+    indent += gap
+    if not is_undefined(property_list):
+        k = property_list
+    else:
+        k = [unicode(e) for e, d in value.own.items() if d.get('enumerable')]
+    partial = []
+    for p in k:
+        str_p = Str(p, value, replacer_function, property_list, gap, stack,
+                    space)
+        if not is_undefined(str_p):
+            member = json.dumps(p) + ':' + (
+                ' ' if gap else
+                '') + str_p  # todo not sure here - what space character?
+            partial.append(member)
+    if not partial:
+        final = '{}'
+    else:
+        if not gap:
+            final = '{%s}' % ','.join(partial)
+        else:
+            sep = ',\n' + indent
+            properties = sep.join(partial)
+            final = '{\n' + indent + properties + '\n' + stepback + '}'
+    stack.remove(value)
+    indent = stepback
+    return final
+
+
+def ja(value, stack, gap, property_list, replacer_function, space):
+    global indent
+    if value in stack:
+        raise MakeError('TypeError', 'Converting circular structure to JSON')
+    stack.add(value)
+    stepback = indent
+    indent += gap
+    partial = []
+    length = js_arr_length(value)
+    for index in xrange(length):
+        index = unicode(index)
+        str_index = Str(index, value, replacer_function, property_list, gap,
+                        stack, space)
+        if is_undefined(str_index):
+            partial.append('null')
+        else:
+            partial.append(str_index)
+    if not partial:
+        final = '[]'
+    else:
+        if not gap:
+            final = '[%s]' % ','.join(partial)
+        else:
+            sep = ',\n' + indent
+            properties = sep.join(partial)
+            final = '[\n' + indent + properties + '\n' + stepback + ']'
+    stack.remove(value)
+    indent = stepback
+    return final
+
+
+def Quote(string):
+    return json.dumps(string)
+
+
+def to_js(d, _args_space):
+    return convert_to_js_type(d, _args_space)
+
+
+def walk(holder, name, reviver):
+    val = holder.get(name)
+    if GetClass(val) == 'Array':
+        for i in xrange(js_arr_length(val)):
+            i = unicode(i)
+            new_element = walk(val, i, reviver)
+            if is_undefined(new_element):
+                val.delete(i)
+            else:
+                new_element.put(i, new_element)
+    elif is_object(val):
+        for key in [
+                unicode(e) for e, d in val.own.items() if d.get('enumerable')
+        ]:
+            new_element = walk(val, key, reviver)
+            if is_undefined(new_element):
+                val.delete(key)
+            else:
+                val.put(key, new_element)
+    return reviver.call(holder, (name, val))
@@ -0,0 +1,163 @@
+from __future__ import unicode_literals
+from ..conversions import *
+from ..func_utils import *
+
+import six
+if six.PY3:
+    basestring = str
+    long = int
+    xrange = range
+    unicode = str
+
+RADIX_SYMBOLS = {
+    0: '0',
+    1: '1',
+    2: '2',
+    3: '3',
+    4: '4',
+    5: '5',
+    6: '6',
+    7: '7',
+    8: '8',
+    9: '9',
+    10: 'a',
+    11: 'b',
+    12: 'c',
+    13: 'd',
+    14: 'e',
+    15: 'f',
+    16: 'g',
+    17: 'h',
+    18: 'i',
+    19: 'j',
+    20: 'k',
+    21: 'l',
+    22: 'm',
+    23: 'n',
+    24: 'o',
+    25: 'p',
+    26: 'q',
+    27: 'r',
+    28: 's',
+    29: 't',
+    30: 'u',
+    31: 'v',
+    32: 'w',
+    33: 'x',
+    34: 'y',
+    35: 'z'
+}
+
+
+def to_str_rep(num):
+    if is_nan(num):
+        return 'NaN'
+    elif is_infinity(num):
+        sign = '-' if num < 0 else ''
+        return sign + 'Infinity'
+    elif int(num) == num:  # dont print .0
+        return unicode(int(num))
+    return unicode(num)  # todo: Make it 100% consistent with Node
+
+
+class NumberPrototype:
+    def toString(this, args):
+        if GetClass(this) != 'Number':
+            raise MakeError('TypeError',
+                            'Number.prototype.valueOf is not generic')
+        if type(this) != float:
+            this = this.value
+        radix = get_arg(args, 0)
+        if is_undefined(radix):
+            return to_str_rep(this)
+        r = to_int(radix)
+        if r == 10:
+            return to_str_rep(this)
+        if r not in xrange(2, 37) or radix != r:
+            raise MakeError(
+                'RangeError',
+                'Number.prototype.toString() radix argument must be an integer between 2 and 36'
+            )
+        num = to_int(this)
+        if num < 0:
+            num = -num
+            sign = '-'
+        else:
+            sign = ''
+        res = ''
+        while num:
+            s = RADIX_SYMBOLS[num % r]
+            num = num // r
+            res = s + res
+        return sign + (res if res else '0')
+
+    def valueOf(this, args):
+        if GetClass(this) != 'Number':
+            raise MakeError('TypeError',
+                            'Number.prototype.valueOf is not generic')
+        if type(this) != float:
+            this = this.value
+        return this
+
+    def toFixed(this, args):
+        if GetClass(this) != 'Number':
+            raise MakeError(
+                'TypeError',
+                'Number.prototype.toFixed called on incompatible receiver')
+        if type(this) != float:
+            this = this.value
+        fractionDigits = get_arg(args, 0)
+        digs = to_int(fractionDigits)
+        if digs < 0 or digs > 20:
+            raise MakeError(
+                'RangeError',
+                'toFixed() digits argument must be between 0 and 20')
+        elif is_infinity(this):
+            return 'Infinity' if this > 0 else '-Infinity'
+        elif is_nan(this):
+            return 'NaN'
+        return format(this, '-.%df' % digs)
+
+    def toExponential(this, args):
+        if GetClass(this) != 'Number':
+            raise MakeError(
+                'TypeError',
+                'Number.prototype.toExponential called on incompatible receiver'
+            )
+        if type(this) != float:
+            this = this.value
+        fractionDigits = get_arg(args, 0)
+        digs = to_int(fractionDigits)
+        if digs < 0 or digs > 20:
+            raise MakeError(
+                'RangeError',
+                'toFixed() digits argument must be between 0 and 20')
+        elif is_infinity(this):
+            return 'Infinity' if this > 0 else '-Infinity'
+        elif is_nan(this):
+            return 'NaN'
+        return format(this, '-.%de' % digs)
+
+    def toPrecision(this, args):
+        if GetClass(this) != 'Number':
+            raise MakeError(
+                'TypeError',
+                'Number.prototype.toPrecision called on incompatible receiver')
+        if type(this) != float:
+            this = this.value
+        precision = get_arg(args, 0)
+        if is_undefined(precision):
+            return to_string(this)
+        prec = to_int(precision)
+        if is_nan(this):
+            return 'NaN'
+        elif is_infinity(this):
+            return 'Infinity' if this > 0 else '-Infinity'
+        digs = prec - len(str(int(this)))
+        if digs >= 0:
+            return format(this, '-.%df' % digs)
+        else:
+            return format(this, '-.%df' % (prec - 1))
+
+
+NumberPrototype.toLocaleString = NumberPrototype.toString
@@ -0,0 +1,48 @@
+from __future__ import unicode_literals
+from ..conversions import *
+from ..func_utils import *
+
+
+class ObjectPrototype:
+    def toString(this, args):
+        if type(this) == UNDEFINED_TYPE:
+            return u'[object Undefined]'
+        elif type(this) == NULL_TYPE:
+            return u'[object Null]'
+        return u'[object %s]' % GetClass(to_object(this, args.space))
+
+    def valueOf(this, args):
+        return to_object(this, args.space)
+
+    def toLocaleString(this, args):
+        o = to_object(this, args.space)
+        toString = o.get(u'toString')
+        if not is_callable(toString):
+            raise MakeError('TypeError', 'toString of this is not callcable')
+        else:
+            return toString.call(this, args)
+
+    def hasOwnProperty(this, args):
+        prop = get_arg(args, 0)
+        o = to_object(this, args.space)
+        return o.get_own_property(to_string(prop)) is not None
+
+    def isPrototypeOf(this, args):
+        # a bit stupid specification because of object conversion that will cause invalid values for primitives
+        # for example Object.prototype.isPrototypeOf.call((5).__proto__, 5) gives false
+        obj = get_arg(args, 0)
+        if not is_object(obj):
+            return False
+        o = to_object(this, args.space)
+        while 1:
+            obj = obj.prototype
+            if obj is None or is_null(obj):
+                return False
+            if obj is o:
+                return True
+
+    def propertyIsEnumerable(this, args):
+        prop = get_arg(args, 0)
+        o = to_object(this, args.space)
+        cand = o.own.get(to_string(prop))
+        return cand is not None and cand.get('enumerable')
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`__path__ = __import__('pkgutil').extend_path(__path__, __name__)`