@scrypted/arlo 0.11.26 → 0.11.27

package/venv/lib/python3.10/site-packages/cloudscraper/interpreters/__init__.py

@@ -1,56 +0,0 @@
-import sys
-import logging
-import abc
-
-from ..exceptions import CloudflareSolveError
-
-if sys.version_info >= (3, 4):
-    ABC = abc.ABC  # noqa
-else:
-    ABC = abc.ABCMeta('ABC', (), {})
-
-# ------------------------------------------------------------------------------- #
-
-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:
-            return '{0:.10f}'.format(float(self.eval(body, domain)))
-        except Exception:
-            raise CloudflareSolveError(
-                'Error trying to solve Cloudflare IUAM Javascript, they may have changed their technique.'
-            )

package/venv/lib/python3.10/site-packages/cloudscraper/interpreters/chakracore.py

@@ -1,103 +0,0 @@
-from __future__ import absolute_import
-
-import os
-import sys
-import ctypes.util
-
-from ctypes import c_void_p, c_size_t, byref, create_string_buffer, CDLL
-
-from . import JavaScriptInterpreter
-from .encapsulated import template
-
-# ------------------------------------------------------------------------------- #
-
-
-class ChallengeInterpreter(JavaScriptInterpreter):
-
-    # ------------------------------------------------------------------------------- #
-
-    def __init__(self):
-        super(ChallengeInterpreter, self).__init__('chakracore')
-
-    # ------------------------------------------------------------------------------- #
-
-    def eval(self, body, domain):
-        chakraCoreLibrary = None
-
-        # check current working directory.
-        for _libraryFile in ['libChakraCore.so', 'libChakraCore.dylib', 'ChakraCore.dll']:
-            if os.path.isfile(os.path.join(os.getcwd(), _libraryFile)):
-                chakraCoreLibrary = os.path.join(os.getcwd(), _libraryFile)
-                continue
-
-        if not chakraCoreLibrary:
-            chakraCoreLibrary = ctypes.util.find_library('ChakraCore')
-
-        if not chakraCoreLibrary:
-            sys.tracebacklimit = 0
-            raise RuntimeError(
-                'ChakraCore library not found in current path or any of your system library paths, '
-                'please download from https://www.github.com/VeNoMouS/cloudscraper/tree/ChakraCore/, '
-                'or https://github.com/Microsoft/ChakraCore/'
-            )
-
-        try:
-            chakraCore = CDLL(chakraCoreLibrary)
-        except OSError:
-            sys.tracebacklimit = 0
-            raise RuntimeError('There was an error loading the ChakraCore library {}'.format(chakraCoreLibrary))
-
-        if sys.platform != 'win32':
-            chakraCore.DllMain(0, 1, 0)
-            chakraCore.DllMain(0, 2, 0)
-
-        script = create_string_buffer(template(body, domain).encode('utf-16'))
-
-        runtime = c_void_p()
-        chakraCore.JsCreateRuntime(0, 0, byref(runtime))
-
-        context = c_void_p()
-        chakraCore.JsCreateContext(runtime, byref(context))
-        chakraCore.JsSetCurrentContext(context)
-
-        fname = c_void_p()
-        chakraCore.JsCreateString(
-            'iuam-challenge.js',
-            len('iuam-challenge.js'),
-            byref(fname)
-        )
-
-        scriptSource = c_void_p()
-        chakraCore.JsCreateExternalArrayBuffer(
-            script,
-            len(script),
-            0,
-            0,
-            byref(scriptSource)
-        )
-
-        jsResult = c_void_p()
-        chakraCore.JsRun(scriptSource, 0, fname, 0x02, byref(jsResult))
-
-        resultJSString = c_void_p()
-        chakraCore.JsConvertValueToString(jsResult, byref(resultJSString))
-
-        stringLength = c_size_t()
-        chakraCore.JsCopyString(resultJSString, 0, 0, byref(stringLength))
-
-        resultSTR = create_string_buffer(stringLength.value + 1)
-        chakraCore.JsCopyString(
-            resultJSString,
-            byref(resultSTR),
-            stringLength.value + 1,
-            0
-        )
-
-        chakraCore.JsDisposeRuntime(runtime)
-
-        return resultSTR.value
-
-
-# ------------------------------------------------------------------------------- #
-
-ChallengeInterpreter()

package/venv/lib/python3.10/site-packages/cloudscraper/interpreters/encapsulated.py

