crosshair-tool 0.0.99__cp312-cp312-macosx_10_13_x86_64.whl

crosshair/libimpl/jsonlib.py

@@ -0,0 +1,984 @@
+#
+# This file includes a modified version of CPython 3.10.11's pure python json
+# implementation.
+#
+# The shared source code is licensed under the PSF license and is
+# copyright © 2001-2022 Python Software Foundation; All Rights Reserved
+#
+# See the "LICENSE" file for complete license details on CrossHair.
+#
+
+
+import codecs
+import json
+import re
+
+from crosshair import register_patch
+
+#
+# Lifted from json/encoder.py:
+#
+
+"""Implementation of JSONEncoder
+"""
+c_encode_basestring_ascii = None
+c_encode_basestring = None
+c_make_encoder = None
+
+ESCAPE = re.compile(r'[\x00-\x1f\\"\b\f\n\r\t]')
+ESCAPE_ASCII = re.compile(r'([\\"]|[^\ -~])')
+HAS_UTF8 = re.compile(b"[\x80-\xff]")
+ESCAPE_DCT = {
+    "\\": "\\\\",
+    '"': '\\"',
+    "\b": "\\b",
+    "\f": "\\f",
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+}
+for i in range(0x20):
+    ESCAPE_DCT.setdefault(chr(i), "\\u{0:04x}".format(i))
+    # ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,))
+
+INFINITY = float("inf")
+
+
+def py_encode_basestring(s):
+    """Return a JSON representation of a Python string"""
+
+    def replace(match):
+        return ESCAPE_DCT[match.group(0)]
+
+    return '"' + ESCAPE.sub(replace, s) + '"'
+
+
+encode_basestring = c_encode_basestring or py_encode_basestring
+
+
+def py_encode_basestring_ascii(s):
+    """Return an ASCII-only JSON representation of a Python string"""
+
+    def replace(match):
+        s = match.group(0)
+        try:
+            return ESCAPE_DCT[s]
+        except KeyError:
+            n = ord(s)
+            if n < 0x10000:
+                return "\\u{0:04x}".format(n)
+                # return '\\u%04x' % (n,)
+            else:
+                # surrogate pair
+                n -= 0x10000
+                s1 = 0xD800 | ((n >> 10) & 0x3FF)
+                s2 = 0xDC00 | (n & 0x3FF)
+                return "\\u{0:04x}\\u{1:04x}".format(s1, s2)
+
+    return '"' + ESCAPE_ASCII.sub(replace, s) + '"'
+
+
+encode_basestring_ascii = c_encode_basestring_ascii or py_encode_basestring_ascii
+
+
+class JSONEncoder(object):
+
+    item_separator = ", "
+    key_separator = ": "
+
+    def __init__(
+        self,
+        *,
+        skipkeys=False,
+        ensure_ascii=True,
+        check_circular=True,
+        allow_nan=True,
+        sort_keys=False,
+        indent=None,
+        separators=None,
+        default=None,
+    ):
+        self.skipkeys = skipkeys
+        self.ensure_ascii = ensure_ascii
+        self.check_circular = check_circular
+        self.allow_nan = allow_nan
+        self.sort_keys = sort_keys
+        self.indent = indent
+        if separators is not None:
+            self.item_separator, self.key_separator = separators
+        elif indent is not None:
+            self.item_separator = ","
+        if default is not None:
+            self.default = default
+
+    def default(self, o):
+        raise TypeError(
+            f"Object of type {o.__class__.__name__} " f"is not JSON serializable"
+        )
+
+    def encode(self, o):
+        # This is for extremely simple cases and benchmarks.
+        if isinstance(o, str):
+            if self.ensure_ascii:
+                return encode_basestring_ascii(o)
+            else:
+                return encode_basestring(o)
+        # This doesn't pass the iterator directly to ''.join() because the
+        # exceptions aren't as detailed.  The list call should be roughly
+        # equivalent to the PySequence_Fast that ''.join() would do.
+        chunks = self.iterencode(o, _one_shot=True)
+        if not isinstance(chunks, (list, tuple)):
+            chunks = list(chunks)
+        return "".join(chunks)
+
+    def iterencode(self, o, _one_shot=False):
+        if self.check_circular:
+            markers = {}
+        else:
+            markers = None
+        if self.ensure_ascii:
+            _encoder = encode_basestring_ascii
+        else:
+            _encoder = encode_basestring
+
+        def floatstr(
+            o,
+            allow_nan=self.allow_nan,
+            _repr=float.__repr__,
+            _inf=INFINITY,
+            _neginf=-INFINITY,
+        ):
+            # Check for specials.  Note that this type of test is processor
+            # and/or platform-specific, so do tests which don't depend on the
+            # internals.
+
+            if o != o:
+                text = "NaN"
+            elif o == _inf:
+                text = "Infinity"
+            elif o == _neginf:
+                text = "-Infinity"
+            else:
+                return _repr(o)
+
+            if not allow_nan:
+                raise ValueError(
+                    "Out of range float values are not JSON compliant: " + repr(o)
+                )
+
+            return text
+
+        if _one_shot and c_make_encoder is not None and self.indent is None:
+            _iterencode = c_make_encoder(
+                markers,
+                self.default,
+                _encoder,
+                self.indent,
+                self.key_separator,
+                self.item_separator,
+                self.sort_keys,
+                self.skipkeys,
+                self.allow_nan,
+            )
+        else:
+            _iterencode = _make_iterencode(
+                markers,
+                self.default,
+                _encoder,
+                self.indent,
+                floatstr,
+                self.key_separator,
+                self.item_separator,
+                self.sort_keys,
+                self.skipkeys,
+                _one_shot,
+            )
+        return _iterencode(o, 0)
+
+
+def _make_iterencode(
+    markers,
+    _default,
+    _encoder,
+    _indent,
+    _floatstr,
+    _key_separator,
+    _item_separator,
+    _sort_keys,
+    _skipkeys,
+    _one_shot,
+    ## HACK: hand-optimized bytecode; turn globals into locals
+    ValueError=ValueError,
+    dict=dict,
+    float=float,
+    id=id,
+    int=int,
+    isinstance=isinstance,
+    list=list,
+    str=str,
+    tuple=tuple,
+    _intstr=int.__repr__,
+):
+
+    if _indent is not None and not isinstance(_indent, str):
+        _indent = " " * _indent
+
+    def _iterencode_list(lst, _current_indent_level):
+        if not lst:
+            yield "[]"
+            return
+        if markers is not None:
+            markerid = id(lst)
+            if markerid in markers:
+                raise ValueError("Circular reference detected")
+            markers[markerid] = lst
+        buf = "["
+        if _indent is not None:
+            _current_indent_level += 1
+            newline_indent = "\n" + _indent * _current_indent_level
+            separator = _item_separator + newline_indent
+            buf += newline_indent
+        else:
+            newline_indent = None
+            separator = _item_separator
+        first = True
+        for value in lst:
+            if first:
+                first = False
+            else:
+                buf = separator
+            if isinstance(value, str):
+                yield buf + _encoder(value)
+            elif value is None:
+                yield buf + "null"
+            elif value is True:
+                yield buf + "true"
+            elif value is False:
+                yield buf + "false"
+            elif isinstance(value, int):
+                # Subclasses of int/float may override __repr__, but we still
+                # want to encode them as integers/floats in JSON. One example
+                # within the standard library is IntEnum.
+                yield buf + _intstr(value)
+            elif isinstance(value, float):
+                # see comment above for int
+                yield buf + _floatstr(value)
+            else:
+                yield buf
+                if isinstance(value, (list, tuple)):
+                    chunks = _iterencode_list(value, _current_indent_level)
+                elif isinstance(value, dict):
+                    chunks = _iterencode_dict(value, _current_indent_level)
+                else:
+                    chunks = _iterencode(value, _current_indent_level)
+                yield from chunks
+        if newline_indent is not None:
+            _current_indent_level -= 1
+            yield "\n" + _indent * _current_indent_level
+        yield "]"
+        if markers is not None:
+            del markers[markerid]
+
+    def _iterencode_dict(dct, _current_indent_level):
+        if not dct:
+            yield "{}"
+            return
+        if markers is not None:
+            markerid = id(dct)
+            if markerid in markers:
+                raise ValueError("Circular reference detected")
+            markers[markerid] = dct
+        yield "{"
+        if _indent is not None:
+            _current_indent_level += 1
+            newline_indent = "\n" + _indent * _current_indent_level
+            item_separator = _item_separator + newline_indent
+            yield newline_indent
+        else:
+            newline_indent = None
+            item_separator = _item_separator
+        first = True
+        if _sort_keys:
+            items = sorted(dct.items())
+        else:
+            items = dct.items()
+        for key, value in items:
+            if isinstance(key, str):
+                pass
+            # JavaScript is weakly typed for these, so it makes sense to
+            # also allow them.  Many encoders seem to do something like this.
+            elif isinstance(key, float):
+                # see comment for int/float in _make_iterencode
+                key = _floatstr(key)
+            elif key is True:
+                key = "true"
+            elif key is False:
+                key = "false"
+            elif key is None:
+                key = "null"
+            elif isinstance(key, int):
+                # see comment for int/float in _make_iterencode
+                key = _intstr(key)
+            elif _skipkeys:
+                continue
+            else:
+                raise TypeError(
+                    f"keys must be str, int, float, bool or None, "
+                    f"not {key.__class__.__name__}"
+                )
+            if first:
+                first = False
+            else:
+                yield item_separator
+            yield _encoder(key)
+            yield _key_separator
+            if isinstance(value, str):
+                yield _encoder(value)
+            elif value is None:
+                yield "null"
+            elif value is True:
+                yield "true"
+            elif value is False:
+                yield "false"
+            elif isinstance(value, int):
+                # see comment for int/float in _make_iterencode
+                yield _intstr(value)
+            elif isinstance(value, float):
+                # see comment for int/float in _make_iterencode
+                yield _floatstr(value)
+            else:
+                if isinstance(value, (list, tuple)):
+                    chunks = _iterencode_list(value, _current_indent_level)
+                elif isinstance(value, dict):
+                    chunks = _iterencode_dict(value, _current_indent_level)
+                else:
+                    chunks = _iterencode(value, _current_indent_level)
+                yield from chunks
+        if newline_indent is not None:
+            _current_indent_level -= 1
+            yield "\n" + _indent * _current_indent_level
+        yield "}"
+        if markers is not None:
+            del markers[markerid]
+
+    def _iterencode(o, _current_indent_level):
+        if isinstance(o, str):
+            yield _encoder(o)
+        elif o is None:
+            yield "null"
+        elif o is True:
+            yield "true"
+        elif o is False:
+            yield "false"
+        elif isinstance(o, int):
+            # see comment for int/float in _make_iterencode
+            yield _intstr(o)
+        elif isinstance(o, float):
+            # see comment for int/float in _make_iterencode
+            yield _floatstr(o)
+        elif isinstance(o, (list, tuple)):
+            yield from _iterencode_list(o, _current_indent_level)
+        elif isinstance(o, dict):
+            yield from _iterencode_dict(o, _current_indent_level)
+        else:
+            if markers is not None:
+                markerid = id(o)
+                if markerid in markers:
+                    raise ValueError("Circular reference detected")
+                markers[markerid] = o
+            o = _default(o)
+            yield from _iterencode(o, _current_indent_level)
+            if markers is not None:
+                del markers[markerid]
+
+    return _iterencode
+
+
+#
+# Lifted from json/scanner.py:
+#
+
+"""JSON token scanner
+"""
+c_make_scanner = None
+
+# CrossHair-specific tweak: change the NUMBER_RE regex.
+# The pure python scanner accepts unicode digits, but the C-based scanner does not.
+# Patch json.scanner.NUMBER_RE to include the re.ASCII flag:
+NUMBER_RE = re.compile(
+    r"(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?",
+    (re.VERBOSE | re.MULTILINE | re.DOTALL | re.ASCII),
+)
+
+
+def py_make_scanner(context):
+    parse_object = context.parse_object
+    parse_array = context.parse_array
+    parse_string = context.parse_string
+    match_number = NUMBER_RE.match
+    strict = context.strict
+    parse_float = context.parse_float
+    parse_int = context.parse_int
+    parse_constant = context.parse_constant
+    object_hook = context.object_hook
+    object_pairs_hook = context.object_pairs_hook
+    memo = context.memo
+
+    def _scan_once(string, idx):
+        try:
+            nextchar = string[idx]
+        except IndexError:
+            raise StopIteration(idx) from None
+
+        if nextchar == '"':
+            return parse_string(string, idx + 1, strict)
+        elif nextchar == "{":
+            return parse_object(
+                (string, idx + 1),
+                strict,
+                _scan_once,
+                object_hook,
+                object_pairs_hook,
+                memo,
+            )
+        elif nextchar == "[":
+            return parse_array((string, idx + 1), _scan_once)
+        elif nextchar == "n" and string[idx : idx + 4] == "null":
+            return None, idx + 4
+        elif nextchar == "t" and string[idx : idx + 4] == "true":
+            return True, idx + 4
+        elif nextchar == "f" and string[idx : idx + 5] == "false":
+            return False, idx + 5
+
+        m = match_number(string, idx)
+        if m is not None:
+            integer, frac, exp = m.groups()
+            if frac or exp:
+                res = parse_float(integer + (frac or "") + (exp or ""))
+            else:
+                res = parse_int(integer)
+            return res, m.end()
+        elif nextchar == "N" and string[idx : idx + 3] == "NaN":
+            return parse_constant("NaN"), idx + 3
+        elif nextchar == "I" and string[idx : idx + 8] == "Infinity":
+            return parse_constant("Infinity"), idx + 8
+        elif nextchar == "-" and string[idx : idx + 9] == "-Infinity":
+            return parse_constant("-Infinity"), idx + 9
+        else:
+            raise StopIteration(idx)
+
+    def scan_once(string, idx):
+        try:
+            return _scan_once(string, idx)
+        finally:
+            memo.clear()
+
+    return scan_once
+
+
+make_scanner = c_make_scanner or py_make_scanner
+
+#
+# Lifted from json/decoder.py:
+#
+
+"""Implementation of JSONDecoder
+"""
+c_scanstring = None
+
+FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL
+
+NaN = float("nan")
+PosInf = float("inf")
+NegInf = float("-inf")
+
+
+from json import JSONDecodeError
+
+_CONSTANTS = {
+    "-Infinity": NegInf,
+    "Infinity": PosInf,
+    "NaN": NaN,
+}
+
+
+STRINGCHUNK = re.compile(r'(.*?)(["\\\x00-\x1f])', FLAGS)
+BACKSLASH = {
+    '"': '"',
+    "\\": "\\",
+    "/": "/",
+    "b": "\b",
+    "f": "\f",
+    "n": "\n",
+    "r": "\r",
+    "t": "\t",
+}
+
+
+def _decode_uXXXX(s, pos):
+    esc = s[pos + 1 : pos + 5]
+    if len(esc) == 4 and esc[1] not in "xX":
+        try:
+            return int(esc, 16)
+        except ValueError:
+            pass
+    msg = "Invalid \\uXXXX escape"
+    raise JSONDecodeError(msg, s, pos)
+
+
+def py_scanstring(s, end, strict=True, _b=BACKSLASH, _m=STRINGCHUNK.match):
+    chunks = []
+    _append = chunks.append
+    begin = end - 1
+    while 1:
+        chunk = _m(s, end)
+        if chunk is None:
+            raise JSONDecodeError("Unterminated string starting at", s, begin)
+        end = chunk.end()
+        content, terminator = chunk.groups()
+        # Content is contains zero or more unescaped string characters
+        if content:
+            _append(content)
+        # Terminator is the end of string, a literal control character,
+        # or a backslash denoting that an escape sequence follows
+        if terminator == '"':
+            break
+        elif terminator != "\\":
+            if strict:
+                # msg = "Invalid control character %r at" % (terminator,)
+                msg = "Invalid control character {0!r} at".format(terminator)
+                raise JSONDecodeError(msg, s, end)
+            else:
+                _append(terminator)
+                continue
+        try:
+            esc = s[end]
+        except IndexError:
+            raise JSONDecodeError("Unterminated string starting at", s, begin) from None
+        # If not a unicode escape sequence, must be in the lookup table
+        if esc != "u":
+            try:
+                char = _b[esc]
+            except KeyError:
+                msg = "Invalid \\escape: {0!r}".format(esc)
+                raise JSONDecodeError(msg, s, end)
+            end += 1
+        else:
+            uni = _decode_uXXXX(s, end)
+            end += 5
+            if 0xD800 <= uni <= 0xDBFF and s[end : end + 2] == "\\u":
+                uni2 = _decode_uXXXX(s, end + 1)
+                if 0xDC00 <= uni2 <= 0xDFFF:
+                    uni = 0x10000 + (((uni - 0xD800) << 10) | (uni2 - 0xDC00))
+                    end += 6
+            char = chr(uni)
+        _append(char)
+    return "".join(chunks), end
+
+
+# Use speedup if available
+scanstring = c_scanstring or py_scanstring
+
+WHITESPACE = re.compile(r"[ \t\n\r]*", FLAGS)
+WHITESPACE_STR = " \t\n\r"
+
+
+def JSONObject(
+    s_and_end,
+    strict,
+    scan_once,
+    object_hook,
+    object_pairs_hook,
+    memo=None,
+    _w=WHITESPACE.match,
+    _ws=WHITESPACE_STR,
+):
+    s, end = s_and_end
+    pairs = []
+    pairs_append = pairs.append
+    # Backwards compatibility
+    if memo is None:
+        memo = {}
+    memo_get = memo.setdefault
+    # Use a slice to prevent IndexError from being raised, the following
+    # check will raise a more specific ValueError if the string is empty
+    nextchar = s[end : end + 1]
+    # Normally we expect nextchar == '"'
+    if nextchar != '"':
+        if nextchar in _ws:
+            end = _w(s, end).end()
+            nextchar = s[end : end + 1]
+        # Trivial empty object
+        if nextchar == "}":
+            if object_pairs_hook is not None:
+                result = object_pairs_hook(pairs)
+                return result, end + 1
+            pairs = {}
+            if object_hook is not None:
+                pairs = object_hook(pairs)
+            return pairs, end + 1
+        elif nextchar != '"':
+            raise JSONDecodeError(
+                "Expecting property name enclosed in double quotes", s, end
+            )
+    end += 1
+    while True:
+        key, end = scanstring(s, end, strict)
+        key = memo_get(key, key)
+        # To skip some function call overhead we optimize the fast paths where
+        # the JSON key separator is ": " or just ":".
+        if s[end : end + 1] != ":":
+            end = _w(s, end).end()
+            if s[end : end + 1] != ":":
+                raise JSONDecodeError("Expecting ':' delimiter", s, end)
+        end += 1
+
+        try:
+            if s[end] in _ws:
+                end += 1
+                if s[end] in _ws:
+                    end = _w(s, end + 1).end()
+        except IndexError:
+            pass
+
+        try:
+            value, end = scan_once(s, end)
+        except StopIteration as err:
+            raise JSONDecodeError("Expecting value", s, err.value) from None
+        pairs_append((key, value))
+        try:
+            nextchar = s[end]
+            if nextchar in _ws:
+                end = _w(s, end + 1).end()
+                nextchar = s[end]
+        except IndexError:
+            nextchar = ""
+        end += 1
+
+        if nextchar == "}":
+            break
+        elif nextchar != ",":
+            raise JSONDecodeError("Expecting ',' delimiter", s, end - 1)
+        end = _w(s, end).end()
+        nextchar = s[end : end + 1]
+        end += 1
+        if nextchar != '"':
+            raise JSONDecodeError(
+                "Expecting property name enclosed in double quotes", s, end - 1
+            )
+    if object_pairs_hook is not None:
+        result = object_pairs_hook(pairs)
+        return result, end
+    pairs = dict(pairs)
+    if object_hook is not None:
+        pairs = object_hook(pairs)
+    return pairs, end
+
+
+def JSONArray(s_and_end, scan_once, _w=WHITESPACE.match, _ws=WHITESPACE_STR):
+    s, end = s_and_end
+    values = []
+    nextchar = s[end : end + 1]
+    if nextchar in _ws:
+        end = _w(s, end + 1).end()
+        nextchar = s[end : end + 1]
+    # Look-ahead for trivial empty array
+    if nextchar == "]":
+        return values, end + 1
+    _append = values.append
+    while True:
+        try:
+            value, end = scan_once(s, end)
+        except StopIteration as err:
+            raise JSONDecodeError("Expecting value", s, err.value) from None
+        _append(value)
+        nextchar = s[end : end + 1]
+        if nextchar in _ws:
+            end = _w(s, end + 1).end()
+            nextchar = s[end : end + 1]
+        end += 1
+        if nextchar == "]":
+            break
+        elif nextchar != ",":
+            raise JSONDecodeError("Expecting ',' delimiter", s, end - 1)
+        try:
+            if s[end] in _ws:
+                end += 1
+                if s[end] in _ws:
+                    end = _w(s, end + 1).end()
+        except IndexError:
+            pass
+
+    return values, end
+
+
+class JSONDecoder(object):
+    def __init__(
+        self,
+        *,
+        object_hook=None,
+        parse_float=None,
+        parse_int=None,
+        parse_constant=None,
+        strict=True,
+        object_pairs_hook=None,
+    ):
+        self.object_hook = object_hook
+        self.parse_float = parse_float or float
+        self.parse_int = parse_int or int
+        self.parse_constant = parse_constant or _CONSTANTS.__getitem__
+        self.strict = strict
+        self.object_pairs_hook = object_pairs_hook
+        self.parse_object = JSONObject
+        self.parse_array = JSONArray
+        self.parse_string = scanstring
+        self.memo = {}
+        self.scan_once = make_scanner(self)
+
+    def decode(self, s, _w=WHITESPACE.match):
+        obj, end = self.raw_decode(s, idx=_w(s, 0).end())
+        end = _w(s, end).end()
+        if end != len(s):
+            raise JSONDecodeError("Extra data", s, end)
+        return obj
+
+    def raw_decode(self, s, idx=0):
+        try:
+            obj, end = self.scan_once(s, idx)
+        except StopIteration as err:
+            raise JSONDecodeError("Expecting value", s, err.value) from None
+        return obj, end
+
+
+#
+# Lifted from json/__init__.py
+#
+
+_default_encoder = JSONEncoder(
+    skipkeys=False,
+    ensure_ascii=True,
+    check_circular=True,
+    allow_nan=True,
+    indent=None,
+    separators=None,
+    default=None,
+)
+
+
+def dump(
+    obj,
+    fp,
+    *,
+    skipkeys=False,
+    ensure_ascii=True,
+    check_circular=True,
+    allow_nan=True,
+    cls=None,
+    indent=None,
+    separators=None,
+    default=None,
+    sort_keys=False,
+    **kw,
+):
+    # cached encoder
+    if (
+        not skipkeys
+        and ensure_ascii
+        and check_circular
+        and allow_nan
+        and cls is None
+        and indent is None
+        and separators is None
+        and default is None
+        and not sort_keys
+        and not kw
+    ):
+        iterable = _default_encoder.iterencode(obj)
+    else:
+        if cls is None:
+            cls = JSONEncoder
+        iterable = cls(
+            skipkeys=skipkeys,
+            ensure_ascii=ensure_ascii,
+            check_circular=check_circular,
+            allow_nan=allow_nan,
+            indent=indent,
+            separators=separators,
+            default=default,
+            sort_keys=sort_keys,
+            **kw,
+        ).iterencode(obj)
+    # could accelerate with writelines in some versions of Python, at
+    # a debuggability cost
+    for chunk in iterable:
+        fp.write(chunk)
+
+
+def dumps(
+    obj,
+    *,
+    skipkeys=False,
+    ensure_ascii=True,
+    check_circular=True,
+    allow_nan=True,
+    cls=None,
+    indent=None,
+    separators=None,
+    default=None,
+    sort_keys=False,
+    **kw,
+):
+    # cached encoder
+    if (
+        not skipkeys
+        and ensure_ascii
+        and check_circular
+        and allow_nan
+        and cls is None
+        and indent is None
+        and separators is None
+        and default is None
+        and not sort_keys
+        and not kw
+    ):
+        return _default_encoder.encode(obj)
+    if cls is None:
+        cls = JSONEncoder
+    return cls(
+        skipkeys=skipkeys,
+        ensure_ascii=ensure_ascii,
+        check_circular=check_circular,
+        allow_nan=allow_nan,
+        indent=indent,
+        separators=separators,
+        default=default,
+        sort_keys=sort_keys,
+        **kw,
+    ).encode(obj)
+
+
+_default_decoder = JSONDecoder(object_hook=None, object_pairs_hook=None)
+
+
+def detect_encoding(b):
+    bstartswith = b.startswith
+    if bstartswith((codecs.BOM_UTF32_BE, codecs.BOM_UTF32_LE)):
+        return "utf-32"
+    if bstartswith((codecs.BOM_UTF16_BE, codecs.BOM_UTF16_LE)):
+        return "utf-16"
+    if bstartswith(codecs.BOM_UTF8):
+        return "utf-8-sig"
+
+    if len(b) >= 4:
+        if not b[0]:
+            # 00 00 -- -- - utf-32-be
+            # 00 XX -- -- - utf-16-be
+            return "utf-16-be" if b[1] else "utf-32-be"
+        if not b[1]:
+            # XX 00 00 00 - utf-32-le
+            # XX 00 00 XX - utf-16-le
+            # XX 00 XX -- - utf-16-le
+            return "utf-16-le" if b[2] or b[3] else "utf-32-le"
+    elif len(b) == 2:
+        if not b[0]:
+            # 00 XX - utf-16-be
+            return "utf-16-be"
+        if not b[1]:
+            # XX 00 - utf-16-le
+            return "utf-16-le"
+    # default
+    return "utf-8"
+
+
+def load(
+    fp,
+    *,
+    cls=None,
+    object_hook=None,
+    parse_float=None,
+    parse_int=None,
+    parse_constant=None,
+    object_pairs_hook=None,
+    **kw,
+):
+    return loads(
+        fp.read(),
+        cls=cls,
+        object_hook=object_hook,
+        parse_float=parse_float,
+        parse_int=parse_int,
+        parse_constant=parse_constant,
+        object_pairs_hook=object_pairs_hook,
+        **kw,
+    )
+
+
+def loads(
+    s,
+    *,
+    cls=None,
+    object_hook=None,
+    parse_float=None,
+    parse_int=None,
+    parse_constant=None,
+    object_pairs_hook=None,
+    **kw,
+):
+    if isinstance(s, str):
+        if s.startswith("\ufeff"):
+            raise JSONDecodeError("Unexpected UTF-8 BOM (decode using utf-8-sig)", s, 0)
+    else:
+        if not isinstance(s, (bytes, bytearray)):
+            raise TypeError(
+                f"the JSON object must be str, bytes or bytearray, "
+                f"not {s.__class__.__name__}"
+            )
+        s = s.decode(detect_encoding(s), "surrogatepass")
+
+    if (
+        cls is None
+        and object_hook is None
+        and parse_int is None
+        and parse_float is None
+        and parse_constant is None
+        and object_pairs_hook is None
+        and not kw
+    ):
+        return _default_decoder.decode(s)
+    if cls is None:
+        cls = JSONDecoder
+    if object_hook is not None:
+        kw["object_hook"] = object_hook
+    if object_pairs_hook is not None:
+        kw["object_pairs_hook"] = object_pairs_hook
+    if parse_float is not None:
+        kw["parse_float"] = parse_float
+    if parse_int is not None:
+        kw["parse_int"] = parse_int
+    if parse_constant is not None:
+        kw["parse_constant"] = parse_constant
+    return cls(**kw).decode(s)
+
+
+#
+# CrossHair-specific code
+#
+
+
+def make_registrations() -> None:
+    register_patch(json.dump, dump)
+    register_patch(json.dumps, dumps)
+    register_patch(json.load, load)
+    register_patch(json.loads, loads)
+    register_patch(json.JSONEncoder.default, JSONEncoder.default)
+    register_patch(json.JSONEncoder.encode, JSONEncoder.encode)
+    register_patch(json.JSONEncoder.iterencode, JSONEncoder.iterencode)
+    register_patch(json.JSONDecoder.decode, JSONDecoder.decode)
+    register_patch(json.JSONDecoder.raw_decode, JSONDecoder.raw_decode)
+
+    # Not in the official API ,but used by some packages like hypothesis-jsonschema:
+    register_patch(json.encoder._make_iterencode, _make_iterencode)  # type: ignore
+    register_patch(json.encoder.encode_basestring_ascii, encode_basestring_ascii)  # type: ignore
+
+    # TODO: Not in official API, but perhaps add some of these?:
+    #   decoder, detect_encoding, encoder, scanner, make_scanner