@@ -1,62 +0,0 @@
-import logging
-import re
-
-# ------------------------------------------------------------------------------- #
-
-
-def template(body, domain):
-    BUG_REPORT = 'Cloudflare may have changed their technique, or there may be a bug in the script.'
-
-    try:
-        js = re.search(
-            r'setTimeout\(function\(\){\s+(.*?a\.value\s*=\s*\S+toFixed\(10\);)',
-            body,
-            re.M | re.S
-        ).group(1)
-    except Exception:
-        raise ValueError('Unable to identify Cloudflare IUAM Javascript on website. {}'.format(BUG_REPORT))
-
-    jsEnv = '''String.prototype.italics=function(str) {{return "<i>" + this + "</i>";}};
-        var subVars= {{{subVars}}};
-        var document = {{
-            createElement: function () {{
-                return {{ firstChild: {{ href: "https://{domain}/" }} }}
-            }},
-            getElementById: function (str) {{
-                return {{"innerHTML": subVars[str]}};
-            }}
-        }};
-    '''
-
-    try:
-        js = js.replace(
-            r"(setInterval(function(){}, 100),t.match(/https?:\/\//)[0]);",
-            r"t.match(/https?:\/\//)[0];"
-        )
-
-        k = re.search(r" k\s*=\s*'(?P<k>\S+)';", body).group('k')
-        r = re.compile(r'<div id="{}(?P<id>\d+)">\s*(?P<jsfuck>[^<>]*)</div>'.format(k))
-
-        subVars = ''
-        for m in r.finditer(body):
-            subVars = '{}\n\t\t{}{}: {},\n'.format(subVars, k, m.group('id'), m.group('jsfuck'))
-        subVars = subVars[:-2]
-
-    except:  # noqa
-        logging.error('Error extracting Cloudflare IUAM Javascript. {}'.format(BUG_REPORT))
-        raise
-
-    return '{}{}'.format(
-        re.sub(
-            r'\s{2,}',
-            ' ',
-            jsEnv.format(
-                domain=domain,
-                subVars=subVars
-            ),
-            re.MULTILINE | re.DOTALL
-        ),
-        js
-    )
-
-# ------------------------------------------------------------------------------- #

package/venv/lib/python3.10/site-packages/cloudscraper/interpreters/js2py.py

@@ -1,44 +0,0 @@
-from __future__ import absolute_import
-
-import js2py
-import logging
-import base64
-
-from . import JavaScriptInterpreter
-
-from .encapsulated import template
-from .jsunfuck import jsunfuck
-
-# ------------------------------------------------------------------------------- #
-
-
-class ChallengeInterpreter(JavaScriptInterpreter):
-
-    # ------------------------------------------------------------------------------- #
-
-    def __init__(self):
-        super(ChallengeInterpreter, self).__init__('js2py')
-
-    # ------------------------------------------------------------------------------- #
-
-    def eval(self, body, domain):
-
-        jsPayload = template(body, domain)
-
-        if js2py.eval_js('(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]') == '1':
-            logging.warning('WARNING - Please upgrade your js2py https://github.com/PiotrDabkowski/Js2Py, applying work around for the meantime.')
-            jsPayload = jsunfuck(jsPayload)
-
-        def atob(s):
-            return base64.b64decode('{}'.format(s)).decode('utf-8')
-
-        js2py.disable_pyimport()
-        context = js2py.EvalJs({'atob': atob})
-        result = context.eval(jsPayload)
-
-        return result
-
-
-# ------------------------------------------------------------------------------- #
-
-ChallengeInterpreter()

package/venv/lib/python3.10/site-packages/cloudscraper/interpreters/jsunfuck.py

@@ -1,97 +0,0 @@
-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

package/venv/lib/python3.10/site-packages/cloudscraper/interpreters/native.py

@@ -1,233 +0,0 @@
-from __future__ import absolute_import
-
-import ast
-import re
-import operator as op
-import pyparsing
-
-from ..exceptions import CloudflareSolveError
-from . import JavaScriptInterpreter
-
-# ------------------------------------------------------------------------------- #
-
-_OP_MAP = {
-    ast.Add: op.add,
-    ast.Sub: op.sub,
-    ast.Mult: op.mul,
-    ast.Div: op.truediv,
-    ast.Invert: op.neg,
-}
-
-# ------------------------------------------------------------------------------- #
-
-
-class Calc(ast.NodeVisitor):
-
-    def visit_BinOp(self, node):
-        return _OP_MAP[type(node.op)](self.visit(node.left), self.visit(node.right))
-
-    # ------------------------------------------------------------------------------- #
-
-    def visit_Num(self, node):
-        return node.n
-
-    # ------------------------------------------------------------------------------- #
-
-    def visit_Expr(self, node):
-        return self.visit(node.value)
-
-    # ------------------------------------------------------------------------------- #
-
-    @classmethod
-    def doMath(cls, expression):
-        tree = ast.parse(expression)
-        calc = cls()
-        return calc.visit(tree.body[0])
-
-# ------------------------------------------------------------------------------- #
-
-
-class Parentheses(object):
-
-    def fix(self, s):
-        res = []
-        self.visited = set([s])
-        self.dfs(s, self.invalid(s), res)
-        return res
-
-    # ------------------------------------------------------------------------------- #
-
-    def dfs(self, s, n, res):
-        if n == 0:
-            res.append(s)
-            return
-        for i in range(len(s)):
-            if s[i] in ['(', ')']:
-                s_new = s[:i] + s[i + 1:]
-                if s_new not in self.visited and self.invalid(s_new) < n:
-                    self.visited.add(s_new)
-                    self.dfs(s_new, self.invalid(s_new), res)
-
-    # ------------------------------------------------------------------------------- #
-
-    def invalid(self, s):
-        plus = minus = 0
-        memo = {"(": 1, ")": -1}
-        for c in s:
-            plus += memo.get(c, 0)
-            minus += 1 if plus < 0 else 0
-            plus = max(0, plus)
-        return plus + minus
-
-# ------------------------------------------------------------------------------- #
-
-
-class ChallengeInterpreter(JavaScriptInterpreter):
-
-    def __init__(self):
-        super(ChallengeInterpreter, self).__init__('native')
-
-    # ------------------------------------------------------------------------------- #
-
-    def eval(self, body, domain):
-
-        operators = {
-            '+': op.add,
-            '-': op.sub,
-            '*': op.mul,
-            '/': op.truediv
-        }
-
-        # ------------------------------------------------------------------------------- #
-
-        def flatten(lists):
-            return sum(map(flatten, lists), []) if isinstance(lists, list) else [lists]
-
-        # ------------------------------------------------------------------------------- #
-
-        def jsfuckToNumber(jsFuck):
-            # "Clean Up" JSFuck
-            jsFuck = jsFuck.replace('!+[]', '1').replace('!![]', '1').replace('[]', '0')
-            jsFuck = jsFuck.lstrip('+').replace('(+', '(').replace(' ', '')
-            jsFuck = Parentheses().fix(jsFuck)[0]
-
-            # Hackery Parser for Math
-            stack = []
-            bstack = []
-
-            for i in flatten(pyparsing.nestedExpr().parseString(jsFuck).asList()):
-                if i == '+':
-                    stack.append(bstack)
-                    bstack = []
-                    continue
-                bstack.append(i)
-            stack.append(bstack)
-
-            return int(''.join([str(Calc.doMath(''.join(i))) for i in stack]))
-
-        # ------------------------------------------------------------------------------- #
-
-        def divisorMath(payload, needle, domain):
-            jsfuckMath = payload.split('/')
-            if needle in jsfuckMath[1]:
-                expression = re.findall(r"^(.*?)(.)\(function", jsfuckMath[1])[0]
-
-                expression_value = operators[expression[1]](
-                    float(jsfuckToNumber(expression[0])),
-                    float(ord(domain[jsfuckToNumber(jsfuckMath[1][
-                        jsfuckMath[1].find('"("+p+")")}') + len('"("+p+")")}'):-2
-                    ])]))
-                )
-            else:
-                expression_value = jsfuckToNumber(jsfuckMath[1])
-
-            expression_value = jsfuckToNumber(jsfuckMath[0]) / float(expression_value)
-
-            return expression_value
-
-        # ------------------------------------------------------------------------------- #
-
-        def challengeSolve(body, domain):
-            jschl_answer = 0
-
-            try:
-                jsfuckChallenge = re.search(
-                    r"setTimeout\(function\(\){\s+var.*?f,\s*(?P<variable>\w+).*?:(?P<init>\S+)};"
-                    r".*?\('challenge-form'\);.*?;(?P<challenge>.*?a\.value)\s*=\s*\S+\.toFixed\(10\);",
-                    body,
-                    re.DOTALL | re.MULTILINE
-                ).groupdict()
-            except AttributeError:
-                raise CloudflareSolveError('There was an issue extracting "jsfuckChallenge" from the Cloudflare challenge.')
-
-            kJSFUCK = re.search(r'(;|)\s*k.=(?P<kJSFUCK>\S+);', jsfuckChallenge['challenge'], re.S | re.M)
-            if kJSFUCK:
-                try:
-                    kJSFUCK = jsfuckToNumber(kJSFUCK.group('kJSFUCK'))
-                except IndexError:
-                    raise CloudflareSolveError('There was an issue extracting "kJSFUCK" from the Cloudflare challenge.')
-
-                try:
-                    kID = re.search(r"\s*k\s*=\s*'(?P<kID>\S+)';", body).group('kID')
-                except IndexError:
-                    raise CloudflareSolveError('There was an issue extracting "kID" from the Cloudflare challenge.')
-
-                try:
-                    r = re.compile(r'<div id="{}(?P<id>\d+)">\s*(?P<jsfuck>[^<>]*)</div>'.format(kID))
-
-                    kValues = {}
-                    for m in r.finditer(body):
-                        kValues[int(m.group('id'))] = m.group('jsfuck')
-
-                    jsfuckChallenge['k'] = kValues[kJSFUCK]
-                except (AttributeError, IndexError):
-                    raise CloudflareSolveError('There was an issue extracting "kValues" from the Cloudflare challenge.')
-
-            jsfuckChallenge['challenge'] = re.finditer(
-                r'{}.*?([+\-*/])=(.*?);(?=a\.value|{})'.format(
-                    jsfuckChallenge['variable'],
-                    jsfuckChallenge['variable']
-                ),
-                jsfuckChallenge['challenge']
-            )
-
-            # ------------------------------------------------------------------------------- #
-
-            if '/' in jsfuckChallenge['init']:
-                val = jsfuckChallenge['init'].split('/')
-                jschl_answer = jsfuckToNumber(val[0]) / float(jsfuckToNumber(val[1]))
-            else:
-                jschl_answer = jsfuckToNumber(jsfuckChallenge['init'])
-
-            # ------------------------------------------------------------------------------- #
-
-            for expressionMatch in jsfuckChallenge['challenge']:
-                oper, expression = expressionMatch.groups()
-
-                if '/' in expression:
-                    expression_value = divisorMath(expression, 'function(p)', domain)
-                else:
-                    if 'Element' in expression:
-                        expression_value = divisorMath(jsfuckChallenge['k'], '"("+p+")")}', domain)
-                    else:
-                        expression_value = jsfuckToNumber(expression)
-
-                jschl_answer = operators[oper](jschl_answer, expression_value)
-
-            # ------------------------------------------------------------------------------- #
-
-            # if not jsfuckChallenge['k'] and '+ t.length' in body:
-            #    jschl_answer += len(domain)
-
-            # ------------------------------------------------------------------------------- #
-
-            return '{0:.10f}'.format(jschl_answer)
-
-        # ------------------------------------------------------------------------------- #
-
-        return challengeSolve(body, domain)
-
-# ------------------------------------------------------------------------------- #
-
-
-ChallengeInterpreter()

package/venv/lib/python3.10/site-packages/cloudscraper/interpreters/nodejs.py

@@ -1,49 +0,0 @@
-import base64
-import subprocess
-import sys
-
-from . import JavaScriptInterpreter
-from .encapsulated import template
-
-# ------------------------------------------------------------------------------- #
-
-
-class ChallengeInterpreter(JavaScriptInterpreter):
-
-    # ------------------------------------------------------------------------------- #
-
-    def __init__(self):
-        super(ChallengeInterpreter, self).__init__('nodejs')
-
-    # ------------------------------------------------------------------------------- #
-
-    def eval(self, body, domain):
-        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(template(body, domain).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`).\n\n'
-                    '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.\n\n'
-                    '(Please read the cloudscraper README\'s Dependencies section: '
-                    'https://github.com/VeNoMouS/cloudscraper#dependencies.)'
-                )
-            raise
-        except Exception:
-            sys.tracebacklimit = 0
-            raise RuntimeError('Error executing Cloudflare IUAM Javascript in nodejs')
-
-
-# ------------------------------------------------------------------------------- #
-
-ChallengeInterpreter()

package/venv/lib/python3.10/site-packages/cloudscraper/interpreters/v8.py

@@ -1,33 +0,0 @@
-from __future__ import absolute_import
-
-import sys
-
-try:
-    import v8eval
-except ImportError:
-    sys.tracebacklimit = 0
-    raise RuntimeError('Please install the python module v8eval either via pip or download it from https://github.com/sony/v8eval')
-
-from . import JavaScriptInterpreter
-from .encapsulated import template
-
-# ------------------------------------------------------------------------------- #
-
-
-class ChallengeInterpreter(JavaScriptInterpreter):
-
-    def __init__(self):
-        super(ChallengeInterpreter, self).__init__('v8')
-
-    # ------------------------------------------------------------------------------- #
-
-    def eval(self, body, domain):
-        try:
-            return v8eval.V8().eval(template(body, domain))
-        except (TypeError, v8eval.V8Error):
-            RuntimeError('We encountered an error running the V8 Engine.')
-
-
-# ------------------------------------------------------------------------------- #
-
-ChallengeInterpreter()