From 855ce5bba90ad73d2f687e67a5abb1d4f00bee29 Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Tue, 22 Oct 2024 10:03:34 -0700
Subject: [PATCH 01/30] [Feature] Enable user-passed `separators` keyword to
 `guidance.json` (#1044)

Main changes:
1. Refactor json generation code to live in a class with
guidance-decorated methods (allows separators to be set at the instance
level rather than having to pass them to every function call; note that
`definitions` are now also stored on the instance)
2. Add `separators` kwarg that controls the strings we will use for item
and key separators (`", "` and `": "` by default). This mirrors the
`json.dumps` API.
3. Add `whitespace_flexible` kwarg to enable old default behavior of
"letting the LLM decide" on whitespace. This is no longer the default
behavior, as it is substantially less efficient from a
guidance-acceleration standpoint.
4. Deprecate `compact` kwarg in favor of `separators = (",", ":")`
5. Proper handling of `const` and `enum` types to ensure correct lexical
boundaries (these were previously incorrectly handled from the point of
view of whitespace flexibility).
6. Change existing tests to reflect the new default behavior
7. Add explicit whitespace tests for cases where `separators` or
`whitespace_flexible` are passed
---
 guidance/library/_json.py                    | 866 ++++++++++---------
 tests/server/test_server.py                  |   6 +-
 tests/unit/library/test_json.py              | 439 ++++------
 tests/unit/library/test_json_stringformat.py |  38 +-
 tests/unit/library/test_pydantic.py          |  59 +-
 5 files changed, 688 insertions(+), 720 deletions(-)

diff --git a/guidance/library/_json.py b/guidance/library/_json.py
index c4a45f035..a7d3354b4 100644
--- a/guidance/library/_json.py
+++ b/guidance/library/_json.py
@@ -32,14 +32,6 @@
 
 JSONSchema = Union[bool, Mapping[str, Any]]
 
-def _to_compact_json(target: Any) -> str:
-    # See 'Compact Encoding':
-    # https://docs.python.org/3/library/json.html
-    # Since this is ultimately about the generated
-    # output, we don't need to worry about pretty printing
-    # and whitespace
-    return json_dumps(target, separators=(",", ":"))
-
 DRAFT202012_RESERVED_KEYWORDS = {
     # Anchors and References
     '$anchor',
@@ -402,386 +394,479 @@ def validate_json_node_keys(node: Mapping[str, Any]):
         )
 
 
-@guidance(stateless=True)
-def _gen_json_int(lm, minimum: Union[float, int, None] = None, maximum: Union[float, int, None] = None, exclusiveMinimum: bool = False, exclusiveMaximum: bool = False):
-    if minimum is not None:
-        if exclusiveMinimum:
-            if minimum != int(minimum):
+class GenJson:
+    item_separator = ", "
+    key_separator = ": "
+    def __init__(self, schema: JSONSchema, separators: Optional[tuple[str, str]] = None) -> None:
+        self.schema = schema
+        if separators is not None:
+            self.item_separator, self.key_separator = separators
+        if isinstance(schema, Mapping):
+            self.definitions = self._build_definitions(schema.get("$defs", schema.get("definitions", {})))
+        else:
+            self.definitions = {}
+
+    def _build_definitions(
+        self,
+        raw_definitions: Mapping[str, JSONSchema],
+    ) -> Mapping[str, Callable[[], GrammarFunction]]:
+        definitions: Dict[str, Callable[[], GrammarFunction]] = {}
+
+        def build_definition(json_schema: JSONSchema) -> Callable[[], GrammarFunction]:
+            @guidance(stateless=True, dedent=False, cache=True)
+            def closure(lm):
+                return lm + self.json(json_schema=json_schema)
+
+            return closure
+
+        definitions = {ref: build_definition(schema) for ref, schema in raw_definitions.items()}
+        return definitions
+
+    @guidance(stateless=True)
+    def root(self, lm):
+        return lm + self.json(json_schema=self.schema)
+
+    @classmethod
+    @guidance(stateless=True)
+    def integer(cls, lm, minimum: Union[float, int, None] = None, maximum: Union[float, int, None] = None, exclusiveMinimum: bool = False, exclusiveMaximum: bool = False):
+        if minimum is not None:
+            if exclusiveMinimum:
+                if minimum != int(minimum):
+                    minimum = math.ceil(minimum)
+                else:
+                    minimum += 1
+            else:
                 minimum = math.ceil(minimum)
+            minimum = int(minimum)
+        if maximum is not None:
+            if exclusiveMaximum:
+                if maximum != int(maximum):
+                    maximum = math.floor(maximum)
+                else:
+                    maximum -= 1
             else:
-                minimum += 1
-        else:
-            minimum = math.ceil(minimum)
-        minimum = int(minimum)
-
-    if maximum is not None:
-        if exclusiveMaximum:
-            if maximum != int(maximum):
                 maximum = math.floor(maximum)
-            else:
-                maximum -= 1
-        else:
-            maximum = math.floor(maximum)
-        maximum = int(maximum)
+            maximum = int(maximum)
 
-    return lm + lexeme(rx_int_range(minimum, maximum), contextual=True)
+        return lm + lexeme(rx_int_range(minimum, maximum), contextual=True)
 
-@guidance(stateless=True)
-def _gen_json_number(lm, minimum: Optional[float] = None, maximum: Optional[float] = None, exclusiveMinimum: bool = False, exclusiveMaximum: bool = False):
-    return lm + lexeme(
-        rx_float_range(
-            minimum, maximum,
-            left_inclusive = not exclusiveMinimum,
-            right_inclusive = not exclusiveMaximum
-        ),
-        contextual=True
-    )
 
-@guidance(stateless=True)
-def _gen_json_string(
-    lm,
-    min_length: int = 0,
-    max_length: Union[int, None] = None,
-    regex: Union[str, None] = None,
-    format: Union[str, None] = None,
-):
-    if (regex is not None or format is not None) and (min_length > 0 or max_length is not None):
-        raise ValueError(
-            "If a pattern or format is specified for a JSON string, minLength and maxLength must be left unspecified."
+    @classmethod
+    @guidance(stateless=True)
+    def number(cls, lm, minimum: Optional[float] = None, maximum: Optional[float] = None, exclusiveMinimum: bool = False, exclusiveMaximum: bool = False):
+        return lm + lexeme(
+            rx_float_range(
+                minimum, maximum,
+                left_inclusive = not exclusiveMinimum,
+                right_inclusive = not exclusiveMaximum
+            ),
+            contextual=True
         )
 
-    if regex is not None and format is not None:
-        raise ValueError("Cannot specify both a regex and a format for a JSON string")
-
-    if format is not None:
-        regex = _get_format_pattern(format)
-
-    elif regex is not None:
-        # Sanitize the regex, removing unnecessary anchors that may cause problems later
-        # NOTE/TODO: this could potentially be pushed further down into the lexeme function,
-        # but it's not immediately clear whether anchors in other contexts are superfluous.
-        regex = regex.lstrip("^").rstrip("$")
-
-    elif regex is None:
-        range_expr = f"{{{min_length},{max_length}}}" if max_length is not None else f"{{{min_length},}}"
-        regex = f"(?s:.{range_expr})"
-
-    return lm + lexeme(regex, contextual=True, json_string=True)
-
 
-@guidance(stateless=True)
-def _gen_json_object(
-    lm,
-    *,
-    properties: Mapping[str, JSONSchema],
-    additional_properties: JSONSchema,
-    required: Sequence[str],
-    definitions: Mapping[str, Callable[[], GrammarFunction]],
-):
-    # "required" keys will be validated against "properties" if they're present, otherwise against "additionalProperties".
-    # If "additionalProperties" is False, then required keys must be in "properties".
-    if any(k not in properties for k in required) and additional_properties is False:
-        raise ValueError(
-            f"Required properties not in properties but additionalProperties is False."
-            f" Missing required properties: {list(r for r in required if r not in properties)}"
-        )
-    items = [
-        # First iterate over the properties in order
-        *properties.items(),
-        # If there are any keys in required that weren't specified by properties, add them in order at the end,
-        # where we will validate against the additional_properties schema
-        *((key, additional_properties) for key in required if key not in properties),
-    ]
-    grammars = tuple(f'"{name}":' + _gen_json(json_schema=schema, definitions=definitions) for name, schema in items)
-    required_items = tuple(name in required for name, _ in items)
-    names = set(properties.keys()) | set(required)
-    key_grammar: GrammarFunction
-    if len(names) > 0:
-        # If there are any properties, we need to disallow them as additionalProperties
-        key_grammar = as_regular_grammar(
-            And([
-                lexeme(r'"([^"\\]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*"'),
-                Not(lexeme('"(' + '|'.join(quote_regex(name) for name in names) + ')"')),
-            ]),
-            lexeme = True,
-        )
-    else:
-        key_grammar = _gen_json_string()
-    if additional_properties is not False:
-        additional_item_grammar =  key_grammar + ':' + _gen_json(json_schema=additional_properties, definitions=definitions)
-        additional_items_grammar = sequence(additional_item_grammar + ',') + additional_item_grammar
-        grammars += (additional_items_grammar,)
-        required_items += (False,)
-
-    return lm + "{" + _gen_list(
-        elements = grammars,
-        required = required_items,
-    ) + "}"
-
-@guidance(stateless=True, cache=True)
-def _gen_list(lm, *, elements: tuple[GrammarFunction, ...], required: tuple[bool, ...], prefixed: bool = False):
-    if not elements:
-        return lm
-
-    elem, elements = elements[0], elements[1:]
-    is_required, required = required[0], required[1:]
+    @classmethod
+    @guidance(stateless=True)
+    def string(
+        cls,
+        lm,
+        *,
+        min_length: int = 0,
+        max_length: Union[int, None] = None,
+        regex: Union[str, None] = None,
+        format: Union[str, None] = None,
+    ):
+        if (regex is not None or format is not None) and (min_length > 0 or max_length is not None):
+            raise ValueError(
+                "If a pattern or format is specified for a JSON string, minLength and maxLength must be left unspecified."
+            )
 
-    if prefixed:
+        if regex is not None and format is not None:
+            raise ValueError("Cannot specify both a regex and a format for a JSON string")
+
+        if format is not None:
+            regex = _get_format_pattern(format)
+
+        elif regex is not None:
+            # Sanitize the regex, removing unnecessary anchors that may cause problems later
+            # NOTE/TODO: this could potentially be pushed further down into the lexeme function,
+            # but it's not immediately clear whether anchors in other contexts are superfluous.
+            regex = regex.lstrip("^").rstrip("$")
+
+        elif regex is None:
+            range_expr = f"{{{min_length},{max_length}}}" if max_length is not None else f"{{{min_length},}}"
+            regex = f"(?s:.{range_expr})"
+
+        return lm + lexeme(regex, contextual=True, json_string=True)
+
+
+    @guidance(stateless=True)
+    def object(
+        self,
+        lm,
+        *,
+        properties: Mapping[str, JSONSchema],
+        additional_properties: JSONSchema,
+        required: Sequence[str],
+    ):
+        # "required" keys will be validated against "properties" if they're present, otherwise against "additionalProperties".
+        # If "additionalProperties" is False, then required keys must be in "properties".
+        if any(k not in properties for k in required) and additional_properties is False:
+            raise ValueError(
+                f"Required properties not in properties but additionalProperties is False."
+                f" Missing required properties: {list(r for r in required if r not in properties)}"
+            )
+        items = [
+            # First iterate over the properties in order
+            *properties.items(),
+            # If there are any keys in required that weren't specified by properties, add them in order at the end,
+            # where we will validate against the additional_properties schema
+            *((key, additional_properties) for key in required if key not in properties),
+        ]
+        grammars = tuple(f'"{name}"{self.key_separator}' + self.json(json_schema=schema) for name, schema in items)
+        required_items = tuple(name in required for name, _ in items)
+        names = set(properties.keys()) | set(required)
+        key_grammar: GrammarFunction
+        if len(names) > 0:
+            # If there are any properties, we need to disallow them as additionalProperties
+            key_grammar = as_regular_grammar(
+                And([
+                    lexeme(r'"([^"\\]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*"'),
+                    Not(lexeme('"(' + '|'.join(quote_regex(name) for name in names) + ')"')),
+                ]),
+                lexeme = True,
+            )
+        else:
+            key_grammar = self.string()
+        if additional_properties is not False:
+            additional_item_grammar = key_grammar + self.key_separator + self.json(json_schema=additional_properties)
+            additional_items_grammar = sequence(additional_item_grammar + self.item_separator) + additional_item_grammar
+            grammars += (additional_items_grammar,)
+            required_items += (False,)
+
+        return lm + "{" + self._join(
+            elements = grammars,
+            required = required_items,
+        ) + "}"
+
+
+    @guidance(stateless=True, cache=True)
+    def _join(self, lm, *, elements: tuple[GrammarFunction, ...], required: tuple[bool, ...], prefixed: bool = False):
+        if not elements:
+            return lm
+
+        elem, elements = elements[0], elements[1:]
+        is_required, required = required[0], required[1:]
+
+        if prefixed:
+            if is_required:
+                # If we know we have preceeding elements, we can safely just add a (',' + e)
+                return lm + (self.item_separator + elem + self._join(elements=elements, required=required, prefixed=True))
+            # If we know we have preceeding elements, we can safely just add an optional(',' + e)
+            return lm + (optional(self.item_separator + elem) + self._join(elements=elements, required=required, prefixed=True))
         if is_required:
-            # If we know we have preceeding elements, we can safely just add a (',' + e)
-            return lm + (',' + elem + _gen_list(elements=elements, required=required, prefixed=True))
-        # If we know we have preceeding elements, we can safely just add an optional(',' + e)
-        return lm + (optional(',' + elem) + _gen_list(elements=elements, required=required, prefixed=True))
-    if is_required:
-        # No preceding elements, and our element is required, so we just add the element
-        return lm + (elem + _gen_list(elements=elements, required=required, prefixed=True))
-
-    # No preceding elements, and our element is optional, so we add a select between the two options.
-    # The first option is the recursive call with no preceding elements, the second is the recursive call
-    # with the current element as a prefix.
-    return lm + select([
-        _gen_list(elements=elements, required=required, prefixed=False),
-        elem + _gen_list(elements=elements, required=required, prefixed=True)
-    ])
+            # No preceding elements, and our element is required, so we just add the element
+            return lm + (elem + self._join(elements=elements, required=required, prefixed=True))
+
+        # No preceding elements, and our element is optional, so we add a select between the two options.
+        # The first option is the recursive call with no preceding elements, the second is the recursive call
+        # with the current element as a prefix.
+        return lm + select([
+            self._join(elements=elements, required=required, prefixed=False),
+            elem + self._join(elements=elements, required=required, prefixed=True)
+        ])
+
+
+    @guidance(stateless=True)
+    def array(
+        self,
+        lm,
+        *,
+        prefix_items_schema: Sequence[JSONSchema],
+        item_schema: JSONSchema,
+        min_items: int,
+        max_items: Optional[int],
+    ):
+        if len(prefix_items_schema) < min_items and item_schema is False:
+            raise ValueError(
+                f"PrefixItems has too few elements ({len(prefix_items_schema)}) to"
+                f" satisfy minItems ({min_items}) but no extra items were allowed"
+            )
 
+        if max_items is not None and max_items < min_items:
+            raise ValueError(f"maxItems ({max_items}) can't be less than minItems ({min_items})")
 
-@guidance(stateless=True)
-def _gen_json_array(
-    lm,
-    *,
-    prefix_items_schema: Sequence[JSONSchema],
-    item_schema: JSONSchema,
-    min_items: int,
-    max_items: Optional[int],
-    definitions: Mapping[str, Callable[[], GrammarFunction]],
-):
-    if len(prefix_items_schema) < min_items and item_schema is False:
-        raise ValueError(
-            f"PrefixItems has too few elements ({len(prefix_items_schema)}) to"
-            f" satisfy minItems ({min_items}) but no extra items were allowed"
-        )
+        required_items = []
+        optional_items = []
 
-    if max_items is not None and max_items < min_items:
-        raise ValueError(f"maxItems ({max_items}) can't be less than minItems ({min_items})")
+        # If max_items is None, we can add an infinite tail of items later
+        n_to_add = max(len(prefix_items_schema), min_items) if max_items is None else max_items
+        for i in range(n_to_add):
+            if i < len(prefix_items_schema):
+                schema = prefix_items_schema[i]
+            elif item_schema is not False:
+                schema = item_schema
+            else:
+                assert i >= min_items
+                break
 
-    required_items = []
-    optional_items = []
+            item = self.json(json_schema=schema)
 
-    # If max_items is None, we can add an infinite tail of items later
-    n_to_add = max(len(prefix_items_schema), min_items) if max_items is None else max_items
-    for i in range(n_to_add):
-        if i < len(prefix_items_schema):
-            schema = prefix_items_schema[i]
-        elif item_schema is not False:
-            schema = item_schema
-        else:
-            assert i >= min_items
-            break
+            if i < min_items:
+                required_items.append(item)
+            else:
+                optional_items.append(item)
 
-        item = _gen_json(json_schema=schema, definitions=definitions)
+        if max_items is None and item_schema is not False:
+            # Add an infinite tail of items
+            item = self.json(json_schema=item_schema)
+            optional_items.append(item + sequence(self.item_separator + item))
 
-        if i < min_items:
-            required_items.append(item)
-        else:
-            optional_items.append(item)
-
-    if max_items is None and item_schema is not False:
-        # Add an infinite tail of items
-        item = _gen_json(json_schema=item_schema, definitions=definitions)
-        optional_items.append(item + sequence("," + item))
-
-    lm += "["
-
-    if required_items:
-        first, *rest = required_items
-        lm += first
-        for item in rest:
-            lm += "," + item
-
-    if optional_items:
-        # This is a bit subtle and would not be required if not for prefixItems -- the previous
-        # must be present before the next one may be added, meaning we have nested optionals:
-        # (first optional(,second optional(,third (optional(,...)))))
-        first, *rest = optional_items
-        tail: Union[str, GrammarFunction] = ""
-        for item in reversed(rest):
-            tail = optional("," + item + tail)
-        tail = first + tail
+        lm += "["
 
         if required_items:
-            lm += optional("," + tail)
-        else:
-            lm += optional(tail)
-
-    lm += "]"
-    return lm
-
-
-@guidance(stateless=True)
-def _process_anyOf(
-    lm,
-    *,
-    anyof_list: Sequence[JSONSchema],
-    definitions: Mapping[str, Callable[[], GrammarFunction]],
-):
-    options = [_gen_json(json_schema=item, definitions=definitions) for item in anyof_list]
-    return lm + select(options)
-
+            first, *rest = required_items
+            lm += first
+            for item in rest:
+                lm += self.item_separator + item
+
+        if optional_items:
+            # This is a bit subtle and would not be required if not for prefixItems -- the previous
+            # must be present before the next one may be added, meaning we have nested optionals:
+            # (first optional(,second optional(,third (optional(,...)))))
+            first, *rest = optional_items
+            tail: Union[str, GrammarFunction] = ""
+            for item in reversed(rest):
+                tail = optional(self.item_separator + item + tail)
+            tail = first + tail
+
+            if required_items:
+                lm += optional(self.item_separator + tail)
+            else:
+                lm += optional(tail)
 
-@guidance(stateless=True)
-def _process_enum(lm, *, options: Sequence[Mapping[str, Any]]):
-    # TODO: can we support a whitespace-flexible version of this?
-    all_opts = []
-    for opt in options:
-        all_opts.append(_to_compact_json(opt))
-    return lm + select(options=all_opts)
+        lm += "]"
+        return lm
 
 
-@guidance(stateless=True)
-def _gen_json_any(lm):
-    return lm + select(
-        [
-            _gen_json(json_schema={"type": "null"}, definitions={}),
-            _gen_json(json_schema={"type": "boolean"}, definitions={}),
-            _gen_json(json_schema={"type": "integer"}, definitions={}),
-            _gen_json(json_schema={"type": "number"}, definitions={}),
-            _gen_json(json_schema={"type": "string"}, definitions={}),
-            # Recursive cases
-            _gen_json(
-                json_schema={
-                    "type": "array",
-                    "items": True,
-                },
-                definitions={},
-            ),
-            _gen_json(
+    @guidance(stateless=True)
+    def anyOf(
+        self,
+        lm,
+        *,
+        anyof_list: Sequence[JSONSchema],
+    ):
+        options = [self.json(json_schema=item) for item in anyof_list]
+        return lm + select(options)
+
+    @guidance(stateless=True)
+    def const(
+        self,
+        lm,
+        *,
+        value: Union[None, bool, int, float, str, Mapping, Sequence],
+    ):
+        # Base case
+        if isinstance(value, (type(None), bool, int, float, str)):
+            return lm + json_dumps(value)
+        # Recursive cases
+        # NOTE: we could potentially just use json_dumps in all cases, but this will ensure that we're
+        # properly treating all parts as individual lexemes, which makes whitespace flexibility possible
+        if isinstance(value, Mapping):
+            return lm + self.json(
                 json_schema={
                     "type": "object",
-                    "additionalProperties": True,
-                },
-                definitions={},
-            ),
-        ]
-    )
-
-
-@guidance(stateless=True)
-def _gen_json(
-    lm,
-    json_schema: JSONSchema,
-    definitions: Mapping[str, Callable[[], GrammarFunction]],
-):
-    if json_schema is True:
-        json_schema = {}
-    elif json_schema is False:
-        raise ValueError("No valid JSON can be generated from a schema of `False`")
-
-    if json_schema == {}:
-        return lm + _gen_json_any()
-
-    validate_json_node_keys(json_schema)
-
-    if Keyword.ANYOF in json_schema:
-        return lm + _process_anyOf(anyof_list=json_schema[Keyword.ANYOF], definitions=definitions)
-
-    if Keyword.ALLOF in json_schema:
-        allof_list = json_schema[Keyword.ALLOF]
-        if len(allof_list) != 1:
-            raise ValueError("Only support allOf with exactly one item")
-        return lm + _gen_json(allof_list[0], definitions)
-
-    if Keyword.ONEOF in json_schema:
-        oneof_list = json_schema[Keyword.ONEOF]
-        if len(oneof_list) == 1:
-            return lm + _gen_json(oneof_list[0], definitions)
-        warnings.warn("oneOf not fully supported, falling back to anyOf. This may cause validation errors in some cases.")
-        return lm + _process_anyOf(anyof_list=oneof_list, definitions=definitions)
-
-    if Keyword.REF in json_schema:
-        return lm + _get_definition(reference=json_schema[Keyword.REF], definitions=definitions)
-
-    if Keyword.CONST in json_schema:
+                    "properties": {k: {"const": v} for k, v in dict(value).items()},
+                    "required": list(value.keys()),
+                    "additionalProperties": False,
+                }
+            )
+        if isinstance(value, Sequence):
+            return lm + self.json(
+                json_schema={
+                    "type": "array",
+                    "prefixItems": [{"const": v} for v in list(value)],
+                    "minItems": len(value),
+                    "maxItems": len(value),
+                    "items": False,
+                }
+            )
+        raise TypeError(f"Unsupported value type: {type(value)} for value: {value!r}")
+
+    @guidance(stateless=True)
+    def enum(
+        self,
+        lm,
+        *,
+        options: Sequence[Mapping[str, Any]]
+    ):
         # TODO: can we support a whitespace-flexible version of this?
-        return lm + _to_compact_json(json_schema[Keyword.CONST])
+        all_opts: list[GrammarFunction] = []
+        for opt in options:
+            all_opts.append(
+                self.const(value=opt)
+            )
+        return lm + select(options=all_opts)
+
+
+    @guidance(stateless=True)
+    def any(self, lm):
+        return lm + select(
+            [
+                self.json(json_schema={"type": "null"}),
+                self.json(json_schema={"type": "boolean"}),
+                self.json(json_schema={"type": "integer"}),
+                self.json(json_schema={"type": "number"}),
+                self.json(json_schema={"type": "string"}),
+                # Recursive cases
+                self.json(
+                    json_schema={
+                        "type": "array",
+                        "items": True,
+                    },
+                ),
+                self.json(
+                    json_schema={
+                        "type": "object",
+                        "additionalProperties": True,
+                    },
+                ),
+            ]
+        )
 
-    if Keyword.ENUM in json_schema:
-        return lm + _process_enum(options=json_schema[Keyword.ENUM])
 
-    if Keyword.TYPE in json_schema:
-        target_types = cast(Union[str, Sequence[str]], json_schema[Keyword.TYPE])
-        if isinstance(target_types, str):
-            target_types = [target_types]
-    else:
-        target_types = list(JSONType)
-
-    options: list[Union[str, GrammarFunction]] = []
-    option: Union[str, GrammarFunction]
-    for target_type in target_types:
-        if target_type == JSONType.NULL:
-            option = "null"
-        elif target_type == JSONType.BOOLEAN:
-            option = select(["true", "false"])
-        elif target_type in {JSONType.INTEGER, JSONType.NUMBER}:
-            minimum = cast(Union[int, float, None], json_schema.get(NumberKeywords.MINIMUM, None))
-            maximum = cast(Union[int, float, None], json_schema.get(NumberKeywords.MAXIMUM, None))
-            # Older schemas (Draft4) may have exclusiveMinimum and exclusiveMaximum as booleans, but Draft202012+ should have them as numbers
-            exclusive_minimum = cast(Union[int, float, None], json_schema.get(NumberKeywords.EXCLUSIVE_MINIMUM, None))
-            exclusive_maximum = cast(Union[int, float, None], json_schema.get(NumberKeywords.EXCLUSIVE_MAXIMUM, None))
-            # Internally, we'll use Draft4 style booleans
-            exclusive_minimum_flag: bool = False
-            exclusive_maximum_flag: bool = False
-
-            if exclusive_minimum is not None:
-                if minimum is None or exclusive_minimum >= minimum:
-                    minimum = exclusive_minimum
-                    exclusive_minimum_flag = True
-
-            if exclusive_maximum is not None:
-                if maximum is None or exclusive_maximum <= maximum:
-                    maximum = exclusive_maximum
-                    exclusive_maximum_flag = True
-
-            if target_type == JSONType.INTEGER:
-                option = _gen_json_int(
-                    minimum=minimum,
-                    maximum=maximum,
-                    exclusiveMinimum=exclusive_minimum_flag,
-                    exclusiveMaximum=exclusive_maximum_flag,
+    @guidance(stateless=True, cache=True)
+    def ref(
+        self,
+        lm,
+        *,
+        reference: str,
+    ):
+        target_definition = None
+        for dk in DEFS_KEYS:
+            ref_start = f"#/{dk}/"
+            if reference.startswith(ref_start):
+                target_name = reference[len(ref_start) :]
+                target_definition = self.definitions[target_name]
+
+        assert target_definition is not None
+        return lm + target_definition()
+
+
+    @guidance(stateless=True)
+    def json(
+        self,
+        lm,
+        *,
+        json_schema: JSONSchema,
+    ):
+        if json_schema is True:
+            json_schema = {}
+        elif json_schema is False:
+            raise ValueError("No valid JSON can be generated from a schema of `False`")
+
+        if json_schema == {}:
+            return lm + self.any()
+
+        validate_json_node_keys(json_schema)
+
+        if Keyword.ANYOF in json_schema:
+            return lm + self.anyOf(anyof_list=json_schema[Keyword.ANYOF])
+
+        if Keyword.ALLOF in json_schema:
+            allof_list = json_schema[Keyword.ALLOF]
+            if len(allof_list) != 1:
+                raise ValueError("Only support allOf with exactly one item")
+            return lm + self.json(json_schema=allof_list[0])
+
+        if Keyword.ONEOF in json_schema:
+            oneof_list = json_schema[Keyword.ONEOF]
+            if len(oneof_list) == 1:
+                return lm + self.json(json_schema=oneof_list[0])
+            warnings.warn("oneOf not fully supported, falling back to anyOf. This may cause validation errors in some cases.")
+            return lm + self.anyOf(anyof_list=oneof_list)
+
+        if Keyword.REF in json_schema:
+            return lm + self.ref(reference=json_schema[Keyword.REF])
+
+        if Keyword.CONST in json_schema:
+            return lm + self.const(value=json_schema[Keyword.CONST])
+
+        if Keyword.ENUM in json_schema:
+            return lm + self.enum(options=json_schema[Keyword.ENUM])
+
+        if Keyword.TYPE in json_schema:
+            target_types = cast(Union[str, Sequence[str]], json_schema[Keyword.TYPE])
+            if isinstance(target_types, str):
+                target_types = [target_types]
+        else:
+            target_types = list(JSONType)
+
+        options: list[Union[str, GrammarFunction]] = []
+        option: Union[str, GrammarFunction]
+        for target_type in target_types:
+            if target_type == JSONType.NULL:
+                option = "null"
+            elif target_type == JSONType.BOOLEAN:
+                option = select(["true", "false"])
+            elif target_type in {JSONType.INTEGER, JSONType.NUMBER}:
+                minimum = cast(Union[int, float, None], json_schema.get(NumberKeywords.MINIMUM, None))
+                maximum = cast(Union[int, float, None], json_schema.get(NumberKeywords.MAXIMUM, None))
+                # Older schemas (Draft4) may have exclusiveMinimum and exclusiveMaximum as booleans, but Draft202012+ should have them as numbers
+                exclusive_minimum = cast(Union[int, float, None], json_schema.get(NumberKeywords.EXCLUSIVE_MINIMUM, None))
+                exclusive_maximum = cast(Union[int, float, None], json_schema.get(NumberKeywords.EXCLUSIVE_MAXIMUM, None))
+                # Internally, we'll use Draft4 style booleans
+                exclusive_minimum_flag: bool = False
+                exclusive_maximum_flag: bool = False
+
+                if exclusive_minimum is not None:
+                    if minimum is None or exclusive_minimum >= minimum:
+                        minimum = exclusive_minimum
+                        exclusive_minimum_flag = True
+
+                if exclusive_maximum is not None:
+                    if maximum is None or exclusive_maximum <= maximum:
+                        maximum = exclusive_maximum
+                        exclusive_maximum_flag = True
+
+                if target_type == JSONType.INTEGER:
+                    option = self.integer(
+                        minimum=minimum,
+                        maximum=maximum,
+                        exclusiveMinimum=exclusive_minimum_flag,
+                        exclusiveMaximum=exclusive_maximum_flag,
+                    )
+                else:
+                    option = self.number(
+                        minimum=minimum,
+                        maximum=maximum,
+                        exclusiveMinimum=exclusive_minimum_flag,
+                        exclusiveMaximum=exclusive_maximum_flag,
+                    )
+            elif target_type == JSONType.STRING:
+                option = self.string(
+                    regex=json_schema.get(StringKeywords.PATTERN, None),
+                    format=json_schema.get(StringKeywords.FORMAT, None),
+                    min_length=json_schema.get(StringKeywords.MIN_LENGTH, 0),
+                    max_length=json_schema.get(StringKeywords.MAX_LENGTH, None),
                 )
-            else:
-                option = _gen_json_number(
-                    minimum=minimum,
-                    maximum=maximum,
-                    exclusiveMinimum=exclusive_minimum_flag,
-                    exclusiveMaximum=exclusive_maximum_flag,
+            elif target_type == JSONType.ARRAY:
+                option = self.array(
+                    prefix_items_schema=json_schema.get(ArrayKeywords.PREFIX_ITEMS, []),
+                    item_schema=json_schema.get(ArrayKeywords.ITEMS, True),
+                    min_items=json_schema.get(ArrayKeywords.MIN_ITEMS, 0),
+                    max_items=json_schema.get(ArrayKeywords.MAX_ITEMS, None),
                 )
-        elif target_type == JSONType.STRING:
-            option = _gen_json_string(
-                regex=json_schema.get(StringKeywords.PATTERN, None),
-                format=json_schema.get(StringKeywords.FORMAT, None),
-                min_length=json_schema.get(StringKeywords.MIN_LENGTH, 0),
-                max_length=json_schema.get(StringKeywords.MAX_LENGTH, None),
-            )
-        elif target_type == JSONType.ARRAY:
-            option = _gen_json_array(
-                prefix_items_schema=json_schema.get(ArrayKeywords.PREFIX_ITEMS, []),
-                item_schema=json_schema.get(ArrayKeywords.ITEMS, True),
-                min_items=json_schema.get(ArrayKeywords.MIN_ITEMS, 0),
-                max_items=json_schema.get(ArrayKeywords.MAX_ITEMS, None),
-                definitions=definitions,
-            )
-        elif target_type == JSONType.OBJECT:
-            option = _gen_json_object(
-                properties=json_schema.get(ObjectKeywords.PROPERTIES, {}),
-                additional_properties=json_schema.get(ObjectKeywords.ADDITIONAL_PROPERTIES, True),
-                required=json_schema.get(ObjectKeywords.REQUIRED, set()),
-                definitions=definitions,
-            )
-        else:
-            raise ValueError(f"Unsupported type in schema: {target_type}")
-        options.append(option)
+            elif target_type == JSONType.OBJECT:
+                option = self.object(
+                    properties=json_schema.get(ObjectKeywords.PROPERTIES, {}),
+                    additional_properties=json_schema.get(ObjectKeywords.ADDITIONAL_PROPERTIES, True),
+                    required=json_schema.get(ObjectKeywords.REQUIRED, set()),
+                )
+            else:
+                raise ValueError(f"Unsupported type in schema: {target_type}")
+            options.append(option)
 
-    return lm + select(options)
+        return lm + select(options)
 
 
 @guidance(stateless=True)
@@ -795,9 +880,11 @@ def json(
         Type["pydantic.BaseModel"],
         "pydantic.TypeAdapter",
     ] = None,
-    compact: bool = False,
     temperature: float = 0.0,
     max_tokens: int = 100000000,
+    separators: Optional[tuple[str, str]] = None,
+    whitespace_flexible: bool = False,
+    **kwargs,
 ):
     """Generate valid JSON according to the supplied JSON schema or `pydantic` model.
 
@@ -840,11 +927,12 @@ def json(
             - A JSON schema object. This is a JSON schema string which has been passed to ``json.loads()``
             - A subclass of ``pydantic.BaseModel``
             - An instance of ``pydantic.TypeAdapter``
-
-    compact : bool
-        If True, the generated JSON will be forced to be compact (no whitespace).
-        If False, output will be whitespace-flexible (i.e. decided by the model).
     """
+    if "compact" in kwargs:
+        warnings.warn("The 'compact' argument is deprecated and has no effect. It will be removed in a future release.", category=DeprecationWarning)
+        kwargs.pop("compact")
+    if kwargs:
+        raise TypeError(f"Unexpected keyword arguments: {kwargs.keys()}")
     if schema is None:
         # Default schema is empty, "anything goes" schema
         # TODO: consider default being `{"type": "object"}`
@@ -858,58 +946,20 @@ def json(
     else:
         raise TypeError(f"Unsupported schema type: {type(schema)}")
 
-    definitions: Mapping[str, Callable[[], GrammarFunction]] = {}
-    if isinstance(schema, Mapping):
-        for dk in DEFS_KEYS:
-            if dk in schema:
-                assert len(definitions) == 0, "Found duplicate definitions"
-                definitions = _build_definitions(schema[dk])
+    if whitespace_flexible:
+        if separators is None:
+            separators = (",", ":")
+        skip_regex = r"[\x20\x0A\x0D\x09]+"
+    else:
+        skip_regex = None
 
     return lm + with_temperature(
         subgrammar(
             name,
-            body=_gen_json(json_schema=schema, definitions=definitions),
-            skip_regex=(
-                None if compact
-                else r"[\x20\x0A\x0D\x09]+"
-            ),
+            body=GenJson(schema=schema, separators=separators).root(),
+            skip_regex=skip_regex,
             no_initial_skip=True,
             max_tokens=max_tokens,
         ),
         temperature=temperature,
     )
-
-
-def _build_definitions(
-    raw_definitions: Mapping[str, JSONSchema]
-) -> Mapping[str, Callable[[], GrammarFunction]]:
-    definitions: Dict[str, Callable[[], GrammarFunction]] = {}
-
-    def build_definition(json_schema: JSONSchema) -> Callable[[], GrammarFunction]:
-        @guidance(stateless=True, dedent=False, cache=True)
-        def closure(lm):
-            return lm + _gen_json(json_schema=json_schema, definitions=definitions)
-
-        return closure
-
-    definitions = {ref: build_definition(schema) for ref, schema in raw_definitions.items()}
-    return definitions
-
-
-@guidance(stateless=True)
-def _get_definition(
-    lm,
-    *,
-    reference: str,
-    definitions: Mapping[str, Callable[[], GrammarFunction]],
-):
-    assert definitions is not None
-    target_definition = None
-    for dk in DEFS_KEYS:
-        ref_start = f"#/{dk}/"
-        if reference.startswith(ref_start):
-            target_name = reference[len(ref_start) :]
-            target_definition = definitions[target_name]
-
-    assert target_definition is not None
-    return lm + target_definition()
diff --git a/tests/server/test_server.py b/tests/server/test_server.py
index b269da609..3a10b9047 100644
--- a/tests/server/test_server.py
+++ b/tests/server/test_server.py
@@ -5,11 +5,11 @@
 
 import pytest
 import requests
+from json import dumps as json_dumps
 from jsonschema import validate
 
 from guidance import Server, gen, models
 from guidance.library import json as gen_json
-from guidance.library._json import _to_compact_json
 
 # We spin out a separate process, and it
 # has to start up and get ready to
@@ -129,9 +129,9 @@ def test_remote_gen_json(target_obj):
     # Sanity check input
     validate(target_obj, schema_obj)
 
-    print(f"target_obj={_to_compact_json(target_obj)}")
+    print(f"target_obj={json_dumps(target_obj)}")
 
-    with ServerContext(mock_string=[_to_compact_json(target_obj)]):
+    with ServerContext(mock_string=[json_dumps(target_obj)]):
         m = models.Model("http://localhost:8392", api_key="SDFSDF")
         m += gen_json(schema=schema_obj, name="my_json_string")
         print(f"Raw: {m['my_json_string']}")
diff --git a/tests/unit/library/test_json.py b/tests/unit/library/test_json.py
index 8b6cf374c..da7d5459a 100644
--- a/tests/unit/library/test_json.py
+++ b/tests/unit/library/test_json.py
@@ -4,11 +4,12 @@
 
 import pytest
 from jsonschema import validate, ValidationError
+from json import dumps as json_dumps
 
 from guidance import json as gen_json
 from guidance import models
 
-from guidance.library._json import _to_compact_json, WHITESPACE, IGNORED_KEYS
+from guidance.library._json import IGNORED_KEYS
 
 from ...utils import check_match_failure as _check_match_failure
 from ...utils import check_run_with_temperature
@@ -16,11 +17,11 @@
 
 
 def generate_and_check(
-    target_obj: Any, schema_obj, desired_temperature: Optional[float] = None,
+    target_obj: Any, schema_obj, desired_temperature: Optional[float] = None
 ):
     # Sanity check what we're being asked
     validate(instance=target_obj, schema=schema_obj)
-    prepared_json = _to_compact_json(target_obj)
+    prepared_json = json_dumps(target_obj)
     assert json.loads(prepared_json) == target_obj
 
     # Now test that the grammar can recognize and generate prepared_json
@@ -46,15 +47,8 @@ def check_match_failure(
     failure_byte: Optional[bytes] = None,
     allowed_bytes: Optional[Set[bytes]] = None,
     schema_obj: Dict[str, Any],
-    maybe_whitespace: Optional[bool] = None,
-    compact: bool = True,
 ):
-    if (allowed_bytes is not None) and (maybe_whitespace is None):
-        raise ValueError("If allowed_bytes is provided, maybe_whitespace must also be provided")
-    if allowed_bytes is not None and maybe_whitespace and not compact:
-        allowed_bytes = allowed_bytes.union(WHITESPACE)
-
-    grammar = gen_json(schema=schema_obj, compact=compact)
+    grammar = gen_json(schema=schema_obj)
 
     _check_match_failure(
         bad_string=bad_string,
@@ -110,20 +104,17 @@ def test_integer_schema(self, my_int):
         generate_and_check(my_int, schema_obj)
 
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        ["bad_string", "good_bytes", "failure_byte", "allowed_bytes", "maybe_whitespace"],
+        ["bad_string", "good_bytes", "failure_byte", "allowed_bytes"],
         [
-            ("9999a7777", b"9999", b"a", INTEGER_FOLLOWING, True),
-            ("123, []", b"123", b",", INTEGER_FOLLOWING, True),
-            ("a321", b"", b"a", INTEGER_LEADING, False),
-            ("123789.456", b"123789", b".", INTEGER_FOLLOWING, True),
-            ("[]", b"", b"[", INTEGER_LEADING, False),
-            ('{"a":4}', b"", b"{", INTEGER_LEADING, False),
+            ("9999a7777", b"9999", b"a", INTEGER_FOLLOWING),
+            ("123, []", b"123", b",", INTEGER_FOLLOWING),
+            ("a321", b"", b"a", INTEGER_LEADING),
+            ("123789.456", b"123789", b".", INTEGER_FOLLOWING),
+            ("[]", b"", b"[", INTEGER_LEADING),
+            ('{"a": 4}', b"", b"{", INTEGER_LEADING),
         ],
     )
-    def test_bad_integer(self, bad_string, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact):
+    def test_bad_integer(self, bad_string, good_bytes, failure_byte, allowed_bytes):
         schema_obj = json.loads(TestInteger.schema)
         check_match_failure(
             bad_string=bad_string,
@@ -131,8 +122,6 @@ def test_bad_integer(self, bad_string, good_bytes, failure_byte, allowed_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
 
@@ -170,19 +159,16 @@ def test_number(self, target_obj, temperature):
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        ["bad_string", "good_bytes", "failure_byte", "allowed_bytes", "maybe_whitespace"],
+        ["bad_string", "good_bytes", "failure_byte", "allowed_bytes"],
         [
-            ("9999a7777", b"9999", b"a", {b"e", b"E", b".", *INTEGER_FOLLOWING}, True),
-            ("123.6, []", b"123.6", b",", {b"e", b"E", *INTEGER_FOLLOWING}, True),
-            ("a321", b"", b"a", INTEGER_LEADING, False),
-            ("[]", b"", b"[", INTEGER_LEADING, False),
-            ('{"a":4}', b"", b"{", INTEGER_LEADING, False),
+            ("9999a7777", b"9999", b"a", {b"e", b"E", b".", *INTEGER_FOLLOWING}),
+            ("123.6, []", b"123.6", b",", {b"e", b"E", *INTEGER_FOLLOWING}),
+            ("a321", b"", b"a", INTEGER_LEADING),
+            ("[]", b"", b"[", INTEGER_LEADING),
+            ('{"a": 4}', b"", b"{", INTEGER_LEADING),
         ],
     )
-    def test_bad_number(self, bad_string, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact):
+    def test_bad_number(self, bad_string, good_bytes, failure_byte, allowed_bytes):
         schema_obj = json.loads(TestNumber.schema)
         check_match_failure(
             bad_string=bad_string,
@@ -190,8 +176,6 @@ def test_bad_number(self, bad_string, good_bytes, failure_byte, allowed_bytes, m
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
 class TestBoundedNumeric:
@@ -322,7 +306,7 @@ def test_numeric_validation(self, instance, schema, should_pass):
             with pytest.raises(ValidationError):
                 validate(instance, schema=schema)
             check_match_failure(
-                bad_string=_to_compact_json(instance),
+                bad_string=json_dumps(instance),
                 schema_obj=schema
             )
 
@@ -403,8 +387,6 @@ def test_regex_bad(self, bad_string: str, good_bytes, failure_byte, allowed_byte
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=False,
-            compact=True,
         )
 
     @pytest.mark.parametrize(
@@ -438,8 +420,6 @@ def test_regex_properly_escaped_bad(self, bad_string: str, good_bytes, failure_b
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=False,
-            compact=True,
         )
 
 
@@ -474,8 +454,6 @@ def test_min_and_maxLength_bad(self, bad_string: str, good_bytes, failure_byte,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=False,
-            compact=True,
         )
 
     @pytest.mark.parametrize(
@@ -547,8 +525,6 @@ def test_minLength_bad(self, bad_string: str, good_bytes, failure_byte, allowed_
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=False,
-            compact=True,
         )
 
     @pytest.mark.parametrize(
@@ -605,8 +581,6 @@ def test_maxLength_bad(self, bad_string: str, good_bytes, failure_byte, allowed_
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=False,
-            compact=True,
         )
 
 
@@ -714,17 +688,14 @@ def test_object_containing_list(self, temperature):
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        ["bad_string", "good_bytes", "failure_byte", "allowed_bytes", "maybe_whitespace"],
+        ["bad_string", "good_bytes", "failure_byte", "allowed_bytes"],
         [
-            ("9999a7777", b"", b"9", {b"{"}, False),
-            ('{"a":1255.4567}', b'{"a":1255', b".", {b"}", *INTEGER_FOLLOWING}, True),
-            ('{"a":"123"}', b'{"a":', b'"', INTEGER_LEADING, True),
+            ("9999a7777", b"", b"9", {b"{"}),
+            ('{"a": 1255.4567}', b'{"a": 1255', b".", {b"}", *INTEGER_FOLLOWING}),
+            ('{"a": "123"}', b'{"a": ', b'"', INTEGER_LEADING),
         ],
     )
-    def test_bad_object(self, bad_string, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact):
+    def test_bad_object(self, bad_string, good_bytes, failure_byte, allowed_bytes):
         schema = """{
             "type": "object",
             "properties": {
@@ -741,8 +712,6 @@ def test_bad_object(self, bad_string, good_bytes, failure_byte, allowed_bytes, m
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
 
@@ -752,7 +721,7 @@ def test_required_is_required(self):
         generate_and_check({"b": 1}, schema)
         generate_and_check({"a": 1, "b": "xyz"}, schema)
         check_match_failure(
-            bad_string=_to_compact_json(
+            bad_string=json_dumps(
                 {"a": 1}
             ),
             schema_obj=schema,
@@ -763,7 +732,7 @@ def test_validated_against_additionalProperties(self):
         generate_and_check({"b": 1}, schema)
         generate_and_check({"a": 1, "b": 42}, schema)
         check_match_failure(
-            bad_string=_to_compact_json(
+            bad_string=json_dumps(
                 {"a": 1, "b": "string"}
             ),
             schema_obj=schema,
@@ -839,18 +808,16 @@ def test_object_list(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        ["bad_string", "good_bytes", "failure_byte", "allowed_bytes", "maybe_whitespace"],
+        ["bad_string", "good_bytes", "failure_byte", "allowed_bytes"],
         [
-            ("9999a7777", b"", b"9", {b"["}, False),
-            ("[321.654]", b"[321", b".", {b"]", b",", *INTEGER_FOLLOWING}, True),
-            ('["123"]', b"[", b'"', {b"]", *INTEGER_LEADING}, True),
+            ("9999a7777", b"", b"9", {b"["}),
+            ("[321.654]", b"[321", b".", {b"]", b",", *INTEGER_FOLLOWING}),
+            ('["123"]', b"[", b'"', {b"]", *INTEGER_LEADING}),
         ],
     )
-    def test_bad_object(self, bad_string, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact):
+    def test_bad_object(self, bad_string, good_bytes, failure_byte, allowed_bytes):
         schema = """{
         "type" : "array",
         "items" : {
@@ -864,8 +831,6 @@ def test_bad_object(self, bad_string, good_bytes, failure_byte, allowed_bytes, m
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
 
@@ -953,38 +918,33 @@ def test_good_with_items(self, min_items, max_items, target_obj):
         }
         generate_and_check(target_obj, schema_obj)
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
             (
                 1,
                 4,
                 [42, "string_not_bool", "hello", "extra"],
-                b"[42,",
+                b"[42, ",
                 b'"',
                 {b"t", b"f"},
-                True,
             ),  # Second item does not match prefix schema
             (
                 0,
                 3,
                 [42, True, 100],
-                b"[42,true,",
+                b"[42, true, ",
                 b"1",
                 {b'"'},
-                True,
             ),  # Last item does not match general item schema
             (
                 3,
                 5,
                 [42, True, "valid", "extra1", "extra2", "too_many"],
-                b'[42,true,"valid","extra1","extra2"',
+                b'[42, true, "valid", "extra1", "extra2"',
                 b",",
                 {b"]"},
-                True,
             ),  # Exceeds maxItems
             (
                 2,
@@ -993,7 +953,6 @@ def test_good_with_items(self, min_items, max_items, target_obj):
                 b"[42",
                 b"]",
                 {b",", *INTEGER_FOLLOWING},
-                True,
             ),  # Not enough items
             (
                 1,
@@ -1002,7 +961,6 @@ def test_good_with_items(self, min_items, max_items, target_obj):
                 b"[42",
                 b",",
                 {b"]", *INTEGER_FOLLOWING},
-                True,
             ),  # Too many items for maxItems
             (
                 0,
@@ -1011,21 +969,19 @@ def test_good_with_items(self, min_items, max_items, target_obj):
                 b"[",
                 b"4",
                 {b"]"},
-                True,
             ),  # maxItems set to 0, but array is not empty
             (
                 3,
                 5,
                 [42, True],
-                b"[42,true",
+                b"[42, true",
                 b"]",
                 {b","},
-                True,
             ),  # Array has one fewer item than required by minItems
         ],
     )
     def test_bad_with_prefix_and_items(
-        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact
+        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes
     ):
         schema_obj = {
             "prefixItems": self.prefix_schema_obj,
@@ -1034,22 +990,18 @@ def test_bad_with_prefix_and_items(
             "maxItems": max_items,
             "type": "array",
         }
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
             (
                 2,
@@ -1058,16 +1010,14 @@ def test_bad_with_prefix_and_items(
                 b"[42",
                 b"]",
                 {b",", *INTEGER_FOLLOWING},
-                True,
             ),  # Array too short to meet minItems, despite matching prefixItems
             (
                 1,
                 2,
                 [42, "not_bool"],
-                b"[42,",
+                b"[42, ",
                 b'"',
                 {b"t", b"f"},
-                True,
             ),  # Second item violates prefixItems type requirement
             (
                 0,
@@ -1076,16 +1026,14 @@ def test_bad_with_prefix_and_items(
                 b"[42",
                 b",",
                 {b"]", *INTEGER_FOLLOWING},
-                True,
             ),  # Array exceeds maxItems with valid prefixItems types
             (
                 1,
                 5,
                 [42, True, "extra"],
-                b"[42,true",
+                b"[42, true",
                 b",",
                 {b"]"},
-                True,
             ),  # Item beyond prefixItems with no "items" schema
             (
                 0,
@@ -1094,12 +1042,11 @@ def test_bad_with_prefix_and_items(
                 b"[",
                 b"4",
                 {b"]"},
-                True,
             ),  # maxItems set to 0, but array is not empty
         ],
     )
     def test_bad_with_prefix(
-        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact
+        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes
     ):
         schema_obj = {
             "prefixItems": self.prefix_schema_obj,
@@ -1108,31 +1055,26 @@ def test_bad_with_prefix(
             "maxItems": max_items,
             "type": "array",
         }
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
             (
                 1,
                 2,
                 ["hello", "world", "extra"],
-                b'["hello","world"',
+                b'["hello", "world"',
                 b",",
                 {b"]"},
-                True,
             ),  # Too many items for maxItems
             (
                 2,
@@ -1141,16 +1083,14 @@ def test_bad_with_prefix(
                 b'["hello"',
                 b"]",
                 {b","},
-                True,
             ),  # Not enough items
             (
                 2,
                 3,
                 ["hello", 42],
-                b'["hello",',
+                b'["hello", ',
                 b"4",
                 {b'"'},
-                True,
             ),  # Badly typed second item
             (
                 0,
@@ -1159,12 +1099,11 @@ def test_bad_with_prefix(
                 b"[",
                 b'"',
                 {b"]"},
-                True,
             ),  # maxItems set to 0, but array is not empty
         ],
     )
     def test_bad_with_items(
-        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact
+        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes
     ):
         schema_obj = {
             "items": self.items_schema_obj,
@@ -1172,15 +1111,13 @@ def test_bad_with_items(
             "maxItems": max_items,
             "type": "array",
         }
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
 
@@ -1525,7 +1462,7 @@ def test_allOf_bad_schema(self):
         TARGET_VALUE = 20
         validate(instance=TARGET_VALUE, schema=schema_obj)
 
-        prepared_string = f"<s>{_to_compact_json(TARGET_VALUE)}"
+        prepared_string = f"<s>{json_dumps(TARGET_VALUE)}"
         lm = models.Mock(prepared_string.encode())
 
         # Run with the mock model
@@ -1586,52 +1523,44 @@ def test_enum(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
-            ("1", b'"', b"1", {b"2"}, False),
-            (2, b"", b"2", {b'"', b"1", b"f"}, False),
-            (True, b"", b"t", {b'"', b"1", b"f"}, False),
+            ("1", b'"', b"1", {b"2"}),
+            (2, b"", b"2", {b'"', b"1", b"f"}),
+            (True, b"", b"t", {b'"', b"1", b"f"}),
         ],
     )
-    def test_bad_enum(self, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact):
+    def test_bad_enum(self, bad_obj, good_bytes, failure_byte, allowed_bytes):
         schema_obj = json.loads(self.simple_schema)
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
-            ("ab", b'"a', b"b", {b"a"}, False),
-            ("bc", b'"b', b"c", {b"b"}, False),
-            ("ca", b'"c', b"a", {b"c"}, False),
+            ("ab", b'"a', b"b", {b"a"}),
+            ("bc", b'"b', b"c", {b"b"}),
+            ("ca", b'"c', b"a", {b"c"}),
         ],
     )
-    def test_bad_prefix_enum(self, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact):
+    def test_bad_prefix_enum(self, bad_obj, good_bytes, failure_byte, allowed_bytes):
         schema_obj = json.loads(self.prefix_schema)
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
 
@@ -1683,7 +1612,7 @@ def test_nested_constant(self):
 
     def test_constant_precedence(self):
         schema_obj = {"type": "integer", "const": 1}
-        bad_string = _to_compact_json(2)
+        bad_string = json_dumps(2)
 
         check_match_failure(
             bad_string=bad_string,
@@ -1691,8 +1620,6 @@ def test_constant_precedence(self):
             failure_byte=b"2",
             allowed_bytes={b"1"},
             schema_obj=schema_obj,
-            maybe_whitespace=False,
-            compact=True,
         )
 
 
@@ -1739,33 +1666,28 @@ def test_simple_additional_properties(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
-            ({"a": "1"}, b'{"a":', b'"', INTEGER_LEADING, True),
+            ({"a": "1"}, b'{"a": ', b'"', INTEGER_LEADING, ),
             (
                 {"a": 1, "b": 1.5},
-                b'{"a":1,"b":1',
+                b'{"a": 1, "b": 1',
                 b".",
                 {b",", b"}", *INTEGER_FOLLOWING},
-                True,
             ),
         ],
     )
-    def test_simple_bad_type(self, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact):
+    def test_simple_bad_type(self, bad_obj, good_bytes, failure_byte, allowed_bytes):
         schema_obj = json.loads(self.simple_schema)
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
     @pytest.mark.parametrize(
@@ -1779,34 +1701,29 @@ def test_anyOf_additional_properties(self, target_obj):
         # The actual check
         generate_and_check(target_obj, schema_obj)
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
-            ({"a": 1.5}, b'{"a":1', b".", {b",", b"}", *INTEGER_FOLLOWING}, True),
-            ({"a": True}, b'{"a":', b"t", {b'"', *INTEGER_LEADING}, True),
+            ({"a": 1.5}, b'{"a": 1', b".", {b",", b"}", *INTEGER_FOLLOWING}),
+            ({"a": True}, b'{"a": ', b"t", {b'"', *INTEGER_LEADING}),
             (
                 {"a": 1, "b": False},
-                b'{"a":1,"b":',
+                b'{"a": 1, "b": ',
                 b"f",
                 {b'"', *INTEGER_LEADING},
-                True,
             ),
         ],
     )
-    def test_anyOf_bad_type(self, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact):
+    def test_anyOf_bad_type(self, bad_obj, good_bytes, failure_byte, allowed_bytes):
         schema_obj = json.loads(self.anyOf_schema)
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
     @pytest.mark.parametrize(
@@ -1826,60 +1743,51 @@ def test_properties_and_additional_properties(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
-            ({}, b"{", b"}", {b'"'}, True),
-            ({"a": 1}, b'{"', b"a", {b"m"}, False),
-            ({"a": 1, "b": 2}, b'{"', b"a", {b"m"}, False),
+            ({}, b"{", b"}", {b'"'}),
+            ({"a": 1}, b'{"', b"a", {b"m"}),
+            ({"a": 1, "b": 2}, b'{"', b"a", {b"m"}),
         ],
     )
     def test_combined_missing_properties(
-        self, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact
+        self, bad_obj, good_bytes, failure_byte, allowed_bytes
     ):
         schema_obj = json.loads(self.combined_schema)
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
-            ({"mystr": 1}, b'{"mystr":', b"1", {b'"'}, True),
-            ({"mystr": 1, "a": 2}, b'{"mystr":', b"1", {b'"'}, True),
+            ({"mystr": 1}, b'{"mystr": ', b"1", {b'"'}),
+            ({"mystr": 1, "a": 2}, b'{"mystr": ', b"1", {b'"'}),
             (
                 {"mystr": "hello", "a": False},
-                b'{"mystr":"hello","a":',
+                b'{"mystr": "hello", "a": ',
                 b"f",
                 INTEGER_LEADING,
-                True,
             ),
         ],
     )
-    def test_combined_bad_type(self, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact):
+    def test_combined_bad_type(self, bad_obj, good_bytes, failure_byte, allowed_bytes):
         schema_obj = json.loads(self.combined_schema)
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
     def test_out_of_order_non_required_properties_not_validated_as_additionalProperties(self):
@@ -1986,22 +1894,19 @@ def test_empty_schema(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "bad_string, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "bad_string, good_bytes, failure_byte, allowed_bytes",
         [
             # {} is not carte blanche for malformed JSON
-            ("{a:1}", b"{", b"a", {b'"', b"}"}, True),
+            ("{a:1}", b"{", b"a", {b'"', b"}"}),
             (
-                "[1,2} ",
-                b"[1,2",
+                "[1, 2} ",
+                b"[1, 2",
                 b"}",
                 {b",", b"]", b"e", b"E", b".", *INTEGER_FOLLOWING},
-                True,
             ),
-            ("123a", b"123", b"a", {b"e", b"E", b".", *INTEGER_FOLLOWING}, True),
+            ("123a", b"123", b"a", {b"e", b"E", b".", *INTEGER_FOLLOWING}),
             (
                 "]",
                 b"",
@@ -2015,12 +1920,11 @@ def test_empty_schema(self, target_obj, temperature):
                     b"n",
                     *INTEGER_LEADING,
                 },
-                False,
             ),
         ],
     )
     def test_bad_empty_schema(
-        self, bad_string, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact
+        self, bad_string, good_bytes, failure_byte, allowed_bytes
     ):
         schema_obj = json.loads(self.empty_schema)
         check_match_failure(
@@ -2029,8 +1933,6 @@ def test_bad_empty_schema(
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
     @pytest.mark.parametrize(
@@ -2073,28 +1975,24 @@ def test_nested_empty_schema(self, schema_obj, target_obj, temperature):
             {"type": "object", "properties": {"a": {"$ref": "#/$defs/A"}}, "$defs": {"A": {}}, "required": ["a"]},
         ],
     )
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
             # Missing property -- presence of {} deeper in the schema isn't carte blanche
-            ({"b": 42}, b'{"', b"b", {b"a"}, False),
+            ({"b": 42}, b'{"', b"b", {b"a"}),
         ],
     )
     def test_nested_empty_schema_bad(
-        self, schema_obj, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact
+        self, schema_obj, bad_obj, good_bytes, failure_byte, allowed_bytes
     ):
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
     @pytest.mark.parametrize(
@@ -2120,30 +2018,26 @@ def test_nested_empty_schema_with_props(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
+
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
             # Missing property -- presence of {} deeper in the schema isn't carte blanche
-            ({"b": 42}, b'{"', b"b", {b"a"}, False),
+            ({"b": 42}, b'{"', b"b", {b"a"}),
         ],
     )
     def test_nested_empty_schema_with_props_bad(
-        self, bad_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact
+        self, bad_obj, good_bytes, failure_byte, allowed_bytes
     ):
         schema_obj = json.loads(self.nested_empty_schema_with_props)
 
-        bad_string = _to_compact_json(bad_obj)
+        bad_string = json_dumps(bad_obj)
         check_match_failure(
             bad_string=bad_string,
             good_bytes=good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             schema_obj=schema_obj,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
     @pytest.mark.parametrize(
@@ -2159,10 +2053,8 @@ def test_items(self, schema_obj):
             [1, 0.4, "hello", False, None, {"a": 42}, [1, 2, 3, "four"]], schema_obj
         )
 
-    @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    def test_no_items(self, compact):
+
+    def test_no_items(self):
         schema_obj = {"type": "array", "items": False}
         check_match_failure(
             bad_string="[42]",
@@ -2170,8 +2062,6 @@ def test_no_items(self, compact):
             failure_byte=b"4",
             allowed_bytes={b"]"},  # array must be empty
             schema_obj=schema_obj,
-            maybe_whitespace=True,
-            compact=compact,
         )
 
     @pytest.mark.parametrize(
@@ -2196,10 +2086,8 @@ def test_additionalProperties(self, schema_obj):
             schema_obj,
         )
 
-    @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    def test_no_additionalProperties(self, compact):
+
+    def test_no_additionalProperties(self):
         schema_obj = {"type": "object", "additionalProperties": False}
         check_match_failure(
             bad_string='{"a": 42}',
@@ -2207,8 +2095,6 @@ def test_no_additionalProperties(self, compact):
             failure_byte=b'"',
             allowed_bytes={b"}"},  # object must be empty
             schema_obj=schema_obj,
-            maybe_whitespace=True,
-            compact=compact,
         )
 
 def test_ignored_keys_allowed_as_properties():
@@ -2267,9 +2153,8 @@ def test_all_required_good(self, extra_items):
     def test_all_required_bad(self, bad_obj):
         schema_obj = {**self.schema_obj, "required": self.ALL_REQUIRED}
         check_match_failure(
-            bad_string=_to_compact_json(bad_obj),
+            bad_string=json_dumps(bad_obj),
             schema_obj=schema_obj,
-            compact=True
         )
 
     @pytest.mark.parametrize(
@@ -2305,9 +2190,8 @@ def test_some_required_bad(self, required):
             if not set(required).issubset(subset):
                 bad_obj = {key: base_obj[key] for key in subset}
                 check_match_failure(
-                    bad_string=_to_compact_json(bad_obj),
+                    bad_string=json_dumps(bad_obj),
                     schema_obj=schema_obj,
-                    compact=True
                 )
 
     # No equivalent "bad" tests for none required, as the schema is satisfied by an empty object
@@ -2349,12 +2233,11 @@ def test_many_optional_properties_doesnt_blow_up(self, num_properties):
             },
             "required": [] # Empty should be worst-case scenario
         }
-        from guidance.library._json import _gen_list
-        _gen_list.__wrapped__.cache_clear()
-        _ = gen_json(
-            schema=schema_obj,
-        )
-        cache_info = _gen_list.__wrapped__.cache_info()
+        from guidance.library._json import GenJson
+        genjson = GenJson(schema=schema_obj)
+        genjson._join.__wrapped__.cache_clear()
+        _ = genjson.root()
+        cache_info = genjson._join.__wrapped__.cache_info()
 
         # Theoretical number of cache misses under the current implementation
         expected_misses = 2*num_properties - 1
@@ -2379,12 +2262,11 @@ def test_all_required_properties_doesnt_blow_up(self, num_properties):
             },
             "required": [f"prop_{i}" for i in range(num_properties)]
         }
-        from guidance.library._json import _gen_list
-        _gen_list.__wrapped__.cache_clear()
-        _ = gen_json(
-            schema=schema_obj,
-        )
-        cache_info = _gen_list.__wrapped__.cache_info()
+        from guidance.library._json import GenJson
+        genjson = GenJson(schema=schema_obj)
+        genjson._join.__wrapped__.cache_clear()
+        _ = genjson.root()
+        cache_info = genjson._join.__wrapped__.cache_info()
 
         # Theoretical number of cache misses under the current implementation
         expected_misses = num_properties
@@ -2427,3 +2309,64 @@ def test_false_schema(self, schema_obj):
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
         assert ve.value.args[0] == "No valid JSON can be generated from a schema of `False`"
+
+class TestWhitespace:
+    seps = [
+        (", ", ": "),
+        (",", ":"),
+        (",", ": "),
+        (", ", ":"),
+    ]
+
+    @pytest.mark.parametrize(
+        "schema, obj",
+        [
+            # Dynamic object (both item and key seps)
+            ({"type": "object"}, {"a": 1, "b": 2, "c": [1, 2, 3]}),
+            # Static object: enum (both item and key seps)
+            ({"enum": [{"a": 1, "b": 2, "c": [1, 2, 3]}]}, {"a": 1, "b": 2, "c": [1, 2, 3]}),
+            # Static object: const (both item and key seps)
+            ({"const": {"a": 1, "b": 2, "c": [1, 2, 3]}}, {"a": 1, "b": 2, "c": [1, 2, 3]}),
+        ]
+    )
+    @pytest.mark.parametrize(
+        "separators",
+        seps,
+    )
+    def test_separators(self, separators, schema, obj):
+        grammar = gen_json(schema=schema, separators=separators)
+        for seps in self.seps:
+            prepared_json = json.dumps(obj, separators=seps)
+            if separators == seps:
+                assert grammar.match(prepared_json) is not None
+                model = models.Mock(f"<s>{prepared_json}".encode())
+                assert str(model + grammar) == prepared_json
+            else:
+                assert grammar.match(prepared_json) is None
+
+    @pytest.mark.parametrize(
+        "schema, obj",
+        [
+            # Dynamic object (both item and key seps)
+            ({"type": "object"}, {"a": 1, "b": 2, "c": [1, 2, 3]}),
+            # Static object: enum (both item and key seps)
+            ({"enum": [{"a": 1, "b": 2, "c": [1, 2, 3]}]}, {"a": 1, "b": 2, "c": [1, 2, 3]}),
+            # Static object: const (both item and key seps)
+            ({"const": {"a": 1, "b": 2, "c": [1, 2, 3]}}, {"a": 1, "b": 2, "c": [1, 2, 3]}),
+        ]
+    )
+    @pytest.mark.parametrize(
+        "separators",
+        seps,
+    )
+    @pytest.mark.parametrize(
+        "indent",
+        [None, 0, 2, 4],
+    )
+    def test_whitespace_flexibility(self, indent, separators, schema, obj):
+        grammar = gen_json(schema=schema, whitespace_flexible=True)
+        prepared_json = json.dumps(obj, separators=separators, indent=indent)
+
+        assert grammar.match(prepared_json, raise_exceptions=True) is not None
+        model = models.Mock(f"<s>{prepared_json}".encode())
+        assert str(model + grammar) == prepared_json
diff --git a/tests/unit/library/test_json_stringformat.py b/tests/unit/library/test_json_stringformat.py
index 4d092fe3c..b484ccca2 100644
--- a/tests/unit/library/test_json_stringformat.py
+++ b/tests/unit/library/test_json_stringformat.py
@@ -72,7 +72,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 @pytest.mark.xfail(reason="json-pointer format not implemented")
@@ -134,7 +134,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 @pytest.mark.xfail(reason="idn-hostname format not implemented")
 class TestIdnHostname:
@@ -213,7 +213,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 @pytest.mark.xfail(reason="uri format not implemented")
@@ -263,7 +263,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 @pytest.mark.xfail(reason="uri-template format not implemented")
@@ -297,7 +297,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 @pytest.mark.xfail(reason="iri-reference format is not yet implemented")
 class TestIriReference:
@@ -333,7 +333,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 @pytest.mark.xfail(reason="iri format not implemented")
@@ -372,7 +372,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 class TestIpv4:
@@ -411,7 +411,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 @pytest.mark.xfail(reason="uri-reference format not implemented")
@@ -448,7 +448,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 class TestTime:
@@ -516,7 +516,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 class TestIpv6:
@@ -579,7 +579,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 class TestUnknown:
@@ -646,7 +646,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 class TestUuid:
@@ -690,7 +690,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 class TestEmail:
@@ -736,7 +736,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 class TestDuration:
@@ -784,7 +784,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 @pytest.mark.xfail(reason="relative-json-pointer format not implemented")
@@ -826,7 +826,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 class TestDateTime:
@@ -874,7 +874,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 @pytest.mark.xfail(reason="regex format not implemented")
 class TestRegex:
@@ -905,7 +905,7 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
 
 @pytest.mark.xfail(reason="idn-email format not implemented")
@@ -939,4 +939,4 @@ def test_good(self, target_str):
     )
     def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
-        check_match_failure(bad_string=bad_str, schema_obj=schema_obj, compact=True)
+        check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
diff --git a/tests/unit/library/test_pydantic.py b/tests/unit/library/test_pydantic.py
index e801e7f35..9bda573f6 100644
--- a/tests/unit/library/test_pydantic.py
+++ b/tests/unit/library/test_pydantic.py
@@ -1,5 +1,5 @@
 import inspect
-from json import dumps as json_dumps
+from json import dumps as original_json_dumps
 from functools import partial
 from typing import Any, Dict, Generic, List, Literal, Tuple, Type, TypeVar, Union, Set
 
@@ -8,25 +8,17 @@
 from pydantic.json_schema import to_jsonable_python as pydantic_to_jsonable_python
 
 from guidance import models, json as gen_json
-from guidance.library._json import WHITESPACE
 from ...utils import check_match_failure as _check_match_failure, generate_and_check as _generate_and_check
 
 
-def to_compact_json(target: Any) -> str:
+def json_dumps(target: Any) -> str:
     """
-    See 'Compact Encoding':
-    https://docs.python.org/3/library/json.html
-    Since this is ultimately about the generated
-    output, we don't need to worry about pretty printing
-    and whitespace
-
-    This function differs from the identically named one in
-    `library._json` by the  `default=pydantic_to_jsonable_python`
+    Set `default=pydantic_to_jsonable_python`
     kwarg to json_dumps, which allows json_dumps to dump pydantic
     objects.
     """
-    return json_dumps(
-        target, separators=(",", ":"), default=pydantic_to_jsonable_python
+    return original_json_dumps(
+        target, default=pydantic_to_jsonable_python
     )
 
 
@@ -66,7 +58,7 @@ def generate_and_check(
 ):
     # Sanity check what we're being asked
     target_obj = validate_obj(target_obj, pydantic_model)
-    prepared_json = to_compact_json(target_obj)
+    prepared_json = json_dumps(target_obj)
     assert validate_string(prepared_json, pydantic_model) == target_obj
 
     # Check that the grammar can produce the literal prepared_json string
@@ -80,19 +72,14 @@ def check_match_failure(
     failure_byte: bytes,
     allowed_bytes: Set[bytes],
     pydantic_model: Union[Type[pydantic.BaseModel], pydantic.TypeAdapter],
-    maybe_whitespace: bool,
-    compact: bool,
 ):
-    bad_string = to_compact_json(bad_obj)
-    grammar = gen_json(schema=pydantic_model, compact=compact)
+    bad_string = json_dumps(bad_obj)
+    grammar = gen_json(schema=pydantic_model)
     _check_match_failure(
         bad_string=bad_string,
         good_bytes=good_bytes,
         failure_byte=failure_byte,
-        allowed_bytes=(
-            allowed_bytes.union(WHITESPACE) if (maybe_whitespace and not compact)
-            else allowed_bytes
-        ),
+        allowed_bytes=allowed_bytes,
         grammar=grammar,
     )
 
@@ -167,10 +154,7 @@ def test_heterogeneous(self):
         model = pydantic.TypeAdapter(Tuple[int, bool])
         generate_and_check((1, True), model)
 
-    @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    def test_maxitems(self, compact):
+    def test_maxitems(self):
         model = pydantic.TypeAdapter(Tuple[int,])
         check_match_failure(
             bad_obj=(1, 2),
@@ -178,8 +162,6 @@ def test_maxitems(self, compact):
             failure_byte=b",",
             allowed_bytes={b"]", *{bytes([i]) for i in range(ord("0"), ord("9") + 1)}},
             pydantic_model=model,
-            maybe_whitespace=True,
-            compact=compact,
         )
 
 
@@ -250,29 +232,24 @@ def test_generic(self, my_type, my_obj):
         generate_and_check(obj, model)
 
     @pytest.mark.parametrize(
-        "compact", [True, False]
-    )
-    @pytest.mark.parametrize(
-        "my_type, my_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace",
+        "my_type, my_obj, good_bytes, failure_byte, allowed_bytes",
         [
-            (bool, "True", b"", b'"', {b"t", b"f"}, True),
-            (str, 42, b"", b"4", {b'"'}, True),
-            (int, False, b"", b"f", {b"-", *{bytes([i]) for i in range(ord("0"), ord("9") + 1)}}, True),
+            (bool, "True", b"", b'"', {b"t", b"f"}),
+            (str, 42, b"", b"4", {b'"'}),
+            (int, False, b"", b"f", {b"-", *{bytes([i]) for i in range(ord("0"), ord("9") + 1)}}),
         ],
     )
     def test_bad_generic(
-        self, my_type, my_obj, good_bytes, failure_byte, allowed_bytes, maybe_whitespace, compact
+        self, my_type, my_obj, good_bytes, failure_byte, allowed_bytes
     ):
         model = self.SimpleGeneric[my_type]
         obj = {"my_obj": my_obj}
         check_match_failure(
             bad_obj=obj,
-            good_bytes=b'{"my_obj":' + good_bytes,
+            good_bytes=b'{"my_obj": ' + good_bytes,
             failure_byte=failure_byte,
             allowed_bytes=allowed_bytes,
             pydantic_model=model,
-            maybe_whitespace=maybe_whitespace,
-            compact=compact,
         )
 
 class TestDiscriminatedUnion:
@@ -310,10 +287,8 @@ def test_good(self):
     def test_bad(self):
         check_match_failure(
             bad_obj={"pet": {"pet_type": "dog"}, "n": 42},
-            good_bytes=b'{"pet":{"pet_type":"dog"',
+            good_bytes=b'{"pet": {"pet_type": "dog"',
             failure_byte=b"}",
             allowed_bytes={b","}, # expect a comma to continue the object with "barks"
             pydantic_model=self.Model,
-            maybe_whitespace=False,
-            compact=True
         )

From 77fc3999e1545c10f17e6da1b6cbd1feeaa1ca1a Mon Sep 17 00:00:00 2001
From: Saibo-creator <53392976+Saibo-creator@users.noreply.github.com>
Date: Wed, 23 Oct 2024 19:56:32 +0200
Subject: [PATCH 02/30] Fix typos in README (#1056)

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 82ec2005f..6b5001975 100644
--- a/README.md
+++ b/README.md
@@ -477,7 +477,7 @@ def calculator_call(lm):
 @guidance
 def calculator(lm):
     expression = lm['tool_args']
-    # You typically don't want to run eval directly for save reasons
+    # You typically don't want to run eval directly for security reasons
     # Here we are guaranteed to only have mathematical expressions
     lm += f' = {eval(expression)}'
     return lm
@@ -489,7 +489,7 @@ lm += gen(max_tokens=30, tools=[calculator_tool], stop='\n\n')
 
 
 ### Gsm8k example
-Notice that the calculator is just called seamlessly during generation. Here is a more realistic exampe of the model solving a gsm8k question:
+Notice that the calculator is just called seamlessly during generation. Here is a more realistic example of the model solving a gsm8k question:
 
 ```python
 @guidance

From da80081e3e7b611ecf7b265e20273a5229403a7d Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Mon, 28 Oct 2024 18:50:23 -0700
Subject: [PATCH 03/30] [Feature] Expand JSON `$ref` resolution (#1061)

1. Refs are now resolved in full generality, allowing anchors, relative
refs, and absolute refs.
2. Rather than pre-computing the grammars for schemas that happen to
live in `$defs`, we now lazily compute grammars upon first reference.
3. Existing ref tests are replaced with the full set of tests from the
JSON Schema test suite. Some are xfailed if they depend on other
features that we do not (yet) support.
4. Keys in objects are now properly escaped in order to guarantee
json.loads-ability (discovered this issue when running the new tests)

NOTE: this introduces a new dependency: `referencing`, which handles ref
lookup for us (a fairly non-trivial task).
---
 guidance/library/_json.py       |  159 +++--
 setup.py                        |    1 +
 tests/unit/library/test_json.py | 1093 ++++++++++++++++++++++++++-----
 3 files changed, 1043 insertions(+), 210 deletions(-)

diff --git a/guidance/library/_json.py b/guidance/library/_json.py
index a7d3354b4..4f8c98ce0 100644
--- a/guidance/library/_json.py
+++ b/guidance/library/_json.py
@@ -14,6 +14,9 @@
     cast,
 )
 import warnings
+import referencing
+import contextlib
+from urllib.parse import urljoin
 
 try:
     import jsonschema
@@ -165,6 +168,7 @@ class ObjectKeywords(str, Enum):
 DEFS_KEYS = {"$defs", "definitions"}
 
 IGNORED_KEYS = {
+    "$anchor",
     "$schema",
     "$id",
     "id",
@@ -401,31 +405,81 @@ def __init__(self, schema: JSONSchema, separators: Optional[tuple[str, str]] = N
         self.schema = schema
         if separators is not None:
             self.item_separator, self.key_separator = separators
-        if isinstance(schema, Mapping):
-            self.definitions = self._build_definitions(schema.get("$defs", schema.get("definitions", {})))
-        else:
-            self.definitions = {}
 
-    def _build_definitions(
+        registry: referencing.Registry[JSONSchema] = referencing.Registry()
+        resource: referencing.Resource[JSONSchema] = referencing.jsonschema.DRAFT202012.create_resource(schema)
+        self._base_uri = resource.id() or ""
+        registry = registry.with_resource(
+            uri=self._base_uri,
+            resource=resource
+        )
+        self._resolver = registry.resolver()
+        self._defs: dict[str, Callable[[], GrammarFunction]] = {}
+
+
+    @guidance(stateless=True)
+    def ref(
         self,
-        raw_definitions: Mapping[str, JSONSchema],
-    ) -> Mapping[str, Callable[[], GrammarFunction]]:
-        definitions: Dict[str, Callable[[], GrammarFunction]] = {}
+        lm,
+        *,
+        reference: str,
+    ):
+        """
+        Resolve a reference to another schema and return the grammar for that schema.
+
+        Note: we define a zero-argument closure that will return the grammar for the reference and
+        add it to the _defs cache. This allows us to avoid re-resolving the reference every time
+        and to handle recursive references correctly.
+        """
+        abspath = self._get_abspath(reference)
+        if abspath not in self._defs:
+            resolved = self._resolver.lookup(abspath)
+            base_uri_of_resolved = resolved.resolver._base_uri
 
-        def build_definition(json_schema: JSONSchema) -> Callable[[], GrammarFunction]:
             @guidance(stateless=True, dedent=False, cache=True)
             def closure(lm):
-                return lm + self.json(json_schema=json_schema)
-
-            return closure
+                with self._base_uri_context(base_uri_of_resolved):
+                    grammar = self.json(json_schema=resolved.contents)
+                return lm + grammar
+
+            self._defs[abspath] = closure
+        return lm + self._defs[abspath]()
+
+
+    def _get_abspath(self, ref):
+        """
+        Convert a reference to an absolute path, resolving it against the base URI if necessary.
+        This will allow us to get a unique key for each reference and hit the _defs cache correctly.
+        """
+        if ref.startswith("#"):
+            # Special case for fragment-only references:
+            # for certain schemes (e.g. urn), urljoin may throw the base URI, but we need to keep them around
+            return f"{self._base_uri}{ref}"
+        return urljoin(self._base_uri, ref)
+
+
+    @contextlib.contextmanager
+    def _base_uri_context(self, base_uri: str):
+        """
+        Temporarily replace the base_uri for the duration of the context manager.
+        This allows refs with different base URIs to be resolved correctly without passing the resolver around.
+
+        Note: very much not thread-safe, but I don't expect instances of this class to be shared between threads.
+        TODO: ensure that the instance's hash depends on the base_uri before adding more caching to this class.
+        """
+        old_base_uri = self._base_uri
+        self._base_uri = base_uri
+        try:
+            yield
+        finally:
+            self._base_uri = old_base_uri
 
-        definitions = {ref: build_definition(schema) for ref, schema in raw_definitions.items()}
-        return definitions
 
     @guidance(stateless=True)
     def root(self, lm):
         return lm + self.json(json_schema=self.schema)
 
+
     @classmethod
     @guidance(stateless=True)
     def integer(cls, lm, minimum: Union[float, int, None] = None, maximum: Union[float, int, None] = None, exclusiveMinimum: bool = False, exclusiveMaximum: bool = False):
@@ -515,37 +569,42 @@ def object(
                 f"Required properties not in properties but additionalProperties is False."
                 f" Missing required properties: {list(r for r in required if r not in properties)}"
             )
-        items = [
-            # First iterate over the properties in order
-            *properties.items(),
-            # If there are any keys in required that weren't specified by properties, add them in order at the end,
-            # where we will validate against the additional_properties schema
-            *((key, additional_properties) for key in required if key not in properties),
-        ]
-        grammars = tuple(f'"{name}"{self.key_separator}' + self.json(json_schema=schema) for name, schema in items)
-        required_items = tuple(name in required for name, _ in items)
-        names = set(properties.keys()) | set(required)
-        key_grammar: GrammarFunction
-        if len(names) > 0:
-            # If there are any properties, we need to disallow them as additionalProperties
-            key_grammar = as_regular_grammar(
-                And([
-                    lexeme(r'"([^"\\]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*"'),
-                    Not(lexeme('"(' + '|'.join(quote_regex(name) for name in names) + ')"')),
-                ]),
-                lexeme = True,
-            )
-        else:
-            key_grammar = self.string()
+
+        keys: list[str] = []
+        required_items: list[bool] = []
+        grammars: list[GrammarFunction] = []
+        # First iterate over the properties in order, then iterate over any missing required keys, using additional_properties as the schema
+        for name in (*properties, *(r for r in required if r not in properties)):
+            # Use json_dumps to properly quote / escape the key
+            key = json_dumps(name)
+            keys.append(key)
+            # Identify if the key is required
+            required_items.append(name in required)
+            # Build the grammar we'll use for this property
+            grammars.append(f'{key}{self.key_separator}' + self.json(json_schema=properties.get(name, additional_properties)))
+
         if additional_properties is not False:
-            additional_item_grammar = key_grammar + self.key_separator + self.json(json_schema=additional_properties)
+            # Key for additionalProperties is a json string, but we need to disallow any properties that are already defined
+            additional_key_grammar: GrammarFunction
+            if len(keys) > 0:
+                additional_key_grammar = as_regular_grammar(
+                    And([
+                        lexeme(r'"([^"\\]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*"'),
+                        Not(lexeme('|'.join(map(quote_regex, keys)))),
+                    ]),
+                    lexeme = True,
+                )
+            else:
+                additional_key_grammar = self.string()
+
+            additional_item_grammar = additional_key_grammar + self.key_separator + self.json(json_schema=additional_properties)
             additional_items_grammar = sequence(additional_item_grammar + self.item_separator) + additional_item_grammar
-            grammars += (additional_items_grammar,)
-            required_items += (False,)
+            grammars.append(additional_items_grammar)
+            required_items.append(False)
 
         return lm + "{" + self._join(
-            elements = grammars,
-            required = required_items,
+            elements = tuple(grammars),
+            required = tuple(required_items),
         ) + "}"
 
 
@@ -734,24 +793,6 @@ def any(self, lm):
         )
 
 
-    @guidance(stateless=True, cache=True)
-    def ref(
-        self,
-        lm,
-        *,
-        reference: str,
-    ):
-        target_definition = None
-        for dk in DEFS_KEYS:
-            ref_start = f"#/{dk}/"
-            if reference.startswith(ref_start):
-                target_name = reference[len(ref_start) :]
-                target_definition = self.definitions[target_name]
-
-        assert target_definition is not None
-        return lm + target_definition()
-
-
     @guidance(stateless=True)
     def json(
         self,
diff --git a/setup.py b/setup.py
index 72c23d468..45290dcf1 100644
--- a/setup.py
+++ b/setup.py
@@ -26,6 +26,7 @@
     "ordered_set",
     "platformdirs",
     "pydantic",
+    "referencing",
     "requests",
     "tiktoken>=0.3",
     "llguidance>=0.1.7",
diff --git a/tests/unit/library/test_json.py b/tests/unit/library/test_json.py
index da7d5459a..cad0d6742 100644
--- a/tests/unit/library/test_json.py
+++ b/tests/unit/library/test_json.py
@@ -1121,194 +1121,985 @@ def test_bad_with_items(
         )
 
 
-class TestWithReferences:
+class TestRefs:
     @pytest.mark.parametrize(
-        "target_obj",
+        ["test_object", "valid"],
         [
-            dict(all_cats=[]),
-            dict(all_cats=[dict(name="Kasha")]),
-            dict(all_cats=[dict(name="Dawon"), dict(name="Barong")]),
+            # match
+            ({"foo": False}, True),
+            # recursive match
+            ({"foo": {"foo": False}}, True),
+            # mismatch
+            ({"bar": False}, False),
+            # recursive mismatch
+            ({"foo": {"bar": False}}, False),
         ],
     )
-    def test_simple_ref(self, target_obj):
-        schema = """{
-        "$defs": {
-            "Cat": {
+    def test_root_pointer_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {"foo": {"$ref": "#"}},
+            "additionalProperties": False,
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # match
+            ({"bar": 3}, True),
+            # mismatch
+            ({"bar": True}, False),
+        ],
+    )
+    def test_relative_pointer_ref_to_object(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {"foo": {"type": "integer"}, "bar": {"$ref": "#/properties/foo"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # match array
+            ([1, 2], True),
+            # mismatch array
+            ([1, "foo"], False),
+        ],
+    )
+    def test_relative_pointer_ref_to_array(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "prefixItems": [{"type": "integer"}, {"$ref": "#/prefixItems/0"}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # slash invalid
+            ({"slash": "aoeu"}, False),
+            # tilde invalid
+            ({"tilde": "aoeu"}, False),
+            # percent invalid
+            ({"percent": "aoeu"}, False),
+            # slash valid
+            ({"slash": 123}, True),
+            # tilde valid
+            ({"tilde": 123}, True),
+            # percent valid
+            ({"percent": 123}, True),
+        ],
+    )
+    def test_escaped_pointer_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {
+                "tilde~field": {"type": "integer"},
+                "slash/field": {"type": "integer"},
+                "percent%field": {"type": "integer"},
+            },
             "properties": {
-                "name": {
-                "title": "Name",
-                "type": "string"
-                }
+                "tilde": {"$ref": "#/$defs/tilde~0field"},
+                "slash": {"$ref": "#/$defs/slash~1field"},
+                "percent": {"$ref": "#/$defs/percent%25field"},
             },
-            "required": [
-                "name"
-            ],
-            "title": "Cat",
-            "type": "object"
-            }
-        },
-        "properties": {
-            "all_cats": {
-            "items": {
-                "$ref": "#/$defs/Cat"
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # nested ref valid
+            (5, True),
+            # nested ref invalid
+            ("a", False),
+        ],
+    )
+    def test_nested_refs(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {
+                "a": {"type": "integer"},
+                "b": {"$ref": "#/$defs/a"},
+                "c": {"$ref": "#/$defs/b"},
             },
-            "title": "All Cats",
-            "type": "array"
-            }
-        },
-        "required": [
-            "all_cats"
+            "$ref": "#/$defs/c",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # ref valid, maxItems valid
+            ({"foo": []}, True),
+            # ref valid, maxItems invalid
+            pytest.param(
+                *({"foo": [1, 2, 3]}, False),
+                marks=pytest.mark.xfail(reason="sibling keywords to ref are not yet supported"),
+            ),
+            # ref invalid
+            ({"foo": "string"}, False),
         ],
-        "title": "CatList",
-        "type": "object"
-        }"""
+    )
+    def test_ref_applies_alongside_sibling_keywords(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {"reffed": {"type": "array"}},
+            "properties": {"foo": {"$ref": "#/$defs/reffed", "maxItems": 2}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-        # First sanity check what we're setting up
-        schema_obj = json.loads(schema)
-        validate(instance=target_obj, schema=schema_obj)
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # remote ref valid
+            ({"minLength": 1}, True),
+            # remote ref invalid
+            ({"minLength": -1}, False),
+        ],
+    )
+    @pytest.mark.xfail(reason="Remote refs are not supported")
+    def test_remote_ref_containing_refs_itself(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "https://json-schema.org/draft/2020-12/schema",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-        # The actual check
-        generate_and_check(target_obj, schema_obj)
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # property named $ref valid
+            ({"$ref": "a"}, True),
+            # property named $ref invalid
+            ({"$ref": 2}, False),
+        ],
+    )
+    def test_property_named_ref_that_is_not_a_reference(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {"$ref": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
     @pytest.mark.parametrize(
-        "target_obj",
+        ["test_object", "valid"],
         [
-            dict(all_cats=[]),
-            dict(all_cats=[dict(name="Kasha")]),
-            dict(all_cats=[dict(name="Dawon"), dict(name="Barong")]),
+            # property named $ref valid
+            ({"$ref": "a"}, True),
+            # property named $ref invalid
+            ({"$ref": 2}, False),
         ],
     )
-    def test_simple_ref_alt(self, target_obj):
-        # Uses 'definitions' rather than '$defs'
-        schema = """{
-        "definitions": {
-            "Cat": {
+    def test_property_named_ref_containing_an_actual_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {"$ref": {"$ref": "#/$defs/is-string"}},
+            "$defs": {"is-string": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # any value is valid
+            ("foo", True)
+        ],
+    )
+    def test_ref_to_boolean_schema_true(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "#/$defs/bool",
+            "$defs": {"bool": True},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # any value is invalid
+            ("foo", False)
+        ],
+    )
+    @pytest.mark.xfail(reason="false schema is not implemented")
+    def test_ref_to_boolean_schema_false(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "#/$defs/bool",
+            "$defs": {"bool": False},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # valid tree
+            (
+                {
+                    "meta": "root",
+                    "nodes": [
+                        {
+                            "value": 1,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [{"value": 1.1}, {"value": 1.2}],
+                            },
+                        },
+                        {
+                            "value": 2,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [{"value": 2.1}, {"value": 2.2}],
+                            },
+                        },
+                    ],
+                },
+                True,
+            ),
+            # invalid tree
+            (
+                {
+                    "meta": "root",
+                    "nodes": [
+                        {
+                            "value": 1,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [{"value": "string is invalid"}, {"value": 1.2}],
+                            },
+                        },
+                        {
+                            "value": 2,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [{"value": 2.1}, {"value": 2.2}],
+                            },
+                        },
+                    ],
+                },
+                False,
+            ),
+        ],
+    )
+    def test_Recursive_references_between_schemas(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "http://localhost:1234/draft2020-12/tree",
+            "description": "tree of nodes",
+            "type": "object",
             "properties": {
-                "name": {
-                "title": "Name",
-                "type": "string"
-                }
+                "meta": {"type": "string"},
+                "nodes": {"type": "array", "items": {"$ref": "node"}},
             },
-            "required": [
-                "name"
-            ],
-            "title": "Cat",
-            "type": "object"
-            }
-        },
-        "properties": {
-            "all_cats": {
-            "items": {
-                "$ref": "#/definitions/Cat"
+            "required": ["meta", "nodes"],
+            "$defs": {
+                "node": {
+                    "$id": "http://localhost:1234/draft2020-12/node",
+                    "description": "node",
+                    "type": "object",
+                    "properties": {"value": {"type": "number"}, "subtree": {"$ref": "tree"}},
+                    "required": ["value"],
+                }
             },
-            "title": "All Cats",
-            "type": "array"
-            }
-        },
-        "required": [
-            "all_cats"
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # object with numbers is valid
+            ({'foo"bar': 1}, True),
+            # object with strings is invalid
+            ({'foo"bar': "1"}, False),
         ],
-        "title": "CatList",
-        "type": "object"
-        }"""
+    )
+    def test_refs_with_quote(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {'foo"bar': {"$ref": "#/$defs/foo%22bar"}},
+            "$defs": {'foo"bar': {"type": "number"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-        # First sanity check what we're setting up
-        schema_obj = json.loads(schema)
-        validate(instance=target_obj, schema=schema_obj)
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # referenced subschema doesn't see annotations from properties
+            ({"prop1": "match"}, False)
+        ],
+    )
+    @pytest.mark.xfail(reason="unevaluatedProperties is not implemented")
+    def test_ref_creates_new_scope_when_adjacent_to_keywords(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {"A": {"unevaluatedProperties": False}},
+            "properties": {"prop1": {"type": "string"}},
+            "$ref": "#/$defs/A",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-        # The actual check
-        generate_and_check(target_obj, schema_obj)
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # do not evaluate the $ref inside the enum, matching any string
+            ("this is a string", False),
+            # do not evaluate the $ref inside the enum, definition exact match
+            ({"type": "string"}, False),
+            # match the enum exactly
+            ({"$ref": "#/$defs/a_string"}, True),
+        ],
+    )
+    def test_naive_replacement_of_ref_with_its_destination_is_not_correct(
+        self, test_object, valid
+    ):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {"a_string": {"type": "string"}},
+            "enum": [{"$ref": "#/$defs/a_string"}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-    @pytest.mark.parametrize("temperature", [None, 0.1, 1])
-    def test_nested_ref(self, temperature):
-        schema = """{
-        "$defs": {
-            "A": {
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # invalid on inner field
+            ({"foo": {"bar": 1}, "bar": "a"}, False),
+            # invalid on outer field
+            ({"foo": {"bar": "a"}, "bar": 1}, False),
+            # valid on both fields
+            pytest.param(
+                *({"foo": {"bar": "a"}, "bar": "a"}, True),
+                marks=pytest.mark.xfail(reason="refs with sibling keywords are not yet supported; foo here is being seen as an additionalProperty before bar"),
+            ),
+        ],
+    )
+    def test_refs_with_relative_uris_and_defs(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "http://example.com/schema-relative-uri-defs1.json",
             "properties": {
-                "name": {
-                "title": "Name",
-                "type": "string"
+                "foo": {
+                    "$id": "schema-relative-uri-defs2.json",
+                    "$defs": {"inner": {"properties": {"bar": {"type": "string"}}}},
+                    "$ref": "#/$defs/inner",
                 }
             },
-            "required": [
-                "name"
-            ],
-            "title": "A",
-            "type": "object"
-            },
-            "B": {
+            "$ref": "schema-relative-uri-defs2.json",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # invalid on inner field
+            ({"foo": {"bar": 1}, "bar": "a"}, False),
+            # invalid on outer field
+            ({"foo": {"bar": "a"}, "bar": 1}, False),
+            # valid on both fields
+            pytest.param(
+                *({"foo": {"bar": "a"}, "bar": "a"}, True),
+                marks=pytest.mark.xfail(reason="refs with sibling keywords are not yet supported; foo here is being seen as an additionalProperty before bar"),
+            ),
+        ],
+    )
+    def test_relative_refs_with_absolute_uris_and_defs(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "http://example.com/schema-refs-absolute-uris-defs1.json",
             "properties": {
-                "other_str": {
-                "title": "Other Str",
-                "type": "string"
-                },
-                "my_A": {
-                "$ref": "#/$defs/A"
+                "foo": {
+                    "$id": "http://example.com/schema-refs-absolute-uris-defs2.json",
+                    "$defs": {"inner": {"properties": {"bar": {"type": "string"}}}},
+                    "$ref": "#/$defs/inner",
                 }
             },
-            "required": [
-                "other_str",
-                "my_A"
-            ],
-            "title": "B",
-            "type": "object"
-            }
-        },
-        "properties": {
-            "my_B": {
-            "$ref": "#/$defs/B"
-            }
-        },
-        "required": [
-            "my_B"
+            "$ref": "schema-refs-absolute-uris-defs2.json",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # number is valid
+            (1, True),
+            # non-number is invalid
+            ("a", False),
         ],
-        "title": "C",
-        "type": "object"
-        }"""
+    )
+    def test_id_must_be_resolved_against_nearest_parent_not_just_immediate_parent(
+        self, test_object, valid
+    ):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "http://example.com/a.json",
+            "$defs": {
+                "x": {
+                    "$id": "http://example.com/b/c.json",
+                    "not": {"$defs": {"y": {"$id": "d.json", "type": "number"}}},
+                }
+            },
+            "allOf": [{"$ref": "http://example.com/b/d.json"}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-        target_obj = dict(my_B=dict(other_str="some string", my_A=dict(name="my name")))
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # data is valid against first definition
+            (5, True),
+            # data is invalid against first definition
+            (50, False),
+        ],
+    )
+    def test_order_of_evaluation_id_and_ref(self, test_object, valid):
+        schema = {
+            "$comment": "$id must be evaluated before $ref to get the proper $ref destination",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://example.com/draft2020-12/ref-and-id1/base.json",
+            "$ref": "int.json",
+            "$defs": {
+                "bigint": {
+                    "$comment": "canonical uri: https://example.com/ref-and-id1/int.json",
+                    "$id": "int.json",
+                    "maximum": 10,
+                },
+                "smallint": {
+                    "$comment": "canonical uri: https://example.com/ref-and-id1-int.json",
+                    "$id": "/draft2020-12/ref-and-id1-int.json",
+                    "maximum": 2,
+                },
+            },
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-        # First sanity check what we're setting up
-        schema_obj = json.loads(schema)
-        validate(instance=target_obj, schema=schema_obj)
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # data is valid against first definition
+            (5, True),
+            # data is invalid against first definition
+            (50, False),
+        ],
+    )
+    def test_order_of_evaluation_id_and_anchor_and_ref(self, test_object, valid):
+        schema = {
+            "$comment": "$id must be evaluated before $ref to get the proper $ref destination",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://example.com/draft2020-12/ref-and-id2/base.json",
+            "$ref": "#bigint",
+            "$defs": {
+                "bigint": {
+                    "$comment": "canonical uri: /ref-and-id2/base.json#/$defs/bigint; another valid uri for this location: /ref-and-id2/base.json#bigint",
+                    "$anchor": "bigint",
+                    "maximum": 10,
+                },
+                "smallint": {
+                    "$comment": "canonical uri: https://example.com/ref-and-id2#/$defs/smallint; another valid uri for this location: https://example.com/ref-and-id2/#bigint",
+                    "$id": "https://example.com/draft2020-12/ref-and-id2/",
+                    "$anchor": "bigint",
+                    "maximum": 2,
+                },
+            },
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-        # The actual check
-        generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # valid under the URN IDed schema
+            ({"foo": 37}, True),
+            # invalid under the URN IDed schema
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_simple_URN_base_URI_with_ref_via_the_URN(self, test_object, valid):
+        schema = {
+            "$comment": "URIs do not have to have HTTP(s) schemes",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:uuid:deadbeef-1234-ffff-ffff-4321feebdaed",
+            "minimum": 30,
+            "properties": {"foo": {"$ref": "urn:uuid:deadbeef-1234-ffff-ffff-4321feebdaed"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-    @pytest.mark.parametrize("temperature", [None, 0.1, 1])
-    def test_multiple_refs_to_same_def(self, temperature):
-        schema = """{
-        "$defs": {
-            "A": {
-                "properties": {
-                    "name": {
-                        "type": "string"
-                    }
-                },
-                "required": ["name"],
-                "type": "object"
-            }
-        },
-        "properties": {
-            "A1": {
-                "$ref": "#/$defs/A"
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_simple_URN_base_URI_with_JSON_pointer(self, test_object, valid):
+        schema = {
+            "$comment": "URIs do not have to have HTTP(s) schemes",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:uuid:deadbeef-1234-00ff-ff00-4321feebdaed",
+            "properties": {"foo": {"$ref": "#/$defs/bar"}},
+            "$defs": {"bar": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_URN_base_URI_with_NSS(self, test_object, valid):
+        schema = {
+            "$comment": "RFC 8141 §2.2",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:example:1/406/47452/2",
+            "properties": {"foo": {"$ref": "#/$defs/bar"}},
+            "$defs": {"bar": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_URN_base_URI_with_r_component(self, test_object, valid):
+        schema = {
+            "$comment": "RFC 8141 §2.3.1",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:example:foo-bar-baz-qux?+CCResolve:cc=uk",
+            "properties": {"foo": {"$ref": "#/$defs/bar"}},
+            "$defs": {"bar": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_URN_base_URI_with_q_component(self, test_object, valid):
+        schema = {
+            "$comment": "RFC 8141 §2.3.2",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:example:weather?=op=map&lat=39.56&lon=-104.85&datetime=1969-07-21T02:56:15Z",
+            "properties": {"foo": {"$ref": "#/$defs/bar"}},
+            "$defs": {"bar": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_URN_base_URI_with_URN_and_JSON_pointer_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:uuid:deadbeef-1234-0000-0000-4321feebdaed",
+            "properties": {
+                "foo": {"$ref": "urn:uuid:deadbeef-1234-0000-0000-4321feebdaed#/$defs/bar"}
             },
-            "A2": {
-                "$ref": "#/$defs/A"
-            }
-        },
-        "required": ["A1", "A2"],
-        "type": "object"
-        }"""
+            "$defs": {"bar": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-        target_obj = dict(A1=dict(name="Romulus"), A2=dict(name="Remus"))
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_URN_base_URI_with_URN_and_anchor_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:uuid:deadbeef-1234-ff00-00ff-4321feebdaed",
+            "properties": {
+                "foo": {"$ref": "urn:uuid:deadbeef-1234-ff00-00ff-4321feebdaed#something"}
+            },
+            "$defs": {"bar": {"$anchor": "something", "type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-        # First sanity check what we're setting up
-        schema_obj = json.loads(schema)
-        validate(instance=target_obj, schema=schema_obj)
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ("bar", True),
+            # a non-string is invalid
+            (12, False),
+        ],
+    )
+    def test_URN_ref_with_nested_pointer_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "urn:uuid:deadbeef-4321-ffff-ffff-1234feebdaed",
+            "$defs": {
+                "foo": {
+                    "$id": "urn:uuid:deadbeef-4321-ffff-ffff-1234feebdaed",
+                    "$defs": {"bar": {"type": "string"}},
+                    "$ref": "#/$defs/bar",
+                }
+            },
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
-        # The actual check
-        generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a non-integer is invalid due to the $ref
+            ("foo", False),
+            # an integer is valid
+            (12, True),
+        ],
+    )
+    @pytest.mark.xfail(reason="if not implemented")
+    def test_ref_to_if(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "http://example.com/ref/if",
+            "if": {"$id": "http://example.com/ref/if", "type": "integer"},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a non-integer is invalid due to the $ref
+            ("foo", False),
+            # an integer is valid
+            (12, True),
+        ],
+    )
+    @pytest.mark.xfail(reason="then not implemented")
+    def test_ref_to_then(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "http://example.com/ref/then",
+            "then": {"$id": "http://example.com/ref/then", "type": "integer"},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a non-integer is invalid due to the $ref
+            ("foo", False),
+            # an integer is valid
+            (12, True),
+        ],
+    )
+    @pytest.mark.xfail(reason="else not implemented")
+    def test_ref_to_else(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "http://example.com/ref/else",
+            "else": {"$id": "http://example.com/ref/else", "type": "integer"},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ("foo", True),
+            # an integer is invalid
+            (12, False),
+        ],
+    )
+    def test_ref_with_absolute_path_reference(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "http://example.com/ref/absref.json",
+            "$defs": {
+                "a": {"$id": "http://example.com/ref/absref/foobar.json", "type": "number"},
+                "b": {"$id": "http://example.com/absref/foobar.json", "type": "string"},
+            },
+            "$ref": "/absref/foobar.json",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # number is valid
+            (1, True),
+            # non-number is invalid
+            ("a", False),
+        ],
+    )
+    def test_id_with_file_URI_still_resolves_pointers___nix(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "file:///folder/file.json",
+            "$defs": {"foo": {"type": "number"}},
+            "$ref": "#/$defs/foo",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # number is valid
+            (1, True),
+            # non-number is invalid
+            ("a", False),
+        ],
+    )
+    def test_id_with_file_URI_still_resolves_pointers___windows(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "file:///c:/folder/file.json",
+            "$defs": {"foo": {"type": "number"}},
+            "$ref": "#/$defs/foo",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # number is valid
+            (1, True),
+            # non-number is invalid
+            ("a", False),
+        ],
+    )
+    def test_empty_tokens_in_ref_json_pointer(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {"": {"$defs": {"": {"type": "number"}}}},
+            "allOf": [{"$ref": "#/$defs//$defs/"}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
 
 
 class TestAnyOf:

From dc5a08083bec00bd06e54138b581516f18c19f76 Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Tue, 29 Oct 2024 14:15:03 -0700
Subject: [PATCH 04/30] [JSON] Raise exceptions when "sibling" keywords are
 unhandled (#1063)

When an applicator has sibling keywords, JSON schema mandates that both sets of keywords are respected. This PR ensures that we raise early exceptions wherever this "schema intersection" behavior isn't explicitly handled.
---
 guidance/library/_json.py       |  64 ++++++++++++---
 tests/unit/library/test_json.py | 133 +++++++++++++++++++++++++++++---
 2 files changed, 173 insertions(+), 24 deletions(-)

diff --git a/guidance/library/_json.py b/guidance/library/_json.py
index 4f8c98ce0..93e0247e9 100644
--- a/guidance/library/_json.py
+++ b/guidance/library/_json.py
@@ -165,17 +165,17 @@ class ObjectKeywords(str, Enum):
     JSONType.OBJECT: ObjectKeywords,
 }
 
-DEFS_KEYS = {"$defs", "definitions"}
-
 IGNORED_KEYS = {
     "$anchor",
+    "$defs",
     "$schema",
     "$id",
     "id",
     "$comment",
     "title",
-    "description",
     "default",
+    "definitions",
+    "description",
     "examples",
 }
 
@@ -188,7 +188,7 @@ class ObjectKeywords(str, Enum):
 IGNORED_KEYS.add("discriminator")
 
 WHITESPACE = {b" ", b"\t", b"\n", b"\r"}
-VALID_KEYS = set(Keyword) | IGNORED_KEYS | DEFS_KEYS | set(NumberKeywords) | set(StringKeywords) | set(ArrayKeywords) | set(ObjectKeywords)
+VALID_KEYS = set(Keyword) | set(NumberKeywords) | set(StringKeywords) | set(ArrayKeywords) | set(ObjectKeywords) | IGNORED_KEYS
 
 FORMAT_PATTERNS: dict[str, Optional[str]] = {
     # https://json-schema.org/understanding-json-schema/reference/string#built-in-formats
@@ -398,6 +398,11 @@ def validate_json_node_keys(node: Mapping[str, Any]):
         )
 
 
+def get_sibling_keys(node: Mapping[str, Any], key: str) -> set[str]:
+    # Get the set of functional (non-ignored) keys that are siblings of the given key
+    return set(node.keys()) & VALID_KEYS - set(IGNORED_KEYS) - {key}
+
+
 class GenJson:
     item_separator = ", "
     key_separator = ": "
@@ -723,7 +728,20 @@ def const(
         lm,
         *,
         value: Union[None, bool, int, float, str, Mapping, Sequence],
+        instance_type: Optional[Union[str, Sequence[str]]] = None,
+        enum: Optional[Sequence[Union[None, bool, int, float, str, Mapping, Sequence]]] = None,
     ):
+        schema_to_validate_against: dict[str, Any] = {}
+        if instance_type is not None:
+            schema_to_validate_against["type"] = instance_type
+        if enum is not None:
+            schema_to_validate_against["enum"] = enum
+        if schema_to_validate_against:
+            # Raise a validation error if the value doesn't match the type
+            jsonschema.validate(
+                instance=value,
+                schema=schema_to_validate_against,
+            )
         # Base case
         if isinstance(value, (type(None), bool, int, float, str)):
             return lm + json_dumps(value)
@@ -756,14 +774,18 @@ def enum(
         self,
         lm,
         *,
-        options: Sequence[Mapping[str, Any]]
+        options: Sequence[Union[None, bool, int, float, str, Mapping, Sequence]],
+        instance_type: Optional[Union[str, Sequence[str]]] = None,
     ):
-        # TODO: can we support a whitespace-flexible version of this?
         all_opts: list[GrammarFunction] = []
-        for opt in options:
-            all_opts.append(
-                self.const(value=opt)
-            )
+        for instance in options:
+            try:
+                grm = self.const(value=instance, instance_type=instance_type)
+            except jsonschema.ValidationError:
+                continue
+            all_opts.append(grm)
+        if not all_opts:
+            raise ValueError(f"No valid options found for enum with type {instance_type!r}: {options}")
         return lm + select(options=all_opts)
 
 
@@ -811,15 +833,24 @@ def json(
         validate_json_node_keys(json_schema)
 
         if Keyword.ANYOF in json_schema:
+            sibling_keys = get_sibling_keys(json_schema, Keyword.ANYOF)
+            if sibling_keys:
+                raise NotImplementedError(f"anyOf with sibling keys is not yet supported. Got {sibling_keys}")
             return lm + self.anyOf(anyof_list=json_schema[Keyword.ANYOF])
 
         if Keyword.ALLOF in json_schema:
+            sibling_keys = get_sibling_keys(json_schema, Keyword.ALLOF)
+            if sibling_keys:
+                raise NotImplementedError(f"allOf with sibling keys is not yet supported. Got {sibling_keys}")
             allof_list = json_schema[Keyword.ALLOF]
             if len(allof_list) != 1:
                 raise ValueError("Only support allOf with exactly one item")
             return lm + self.json(json_schema=allof_list[0])
 
         if Keyword.ONEOF in json_schema:
+            sibling_keys = get_sibling_keys(json_schema, Keyword.ONEOF)
+            if sibling_keys:
+                raise NotImplementedError(f"oneOf with sibling keys is not yet supported. Got {sibling_keys}")
             oneof_list = json_schema[Keyword.ONEOF]
             if len(oneof_list) == 1:
                 return lm + self.json(json_schema=oneof_list[0])
@@ -827,13 +858,22 @@ def json(
             return lm + self.anyOf(anyof_list=oneof_list)
 
         if Keyword.REF in json_schema:
+            sibling_keys = get_sibling_keys(json_schema, Keyword.REF)
+            if sibling_keys:
+                raise NotImplementedError(f"$ref with sibling keys is not yet supported. Got {sibling_keys}")
             return lm + self.ref(reference=json_schema[Keyword.REF])
 
         if Keyword.CONST in json_schema:
-            return lm + self.const(value=json_schema[Keyword.CONST])
+            sibling_keys = get_sibling_keys(json_schema, Keyword.CONST) - {Keyword.TYPE, Keyword.ENUM}
+            if sibling_keys:
+                raise NotImplementedError(f"const with sibling keys is not yet supported. Got {sibling_keys}")
+            return lm + self.const(value=json_schema[Keyword.CONST], instance_type=json_schema.get(Keyword.TYPE, None), enum=json_schema.get(Keyword.ENUM, None))
 
         if Keyword.ENUM in json_schema:
-            return lm + self.enum(options=json_schema[Keyword.ENUM])
+            sibling_keys = get_sibling_keys(json_schema, Keyword.ENUM) - {Keyword.TYPE}
+            if sibling_keys:
+                raise NotImplementedError(f"enum with sibling keys is not yet supported. Got {sibling_keys}")
+            return lm + self.enum(options=json_schema[Keyword.ENUM], instance_type=json_schema.get(Keyword.TYPE, None))
 
         if Keyword.TYPE in json_schema:
             target_types = cast(Union[str, Sequence[str]], json_schema[Keyword.TYPE])
diff --git a/tests/unit/library/test_json.py b/tests/unit/library/test_json.py
index cad0d6742..2deea6eda 100644
--- a/tests/unit/library/test_json.py
+++ b/tests/unit/library/test_json.py
@@ -1265,14 +1265,12 @@ def test_nested_refs(self, test_object, valid):
             # ref valid, maxItems valid
             ({"foo": []}, True),
             # ref valid, maxItems invalid
-            pytest.param(
-                *({"foo": [1, 2, 3]}, False),
-                marks=pytest.mark.xfail(reason="sibling keywords to ref are not yet supported"),
-            ),
+            ({"foo": [1, 2, 3]}, False),
             # ref invalid
             ({"foo": "string"}, False),
         ],
     )
+    @pytest.mark.xfail(reason="sibling keywords to ref are not yet supported")
     def test_ref_applies_alongside_sibling_keywords(self, test_object, valid):
         schema = {
             "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -1559,12 +1557,10 @@ def test_naive_replacement_of_ref_with_its_destination_is_not_correct(
             # invalid on outer field
             ({"foo": {"bar": "a"}, "bar": 1}, False),
             # valid on both fields
-            pytest.param(
-                *({"foo": {"bar": "a"}, "bar": "a"}, True),
-                marks=pytest.mark.xfail(reason="refs with sibling keywords are not yet supported; foo here is being seen as an additionalProperty before bar"),
-            ),
+            ({"foo": {"bar": "a"}, "bar": "a"}, True),
         ],
     )
+    @pytest.mark.xfail(reason="refs with sibling keywords are not yet supported")
     def test_refs_with_relative_uris_and_defs(self, test_object, valid):
         schema = {
             "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -1594,12 +1590,10 @@ def test_refs_with_relative_uris_and_defs(self, test_object, valid):
             # invalid on outer field
             ({"foo": {"bar": "a"}, "bar": 1}, False),
             # valid on both fields
-            pytest.param(
-                *({"foo": {"bar": "a"}, "bar": "a"}, True),
-                marks=pytest.mark.xfail(reason="refs with sibling keywords are not yet supported; foo here is being seen as an additionalProperty before bar"),
-            ),
+            ({"foo": {"bar": "a"}, "bar": "a"}, True),
         ],
     )
+    @pytest.mark.xfail(reason="refs with sibling keywords are not yet supported")
     def test_relative_refs_with_absolute_uris_and_defs(self, test_object, valid):
         schema = {
             "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -2354,6 +2348,60 @@ def test_bad_prefix_enum(self, bad_obj, good_bytes, failure_byte, allowed_bytes)
             schema_obj=schema_obj,
         )
 
+    @pytest.mark.parametrize(
+        "obj, valid",
+        [
+            (1, True),
+            (2, False),
+            ("2", False),
+            ("1", False),
+            (True, False),
+        ]
+    )
+    def test_typed_enum_single_type(self, obj, valid):
+        schema_obj = {
+            "enum": [1, "2", True],
+            "type": "integer"
+        }
+        if valid:
+            validate(instance=obj, schema=schema_obj)
+            generate_and_check(obj, schema_obj)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=obj, schema=schema_obj)
+            check_match_failure(bad_string=json_dumps(obj), schema_obj=schema_obj)
+
+    @pytest.mark.parametrize(
+        "obj, valid",
+        [
+            (1, True),
+            (2, False),
+            ("2", True),
+            ("1", False),
+            (True, False),
+        ]
+    )
+    def test_typed_enum_multiple_types(self, obj, valid):
+        schema_obj = {
+            "enum": [1, "2", True],
+            "type": ["integer", "string"]
+        }
+        if valid:
+            validate(instance=obj, schema=schema_obj)
+            generate_and_check(obj, schema_obj)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=obj, schema=schema_obj)
+            check_match_failure(bad_string=json_dumps(obj), schema_obj=schema_obj)
+
+    def test_invalid_typed_enum(self):
+        schema_obj = {
+            "enum": [1, "2"],
+            "type": "boolean"
+        }
+        with pytest.raises(ValueError) as ve:
+            gen_json(schema=schema_obj)
+        assert ve.value.args[0] == "No valid options found for enum with type 'boolean': [1, '2']"
 
 class TestConst:
     def test_constant_int(self):
@@ -2413,6 +2461,67 @@ def test_constant_precedence(self):
             schema_obj=schema_obj,
         )
 
+    def test_valid_typed_const(self):
+        schema_obj = {
+            "const": 1,
+            "type": "integer"
+        }
+        target_obj = 1
+        validate(instance=target_obj, schema=schema_obj)
+        generate_and_check(target_obj, schema_obj)
+
+    def test_invalid_typed_const(self):
+        schema_obj = {
+            "const": 1,
+            "type": "boolean"
+        }
+        with pytest.raises(ValidationError):
+            gen_json(schema=schema_obj)
+
+    def test_valid_enum_const(self):
+        schema_obj = {
+            "const": 1,
+            "enum": [1, 2, 3]
+        }
+        target_obj = 1
+        validate(instance=target_obj, schema=schema_obj)
+        generate_and_check(target_obj, schema_obj)
+
+    def test_invalid_enum_const(self):
+        schema_obj = {
+            "const": 1,
+            "enum": [2, 3]
+        }
+        with pytest.raises(ValidationError):
+            gen_json(schema=schema_obj)
+
+    def test_valid_typed_enum_const(self):
+        schema_obj = {
+            "const": 1,
+            "enum": [1, "2", 3],
+            "type": "integer"
+        }
+        target_obj = 1
+        validate(instance=target_obj, schema=schema_obj)
+        generate_and_check(target_obj, schema_obj)
+
+    @pytest.mark.parametrize(
+        "const",
+        [
+            "2", # right enum, wrong type
+            2, # wrong enum, right type
+            "3", # wrong enum, wrong type
+        ]
+    )
+    def test_invalid_typed_enum_const(self, const):
+        schema_obj = {
+            "const": const,
+            "enum": [1, "2", 3],
+            "type": "integer"
+        }
+        with pytest.raises(ValidationError):
+            gen_json(schema=schema_obj)
+
 
 class TestAdditionalProperties:
 

From c8c6a1192dcd2435615250e642b0e3a15ad68622 Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Tue, 29 Oct 2024 14:16:44 -0700
Subject: [PATCH 05/30] [Feature] Allow json-loads-able strings to be passed as
 schema (#1028)

JSON-load any passed schema string
---
 guidance/library/_json.py       |  8 ++++++--
 tests/unit/library/test_json.py | 27 ++++++++++++++++++++++-----
 2 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/guidance/library/_json.py b/guidance/library/_json.py
index 93e0247e9..0ca544726 100644
--- a/guidance/library/_json.py
+++ b/guidance/library/_json.py
@@ -1,4 +1,4 @@
-from json import dumps as json_dumps
+from json import dumps as json_dumps, loads as json_loads
 from enum import Enum
 import math
 from typing import (
@@ -957,6 +957,7 @@ def json(
     *,
     schema: Union[
         None,
+        str,
         JSONSchema,
         Type["pydantic.BaseModel"],
         "pydantic.TypeAdapter",
@@ -1005,6 +1006,7 @@ def json(
     schema : Union[None, Mapping[str, Any], Type[pydantic.BaseModel], pydantic.TypeAdapter]
         One of:
             - None, in which case any valid JSON will be generated
+            - A string representing a JSON schema which will be parsed using ``json.loads()``
             - A JSON schema object. This is a JSON schema string which has been passed to ``json.loads()``
             - A subclass of ``pydantic.BaseModel``
             - An instance of ``pydantic.TypeAdapter``
@@ -1018,7 +1020,9 @@ def json(
         # Default schema is empty, "anything goes" schema
         # TODO: consider default being `{"type": "object"}`
         schema = {}
-    elif isinstance(schema, (Mapping, bool)):
+    elif isinstance(schema, (Mapping, bool, str)):
+        if isinstance(schema, str):
+            schema = cast(JSONSchema, json_loads(schema))
         # Raises jsonschema.exceptions.SchemaError or ValueError
         # if schema is not valid
         jsonschema.validators.Draft202012Validator.check_schema(schema)
diff --git a/tests/unit/library/test_json.py b/tests/unit/library/test_json.py
index 2deea6eda..d320fdb4f 100644
--- a/tests/unit/library/test_json.py
+++ b/tests/unit/library/test_json.py
@@ -1,15 +1,15 @@
 import json
 from functools import partial
-from typing import Any, Dict, Set, Union, Optional
+from typing import Any, Set, Union, Optional
 
 import pytest
 from jsonschema import validate, ValidationError
-from json import dumps as json_dumps
+from json import dumps as json_dumps, loads as json_loads
 
 from guidance import json as gen_json
 from guidance import models
 
-from guidance.library._json import IGNORED_KEYS
+from guidance.library._json import IGNORED_KEYS, JSONSchema
 
 from ...utils import check_match_failure as _check_match_failure
 from ...utils import check_run_with_temperature
@@ -17,8 +17,11 @@
 
 
 def generate_and_check(
-    target_obj: Any, schema_obj, desired_temperature: Optional[float] = None
+    target_obj: Any, schema_obj: Union[str, JSONSchema], desired_temperature: Optional[float] = None
 ):
+    if isinstance(schema_obj, str):
+        schema_obj = json_loads(schema_obj)
+
     # Sanity check what we're being asked
     validate(instance=target_obj, schema=schema_obj)
     prepared_json = json_dumps(target_obj)
@@ -46,7 +49,7 @@ def check_match_failure(
     good_bytes: Optional[bytes] = None,
     failure_byte: Optional[bytes] = None,
     allowed_bytes: Optional[Set[bytes]] = None,
-    schema_obj: Dict[str, Any],
+    schema_obj: Union[str, JSONSchema],
 ):
     grammar = gen_json(schema=schema_obj)
 
@@ -3270,3 +3273,17 @@ def test_whitespace_flexibility(self, indent, separators, schema, obj):
         assert grammar.match(prepared_json, raise_exceptions=True) is not None
         model = models.Mock(f"<s>{prepared_json}".encode())
         assert str(model + grammar) == prepared_json
+
+
+class TestStringSchema:
+    def test_good(self):
+        schema = """{"type": "object", "properties": {"a": {"type": "string"}}}"""
+        target_obj = {"a": "hello"}
+        generate_and_check(target_obj, schema)
+
+    def test_bad(self):
+        schema = """{"type": "object", "properties": {"a": {"type": "string"}}}"""
+        check_match_failure(
+            bad_string='{"a": 42}',
+            schema_obj=schema,
+        )

From b4b004700660801999508950d13fdb35362e7a66 Mon Sep 17 00:00:00 2001
From: S Jenkins <69673492+nopdive@users.noreply.github.com>
Date: Wed, 30 Oct 2024 09:41:29 -0700
Subject: [PATCH 06/30] [Hotfix] Echo forced to false on terminal detection.
 (#1067)

Model class now detects if executing within a terminal (as opposed to a
notebook). Echo will be forced to false for terminal usage, until
interactivity overhaul is merged. Environment class has been ported from
overhaul PR.
---
 guidance/models/_model.py       |  11 ++-
 guidance/visual/__init__.py     |   6 ++
 guidance/visual/_environment.py | 136 ++++++++++++++++++++++++++++++++
 3 files changed, 152 insertions(+), 1 deletion(-)
 create mode 100644 guidance/visual/__init__.py
 create mode 100644 guidance/visual/_environment.py

diff --git a/guidance/models/_model.py b/guidance/models/_model.py
index 74f3c8af0..e4e08d0ff 100644
--- a/guidance/models/_model.py
+++ b/guidance/models/_model.py
@@ -15,6 +15,8 @@
 
 import numpy as np
 
+from ..visual import Environment
+
 try:
     from IPython.display import clear_output, display, HTML
 
@@ -226,7 +228,14 @@ def __init__(self, engine, echo=True, **kwargs):
 
         self.engine = engine
         self.chat_template = engine.get_chat_template() # TODO [HN]: Should this be a method or attr?
-        self.echo = echo
+
+        # HOTFIX(nopdive): Temporary until visualization overhaul is merged.
+        environment = Environment()
+        if environment.is_terminal():
+            self.echo = False
+        else:
+            self.echo = echo
+
         self.token_count = 0  # tracks how many tokens our byte state represents
         self.max_display_rate = 0.2  # this controls how frequently we are allowed to redraw the display (in seconds)
         self.opened_blocks = {}  # what context blocks have been opened but not closed
diff --git a/guidance/visual/__init__.py b/guidance/visual/__init__.py
new file mode 100644
index 000000000..a286a2509
--- /dev/null
+++ b/guidance/visual/__init__.py
@@ -0,0 +1,6 @@
+"""UI and other visual UX considerations.
+
+Users should have few reasons to be accessing this module.
+"""
+
+from ._environment import Environment
\ No newline at end of file
diff --git a/guidance/visual/_environment.py b/guidance/visual/_environment.py
new file mode 100644
index 000000000..ce35a70af
--- /dev/null
+++ b/guidance/visual/_environment.py
@@ -0,0 +1,136 @@
+""" Rendering environment detection.
+
+Detection logic is inspired from both plotly and interpretml environment detection.
+- https://github.com/plotly/plotly.py
+- https://github.com/interpretml/interpret
+"""
+# TODO(nopdive): Major cloud providers implemented and manually verified.
+
+import os
+from pydantic import BaseModel
+
+
+class EnvFlags(BaseModel):
+    """Environment flags - such as if we're in a notebook or cloud."""
+
+    is_notebook: bool = False
+    is_cloud: bool = False
+
+
+class Environment:
+    """ Capabilities based environment detection."""
+
+    def __init__(self):
+        """ Initializes.
+
+        This will immediately check for which environments are detected.
+        """
+        self._flags = EnvFlags()
+        self._checks = {
+            "vscode": _detect_vscode,
+            "ipython-zmq": _detect_ipython_zmq,
+            "ipython": _detect_ipython,
+        }
+        envs = []
+        for name, update_flags in self._checks.items():
+            if update_flags(self._flags):  # in-place operation on flags
+                envs.append(name)
+        self._detected_envs = envs
+
+
+    @property
+    def detected_envs(self) -> list[str]:
+        """ Detected environments (i.e. vscode, ipython-zmq).
+
+        Returns:
+            Detected environment names.
+        """
+        return self._detected_envs
+
+
+    def is_notebook(self) -> bool:
+        """ Determines if the python process is in a notebook.
+
+        Returns:
+            True if in notebook.
+        """
+        return self._flags.is_notebook
+
+    def is_cloud(self) -> bool:
+        """ Determines if the python process is in a cloud provider.
+
+        Returns:
+            True if in notebook.
+        """
+        return self._flags.is_cloud
+
+    def is_terminal(self) -> bool:
+        """ Determines if the python process not in a notebook (we assume terminal).
+
+        Returns:
+            True if in terminal.
+        """
+        return not self._flags.is_notebook
+
+
+def _detect_vscode(flags: EnvFlags) -> bool:
+    """Detects if called in a vscode process.
+
+    Args:
+        flags: Inplace flags to be set.
+
+    Returns:
+        True if in vscode environment.
+    """
+    # NOTE: We don't flag is_notebook since this will be picked up by ipython-zmq here.
+    found = "VSCODE_PID" in os.environ
+    return found
+
+
+def _detect_ipython(flags: EnvFlags) -> bool:
+    """Detects if called in an IPython environment.
+    Mostly derived from stackoverflow below:
+    https://stackoverflow.com/questions/15411967/how-can-i-check-if-code-is-executed-in-the-ipython-notebook
+
+    Args:
+        flags: Inplace flags to be set.
+
+    Returns:
+        True if in IPython environment.
+    """
+    found = False
+    try:
+        from IPython import get_ipython
+        found = get_ipython() is not None
+    except NameError:  # pragma: no cover
+        pass
+    return found
+
+
+def _detect_ipython_zmq(flags: EnvFlags) -> bool:
+    """Detects if in an IPython environment using ZMQ (i.e. notebook/qtconsole/lab).
+
+    Mostly derived from stackoverflow below:
+    https://stackoverflow.com/questions/15411967/how-can-i-check-if-code-is-executed-in-the-ipython-notebook/24937408
+
+    Args:
+        flags: Inplace flags to be set.
+
+    Returns:
+        True if called in IPython notebook or qtconsole.
+    """
+    try:
+        from IPython import get_ipython
+
+        shell = get_ipython().__class__.__name__
+        if shell == "ZMQInteractiveShell":
+            found = True  # Jupyter notebook or qtconsole
+        elif shell == "TerminalInteractiveShell":
+            found = False  # Terminal running IPython
+        else:
+            found = False  # Other type (?)
+    except NameError:  # pragma: no cover
+        found = False  # Probably standard Python interpreter
+
+    flags.is_notebook |= found
+    return found
\ No newline at end of file

From 11892c29cd4387fa7172724df649108c0cabe096 Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Tue, 5 Nov 2024 10:32:23 -0800
Subject: [PATCH 07/30] [Keeping House] Split JSON tests into multiple files
 (#1072)

Split the JSON tests into multiple files and ran black.
---
 tests/unit/library/json/__init__.py           |    0
 tests/unit/library/{ => json}/test_json.py    | 1613 +++--------------
 tests/unit/library/json/test_refs.py          |  981 ++++++++++
 .../test_string_format.py}                    |  140 +-
 tests/unit/library/json/utils.py              |   60 +
 5 files changed, 1435 insertions(+), 1359 deletions(-)
 create mode 100644 tests/unit/library/json/__init__.py
 rename tests/unit/library/{ => json}/test_json.py (62%)
 create mode 100644 tests/unit/library/json/test_refs.py
 rename tests/unit/library/{test_json_stringformat.py => json/test_string_format.py} (88%)
 create mode 100644 tests/unit/library/json/utils.py

diff --git a/tests/unit/library/json/__init__.py b/tests/unit/library/json/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/unit/library/test_json.py b/tests/unit/library/json/test_json.py
similarity index 62%
rename from tests/unit/library/test_json.py
rename to tests/unit/library/json/test_json.py
index d320fdb4f..47adc45f9 100644
--- a/tests/unit/library/test_json.py
+++ b/tests/unit/library/json/test_json.py
@@ -1,72 +1,21 @@
 import json
-from functools import partial
-from typing import Any, Set, Union, Optional
+from json import dumps as json_dumps
 
 import pytest
-from jsonschema import validate, ValidationError
-from json import dumps as json_dumps, loads as json_loads
+from jsonschema import ValidationError, validate
 
 from guidance import json as gen_json
 from guidance import models
+from guidance.library._json import IGNORED_KEYS
 
-from guidance.library._json import IGNORED_KEYS, JSONSchema
-
-from ...utils import check_match_failure as _check_match_failure
-from ...utils import check_run_with_temperature
-from ...utils import generate_and_check as _generate_and_check
-
-
-def generate_and_check(
-    target_obj: Any, schema_obj: Union[str, JSONSchema], desired_temperature: Optional[float] = None
-):
-    if isinstance(schema_obj, str):
-        schema_obj = json_loads(schema_obj)
-
-    # Sanity check what we're being asked
-    validate(instance=target_obj, schema=schema_obj)
-    prepared_json = json_dumps(target_obj)
-    assert json.loads(prepared_json) == target_obj
-
-    # Now test that the grammar can recognize and generate prepared_json
-    # We partial in the grammar_callable
-    if desired_temperature is not None:
-        grammar_callable = partial(
-            gen_json, schema=schema_obj, temperature=desired_temperature
-        )
-    else:
-        grammar_callable = partial(gen_json, schema=schema_obj)
-
-    lm = _generate_and_check(
-        grammar_callable,
-        test_string=prepared_json,
-    )
-    check_run_with_temperature(lm, desired_temperature)
-
-
-def check_match_failure(
-    *,
-    bad_string: str,
-    good_bytes: Optional[bytes] = None,
-    failure_byte: Optional[bytes] = None,
-    allowed_bytes: Optional[Set[bytes]] = None,
-    schema_obj: Union[str, JSONSchema],
-):
-    grammar = gen_json(schema=schema_obj)
-
-    _check_match_failure(
-        bad_string=bad_string,
-        good_bytes=good_bytes,
-        failure_byte=failure_byte,
-        allowed_bytes=allowed_bytes,
-        grammar=grammar,
-    )
-
+from .utils import check_match_failure, generate_and_check
 
 # Common sets of allowed_bytes
 INTEGER_LEADING = {b"-", b"0", *{bytes([i]) for i in range(ord("1"), ord("9") + 1)}}
 INTEGER_FOLLOWING = {bytes([i]) for i in range(ord("0"), ord("9") + 1)}
 A_to_Z = {bytes([i]) for i in range(ord("A"), ord("Z") + 1)}
 
+
 def test_null():
     schema = """{"type": "null" }"""
 
@@ -181,6 +130,7 @@ def test_bad_number(self, bad_string, good_bytes, failure_byte, allowed_bytes):
             schema_obj=schema_obj,
         )
 
+
 class TestBoundedNumeric:
     @pytest.mark.parametrize(
         "instance, schema, should_pass",
@@ -190,11 +140,15 @@ class TestBoundedNumeric:
             (-5, {"type": "integer", "minimum": -5}, True),
             pytest.param(
                 *(5.0, {"type": "integer", "minimum": 5}, True),
-                marks=pytest.mark.xfail(reason="JSON technically allows trailing zeroes, but we currently don't")
+                marks=pytest.mark.xfail(
+                    reason="JSON technically allows trailing zeroes, but we currently don't"
+                ),
             ),
             pytest.param(
                 *(-5.0, {"type": "integer", "minimum": -5}, True),
-                marks=pytest.mark.xfail(reason="JSON technically allows trailing zeroes, but we currently don't")
+                marks=pytest.mark.xfail(
+                    reason="JSON technically allows trailing zeroes, but we currently don't"
+                ),
             ),
             (5.1, {"type": "integer", "minimum": 5}, False),
             (-5.1, {"type": "integer", "minimum": -5}, False),
@@ -254,7 +208,11 @@ class TestBoundedNumeric:
             (5.1, {"type": "number", "exclusiveMinimum": 5.0, "exclusiveMaximum": 10.0}, True),
             (-9.9, {"type": "number", "exclusiveMinimum": -10.0, "exclusiveMaximum": -5.0}, True),
             (5.0, {"type": "number", "exclusiveMinimum": 5.0, "exclusiveMaximum": 10.0}, False),
-            (-10.0, {"type": "number", "exclusiveMinimum": -10.0, "exclusiveMaximum": -5.0}, False),
+            (
+                -10.0,
+                {"type": "number", "exclusiveMinimum": -10.0, "exclusiveMaximum": -5.0},
+                False,
+            ),
             (9.9, {"type": "number", "exclusiveMinimum": 5.0, "exclusiveMaximum": 10.0}, True),
             (-5.1, {"type": "number", "exclusiveMinimum": -10.0, "exclusiveMaximum": -5.0}, True),
             # --- Edge cases ---
@@ -295,10 +253,10 @@ class TestBoundedNumeric:
             (0.2999, {"type": "number", "minimum": 0.1, "maximum": 0.3}, True),
             (-0.2999, {"type": "number", "minimum": -0.3, "maximum": -0.1}, True),
             (0.0999, {"type": "number", "minimum": 0.1, "maximum": 0.3}, False),
-            (-0.0999, {"type": "number", "minimum": -.3, "maximum": -0.1}, False),
+            (-0.0999, {"type": "number", "minimum": -0.3, "maximum": -0.1}, False),
             (0.3001, {"type": "number", "minimum": 0.1, "maximum": 0.3}, False),
             (-0.3001, {"type": "number", "minimum": -0.3, "maximum": -0.1}, False),
-        ]
+        ],
     )
     def test_numeric_validation(self, instance, schema, should_pass):
         # Sanity check
@@ -308,10 +266,7 @@ def test_numeric_validation(self, instance, schema, should_pass):
         else:
             with pytest.raises(ValidationError):
                 validate(instance, schema=schema)
-            check_match_failure(
-                bad_string=json_dumps(instance),
-                schema_obj=schema
-            )
+            check_match_failure(bad_string=json_dumps(instance), schema_obj=schema)
 
 
 class TestString:
@@ -392,9 +347,7 @@ def test_regex_bad(self, bad_string: str, good_bytes, failure_byte, allowed_byte
             schema_obj=schema_obj,
         )
 
-    @pytest.mark.parametrize(
-        "string", ["aA\u001f", '"""']
-    )
+    @pytest.mark.parametrize("string", ["aA\u001f", '"""'])
     def test_regex_properly_escaped_good(self, string):
         schema_obj = {"type": "string", "pattern": r".{3}"}
         # First sanity check what we're setting up
@@ -407,13 +360,15 @@ def test_regex_properly_escaped_good(self, string):
         [
             (
                 '"\\u001f\\u001f\u001f',
-                b'"\\u001f\\u001f', # able to match the first two stringified bytes
-                '\u001f'.encode(), # fails on a literal \x1f byte
-                None # hard to write a set of allowed bytes here
+                b'"\\u001f\\u001f',  # able to match the first two stringified bytes
+                "\u001f".encode(),  # fails on a literal \x1f byte
+                None,  # hard to write a set of allowed bytes here
             ),
         ],
     )
-    def test_regex_properly_escaped_bad(self, bad_string: str, good_bytes, failure_byte, allowed_bytes):
+    def test_regex_properly_escaped_bad(
+        self, bad_string: str, good_bytes, failure_byte, allowed_bytes
+    ):
         # Note that the strings being fed in include the double quotes required
         # to make them JSON strings
         schema_obj = {"type": "string", "pattern": r".{3}"}
@@ -425,7 +380,6 @@ def test_regex_properly_escaped_bad(self, bad_string: str, good_bytes, failure_b
             schema_obj=schema_obj,
         )
 
-
     @pytest.mark.parametrize(
         "my_string", ["a", "bb", "ccc", "150", ",?", ".\t\n", "(){", "aA7", "\\9O"]
     )
@@ -724,28 +678,37 @@ def test_required_is_required(self):
         generate_and_check({"b": 1}, schema)
         generate_and_check({"a": 1, "b": "xyz"}, schema)
         check_match_failure(
-            bad_string=json_dumps(
-                {"a": 1}
-            ),
+            bad_string=json_dumps({"a": 1}),
             schema_obj=schema,
         )
 
     def test_validated_against_additionalProperties(self):
-        schema = {"type": "object", "properties": {"a": {"type": "integer"}}, "required": ["b"], "additionalProperties": {"type": "integer"}}
+        schema = {
+            "type": "object",
+            "properties": {"a": {"type": "integer"}},
+            "required": ["b"],
+            "additionalProperties": {"type": "integer"},
+        }
         generate_and_check({"b": 1}, schema)
         generate_and_check({"a": 1, "b": 42}, schema)
         check_match_failure(
-            bad_string=json_dumps(
-                {"a": 1, "b": "string"}
-            ),
+            bad_string=json_dumps({"a": 1, "b": "string"}),
             schema_obj=schema,
         )
 
     def test_false_additionalProperties_fails(self):
-        schema = {"type": "object", "properties": {"a": {"type": "integer"}}, "required": ["b", "c"], "additionalProperties": False}
+        schema = {
+            "type": "object",
+            "properties": {"a": {"type": "integer"}},
+            "required": ["b", "c"],
+            "additionalProperties": False,
+        }
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
-        assert ve.value.args[0] == "Required properties not in properties but additionalProperties is False. Missing required properties: ['b', 'c']"
+        assert (
+            ve.value.args[0]
+            == "Required properties not in properties but additionalProperties is False. Missing required properties: ['b', 'c']"
+        )
 
 
 class TestSimpleArray:
@@ -811,7 +774,6 @@ def test_object_list(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
-
     @pytest.mark.parametrize(
         ["bad_string", "good_bytes", "failure_byte", "allowed_bytes"],
         [
@@ -921,7 +883,6 @@ def test_good_with_items(self, min_items, max_items, target_obj):
         }
         generate_and_check(target_obj, schema_obj)
 
-
     @pytest.mark.parametrize(
         "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
@@ -940,1163 +901,186 @@ def test_good_with_items(self, min_items, max_items, target_obj):
                 b"[42, true, ",
                 b"1",
                 {b'"'},
-            ),  # Last item does not match general item schema
-            (
-                3,
-                5,
-                [42, True, "valid", "extra1", "extra2", "too_many"],
-                b'[42, true, "valid", "extra1", "extra2"',
-                b",",
-                {b"]"},
-            ),  # Exceeds maxItems
-            (
-                2,
-                3,
-                [42],
-                b"[42",
-                b"]",
-                {b",", *INTEGER_FOLLOWING},
-            ),  # Not enough items
-            (
-                1,
-                1,
-                [42, True],
-                b"[42",
-                b",",
-                {b"]", *INTEGER_FOLLOWING},
-            ),  # Too many items for maxItems
-            (
-                0,
-                0,
-                [42, True, "str"],
-                b"[",
-                b"4",
-                {b"]"},
-            ),  # maxItems set to 0, but array is not empty
-            (
-                3,
-                5,
-                [42, True],
-                b"[42, true",
-                b"]",
-                {b","},
-            ),  # Array has one fewer item than required by minItems
-        ],
-    )
-    def test_bad_with_prefix_and_items(
-        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes
-    ):
-        schema_obj = {
-            "prefixItems": self.prefix_schema_obj,
-            "items": self.items_schema_obj,
-            "minItems": min_items,
-            "maxItems": max_items,
-            "type": "array",
-        }
-        bad_string = json_dumps(bad_obj)
-        check_match_failure(
-            bad_string=bad_string,
-            good_bytes=good_bytes,
-            failure_byte=failure_byte,
-            allowed_bytes=allowed_bytes,
-            schema_obj=schema_obj,
-        )
-
-
-    @pytest.mark.parametrize(
-        "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes",
-        [
-            (
-                2,
-                2,
-                [42],
-                b"[42",
-                b"]",
-                {b",", *INTEGER_FOLLOWING},
-            ),  # Array too short to meet minItems, despite matching prefixItems
-            (
-                1,
-                2,
-                [42, "not_bool"],
-                b"[42, ",
-                b'"',
-                {b"t", b"f"},
-            ),  # Second item violates prefixItems type requirement
-            (
-                0,
-                1,
-                [42, True],
-                b"[42",
-                b",",
-                {b"]", *INTEGER_FOLLOWING},
-            ),  # Array exceeds maxItems with valid prefixItems types
-            (
-                1,
-                5,
-                [42, True, "extra"],
-                b"[42, true",
-                b",",
-                {b"]"},
-            ),  # Item beyond prefixItems with no "items" schema
-            (
-                0,
-                0,
-                [42],
-                b"[",
-                b"4",
-                {b"]"},
-            ),  # maxItems set to 0, but array is not empty
-        ],
-    )
-    def test_bad_with_prefix(
-        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes
-    ):
-        schema_obj = {
-            "prefixItems": self.prefix_schema_obj,
-            "items": False,
-            "minItems": min_items,
-            "maxItems": max_items,
-            "type": "array",
-        }
-        bad_string = json_dumps(bad_obj)
-        check_match_failure(
-            bad_string=bad_string,
-            good_bytes=good_bytes,
-            failure_byte=failure_byte,
-            allowed_bytes=allowed_bytes,
-            schema_obj=schema_obj,
-        )
-
-
-    @pytest.mark.parametrize(
-        "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes",
-        [
-            (
-                1,
-                2,
-                ["hello", "world", "extra"],
-                b'["hello", "world"',
-                b",",
-                {b"]"},
-            ),  # Too many items for maxItems
-            (
-                2,
-                3,
-                ["hello"],
-                b'["hello"',
-                b"]",
-                {b","},
-            ),  # Not enough items
-            (
-                2,
-                3,
-                ["hello", 42],
-                b'["hello", ',
-                b"4",
-                {b'"'},
-            ),  # Badly typed second item
-            (
-                0,
-                0,
-                ["hello"],
-                b"[",
-                b'"',
-                {b"]"},
-            ),  # maxItems set to 0, but array is not empty
-        ],
-    )
-    def test_bad_with_items(
-        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes
-    ):
-        schema_obj = {
-            "items": self.items_schema_obj,
-            "minItems": min_items,
-            "maxItems": max_items,
-            "type": "array",
-        }
-        bad_string = json_dumps(bad_obj)
-        check_match_failure(
-            bad_string=bad_string,
-            good_bytes=good_bytes,
-            failure_byte=failure_byte,
-            allowed_bytes=allowed_bytes,
-            schema_obj=schema_obj,
-        )
-
-
-class TestRefs:
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # match
-            ({"foo": False}, True),
-            # recursive match
-            ({"foo": {"foo": False}}, True),
-            # mismatch
-            ({"bar": False}, False),
-            # recursive mismatch
-            ({"foo": {"bar": False}}, False),
-        ],
-    )
-    def test_root_pointer_ref(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "properties": {"foo": {"$ref": "#"}},
-            "additionalProperties": False,
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # match
-            ({"bar": 3}, True),
-            # mismatch
-            ({"bar": True}, False),
-        ],
-    )
-    def test_relative_pointer_ref_to_object(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "properties": {"foo": {"type": "integer"}, "bar": {"$ref": "#/properties/foo"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # match array
-            ([1, 2], True),
-            # mismatch array
-            ([1, "foo"], False),
-        ],
-    )
-    def test_relative_pointer_ref_to_array(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "prefixItems": [{"type": "integer"}, {"$ref": "#/prefixItems/0"}],
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # slash invalid
-            ({"slash": "aoeu"}, False),
-            # tilde invalid
-            ({"tilde": "aoeu"}, False),
-            # percent invalid
-            ({"percent": "aoeu"}, False),
-            # slash valid
-            ({"slash": 123}, True),
-            # tilde valid
-            ({"tilde": 123}, True),
-            # percent valid
-            ({"percent": 123}, True),
-        ],
-    )
-    def test_escaped_pointer_ref(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$defs": {
-                "tilde~field": {"type": "integer"},
-                "slash/field": {"type": "integer"},
-                "percent%field": {"type": "integer"},
-            },
-            "properties": {
-                "tilde": {"$ref": "#/$defs/tilde~0field"},
-                "slash": {"$ref": "#/$defs/slash~1field"},
-                "percent": {"$ref": "#/$defs/percent%25field"},
-            },
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # nested ref valid
-            (5, True),
-            # nested ref invalid
-            ("a", False),
-        ],
-    )
-    def test_nested_refs(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$defs": {
-                "a": {"type": "integer"},
-                "b": {"$ref": "#/$defs/a"},
-                "c": {"$ref": "#/$defs/b"},
-            },
-            "$ref": "#/$defs/c",
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # ref valid, maxItems valid
-            ({"foo": []}, True),
-            # ref valid, maxItems invalid
-            ({"foo": [1, 2, 3]}, False),
-            # ref invalid
-            ({"foo": "string"}, False),
-        ],
-    )
-    @pytest.mark.xfail(reason="sibling keywords to ref are not yet supported")
-    def test_ref_applies_alongside_sibling_keywords(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$defs": {"reffed": {"type": "array"}},
-            "properties": {"foo": {"$ref": "#/$defs/reffed", "maxItems": 2}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # remote ref valid
-            ({"minLength": 1}, True),
-            # remote ref invalid
-            ({"minLength": -1}, False),
-        ],
-    )
-    @pytest.mark.xfail(reason="Remote refs are not supported")
-    def test_remote_ref_containing_refs_itself(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$ref": "https://json-schema.org/draft/2020-12/schema",
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # property named $ref valid
-            ({"$ref": "a"}, True),
-            # property named $ref invalid
-            ({"$ref": 2}, False),
-        ],
-    )
-    def test_property_named_ref_that_is_not_a_reference(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "properties": {"$ref": {"type": "string"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # property named $ref valid
-            ({"$ref": "a"}, True),
-            # property named $ref invalid
-            ({"$ref": 2}, False),
-        ],
-    )
-    def test_property_named_ref_containing_an_actual_ref(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "properties": {"$ref": {"$ref": "#/$defs/is-string"}},
-            "$defs": {"is-string": {"type": "string"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # any value is valid
-            ("foo", True)
-        ],
-    )
-    def test_ref_to_boolean_schema_true(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$ref": "#/$defs/bool",
-            "$defs": {"bool": True},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # any value is invalid
-            ("foo", False)
-        ],
-    )
-    @pytest.mark.xfail(reason="false schema is not implemented")
-    def test_ref_to_boolean_schema_false(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$ref": "#/$defs/bool",
-            "$defs": {"bool": False},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # valid tree
-            (
-                {
-                    "meta": "root",
-                    "nodes": [
-                        {
-                            "value": 1,
-                            "subtree": {
-                                "meta": "child",
-                                "nodes": [{"value": 1.1}, {"value": 1.2}],
-                            },
-                        },
-                        {
-                            "value": 2,
-                            "subtree": {
-                                "meta": "child",
-                                "nodes": [{"value": 2.1}, {"value": 2.2}],
-                            },
-                        },
-                    ],
-                },
-                True,
-            ),
-            # invalid tree
-            (
-                {
-                    "meta": "root",
-                    "nodes": [
-                        {
-                            "value": 1,
-                            "subtree": {
-                                "meta": "child",
-                                "nodes": [{"value": "string is invalid"}, {"value": 1.2}],
-                            },
-                        },
-                        {
-                            "value": 2,
-                            "subtree": {
-                                "meta": "child",
-                                "nodes": [{"value": 2.1}, {"value": 2.2}],
-                            },
-                        },
-                    ],
-                },
-                False,
-            ),
-        ],
-    )
-    def test_Recursive_references_between_schemas(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "http://localhost:1234/draft2020-12/tree",
-            "description": "tree of nodes",
-            "type": "object",
-            "properties": {
-                "meta": {"type": "string"},
-                "nodes": {"type": "array", "items": {"$ref": "node"}},
-            },
-            "required": ["meta", "nodes"],
-            "$defs": {
-                "node": {
-                    "$id": "http://localhost:1234/draft2020-12/node",
-                    "description": "node",
-                    "type": "object",
-                    "properties": {"value": {"type": "number"}, "subtree": {"$ref": "tree"}},
-                    "required": ["value"],
-                }
-            },
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # object with numbers is valid
-            ({'foo"bar': 1}, True),
-            # object with strings is invalid
-            ({'foo"bar': "1"}, False),
-        ],
-    )
-    def test_refs_with_quote(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "properties": {'foo"bar': {"$ref": "#/$defs/foo%22bar"}},
-            "$defs": {'foo"bar': {"type": "number"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # referenced subschema doesn't see annotations from properties
-            ({"prop1": "match"}, False)
-        ],
-    )
-    @pytest.mark.xfail(reason="unevaluatedProperties is not implemented")
-    def test_ref_creates_new_scope_when_adjacent_to_keywords(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$defs": {"A": {"unevaluatedProperties": False}},
-            "properties": {"prop1": {"type": "string"}},
-            "$ref": "#/$defs/A",
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # do not evaluate the $ref inside the enum, matching any string
-            ("this is a string", False),
-            # do not evaluate the $ref inside the enum, definition exact match
-            ({"type": "string"}, False),
-            # match the enum exactly
-            ({"$ref": "#/$defs/a_string"}, True),
-        ],
-    )
-    def test_naive_replacement_of_ref_with_its_destination_is_not_correct(
-        self, test_object, valid
-    ):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$defs": {"a_string": {"type": "string"}},
-            "enum": [{"$ref": "#/$defs/a_string"}],
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # invalid on inner field
-            ({"foo": {"bar": 1}, "bar": "a"}, False),
-            # invalid on outer field
-            ({"foo": {"bar": "a"}, "bar": 1}, False),
-            # valid on both fields
-            ({"foo": {"bar": "a"}, "bar": "a"}, True),
-        ],
-    )
-    @pytest.mark.xfail(reason="refs with sibling keywords are not yet supported")
-    def test_refs_with_relative_uris_and_defs(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "http://example.com/schema-relative-uri-defs1.json",
-            "properties": {
-                "foo": {
-                    "$id": "schema-relative-uri-defs2.json",
-                    "$defs": {"inner": {"properties": {"bar": {"type": "string"}}}},
-                    "$ref": "#/$defs/inner",
-                }
-            },
-            "$ref": "schema-relative-uri-defs2.json",
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # invalid on inner field
-            ({"foo": {"bar": 1}, "bar": "a"}, False),
-            # invalid on outer field
-            ({"foo": {"bar": "a"}, "bar": 1}, False),
-            # valid on both fields
-            ({"foo": {"bar": "a"}, "bar": "a"}, True),
-        ],
-    )
-    @pytest.mark.xfail(reason="refs with sibling keywords are not yet supported")
-    def test_relative_refs_with_absolute_uris_and_defs(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "http://example.com/schema-refs-absolute-uris-defs1.json",
-            "properties": {
-                "foo": {
-                    "$id": "http://example.com/schema-refs-absolute-uris-defs2.json",
-                    "$defs": {"inner": {"properties": {"bar": {"type": "string"}}}},
-                    "$ref": "#/$defs/inner",
-                }
-            },
-            "$ref": "schema-refs-absolute-uris-defs2.json",
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # number is valid
-            (1, True),
-            # non-number is invalid
-            ("a", False),
-        ],
-    )
-    def test_id_must_be_resolved_against_nearest_parent_not_just_immediate_parent(
-        self, test_object, valid
-    ):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "http://example.com/a.json",
-            "$defs": {
-                "x": {
-                    "$id": "http://example.com/b/c.json",
-                    "not": {"$defs": {"y": {"$id": "d.json", "type": "number"}}},
-                }
-            },
-            "allOf": [{"$ref": "http://example.com/b/d.json"}],
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # data is valid against first definition
-            (5, True),
-            # data is invalid against first definition
-            (50, False),
-        ],
-    )
-    def test_order_of_evaluation_id_and_ref(self, test_object, valid):
-        schema = {
-            "$comment": "$id must be evaluated before $ref to get the proper $ref destination",
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "https://example.com/draft2020-12/ref-and-id1/base.json",
-            "$ref": "int.json",
-            "$defs": {
-                "bigint": {
-                    "$comment": "canonical uri: https://example.com/ref-and-id1/int.json",
-                    "$id": "int.json",
-                    "maximum": 10,
-                },
-                "smallint": {
-                    "$comment": "canonical uri: https://example.com/ref-and-id1-int.json",
-                    "$id": "/draft2020-12/ref-and-id1-int.json",
-                    "maximum": 2,
-                },
-            },
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # data is valid against first definition
-            (5, True),
-            # data is invalid against first definition
-            (50, False),
-        ],
-    )
-    def test_order_of_evaluation_id_and_anchor_and_ref(self, test_object, valid):
-        schema = {
-            "$comment": "$id must be evaluated before $ref to get the proper $ref destination",
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "https://example.com/draft2020-12/ref-and-id2/base.json",
-            "$ref": "#bigint",
-            "$defs": {
-                "bigint": {
-                    "$comment": "canonical uri: /ref-and-id2/base.json#/$defs/bigint; another valid uri for this location: /ref-and-id2/base.json#bigint",
-                    "$anchor": "bigint",
-                    "maximum": 10,
-                },
-                "smallint": {
-                    "$comment": "canonical uri: https://example.com/ref-and-id2#/$defs/smallint; another valid uri for this location: https://example.com/ref-and-id2/#bigint",
-                    "$id": "https://example.com/draft2020-12/ref-and-id2/",
-                    "$anchor": "bigint",
-                    "maximum": 2,
-                },
-            },
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # valid under the URN IDed schema
-            ({"foo": 37}, True),
-            # invalid under the URN IDed schema
-            ({"foo": 12}, False),
-        ],
-    )
-    def test_simple_URN_base_URI_with_ref_via_the_URN(self, test_object, valid):
-        schema = {
-            "$comment": "URIs do not have to have HTTP(s) schemes",
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "urn:uuid:deadbeef-1234-ffff-ffff-4321feebdaed",
-            "minimum": 30,
-            "properties": {"foo": {"$ref": "urn:uuid:deadbeef-1234-ffff-ffff-4321feebdaed"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a string is valid
-            ({"foo": "bar"}, True),
-            # a non-string is invalid
-            ({"foo": 12}, False),
-        ],
-    )
-    def test_simple_URN_base_URI_with_JSON_pointer(self, test_object, valid):
-        schema = {
-            "$comment": "URIs do not have to have HTTP(s) schemes",
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "urn:uuid:deadbeef-1234-00ff-ff00-4321feebdaed",
-            "properties": {"foo": {"$ref": "#/$defs/bar"}},
-            "$defs": {"bar": {"type": "string"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a string is valid
-            ({"foo": "bar"}, True),
-            # a non-string is invalid
-            ({"foo": 12}, False),
-        ],
-    )
-    def test_URN_base_URI_with_NSS(self, test_object, valid):
-        schema = {
-            "$comment": "RFC 8141 §2.2",
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "urn:example:1/406/47452/2",
-            "properties": {"foo": {"$ref": "#/$defs/bar"}},
-            "$defs": {"bar": {"type": "string"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a string is valid
-            ({"foo": "bar"}, True),
-            # a non-string is invalid
-            ({"foo": 12}, False),
-        ],
-    )
-    def test_URN_base_URI_with_r_component(self, test_object, valid):
-        schema = {
-            "$comment": "RFC 8141 §2.3.1",
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "urn:example:foo-bar-baz-qux?+CCResolve:cc=uk",
-            "properties": {"foo": {"$ref": "#/$defs/bar"}},
-            "$defs": {"bar": {"type": "string"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a string is valid
-            ({"foo": "bar"}, True),
-            # a non-string is invalid
-            ({"foo": 12}, False),
-        ],
-    )
-    def test_URN_base_URI_with_q_component(self, test_object, valid):
-        schema = {
-            "$comment": "RFC 8141 §2.3.2",
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "urn:example:weather?=op=map&lat=39.56&lon=-104.85&datetime=1969-07-21T02:56:15Z",
-            "properties": {"foo": {"$ref": "#/$defs/bar"}},
-            "$defs": {"bar": {"type": "string"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a string is valid
-            ({"foo": "bar"}, True),
-            # a non-string is invalid
-            ({"foo": 12}, False),
-        ],
-    )
-    def test_URN_base_URI_with_URN_and_JSON_pointer_ref(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "urn:uuid:deadbeef-1234-0000-0000-4321feebdaed",
-            "properties": {
-                "foo": {"$ref": "urn:uuid:deadbeef-1234-0000-0000-4321feebdaed#/$defs/bar"}
-            },
-            "$defs": {"bar": {"type": "string"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a string is valid
-            ({"foo": "bar"}, True),
-            # a non-string is invalid
-            ({"foo": 12}, False),
-        ],
-    )
-    def test_URN_base_URI_with_URN_and_anchor_ref(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "urn:uuid:deadbeef-1234-ff00-00ff-4321feebdaed",
-            "properties": {
-                "foo": {"$ref": "urn:uuid:deadbeef-1234-ff00-00ff-4321feebdaed#something"}
-            },
-            "$defs": {"bar": {"$anchor": "something", "type": "string"}},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a string is valid
-            ("bar", True),
-            # a non-string is invalid
-            (12, False),
-        ],
-    )
-    def test_URN_ref_with_nested_pointer_ref(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$ref": "urn:uuid:deadbeef-4321-ffff-ffff-1234feebdaed",
-            "$defs": {
-                "foo": {
-                    "$id": "urn:uuid:deadbeef-4321-ffff-ffff-1234feebdaed",
-                    "$defs": {"bar": {"type": "string"}},
-                    "$ref": "#/$defs/bar",
-                }
-            },
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a non-integer is invalid due to the $ref
-            ("foo", False),
-            # an integer is valid
-            (12, True),
-        ],
-    )
-    @pytest.mark.xfail(reason="if not implemented")
-    def test_ref_to_if(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$ref": "http://example.com/ref/if",
-            "if": {"$id": "http://example.com/ref/if", "type": "integer"},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a non-integer is invalid due to the $ref
-            ("foo", False),
-            # an integer is valid
-            (12, True),
-        ],
-    )
-    @pytest.mark.xfail(reason="then not implemented")
-    def test_ref_to_then(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$ref": "http://example.com/ref/then",
-            "then": {"$id": "http://example.com/ref/then", "type": "integer"},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a non-integer is invalid due to the $ref
-            ("foo", False),
-            # an integer is valid
-            (12, True),
-        ],
-    )
-    @pytest.mark.xfail(reason="else not implemented")
-    def test_ref_to_else(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$ref": "http://example.com/ref/else",
-            "else": {"$id": "http://example.com/ref/else", "type": "integer"},
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # a string is valid
-            ("foo", True),
-            # an integer is invalid
-            (12, False),
-        ],
-    )
-    def test_ref_with_absolute_path_reference(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "http://example.com/ref/absref.json",
-            "$defs": {
-                "a": {"$id": "http://example.com/ref/absref/foobar.json", "type": "number"},
-                "b": {"$id": "http://example.com/absref/foobar.json", "type": "string"},
-            },
-            "$ref": "/absref/foobar.json",
-        }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
-
-    @pytest.mark.parametrize(
-        ["test_object", "valid"],
-        [
-            # number is valid
-            (1, True),
-            # non-number is invalid
-            ("a", False),
+            ),  # Last item does not match general item schema
+            (
+                3,
+                5,
+                [42, True, "valid", "extra1", "extra2", "too_many"],
+                b'[42, true, "valid", "extra1", "extra2"',
+                b",",
+                {b"]"},
+            ),  # Exceeds maxItems
+            (
+                2,
+                3,
+                [42],
+                b"[42",
+                b"]",
+                {b",", *INTEGER_FOLLOWING},
+            ),  # Not enough items
+            (
+                1,
+                1,
+                [42, True],
+                b"[42",
+                b",",
+                {b"]", *INTEGER_FOLLOWING},
+            ),  # Too many items for maxItems
+            (
+                0,
+                0,
+                [42, True, "str"],
+                b"[",
+                b"4",
+                {b"]"},
+            ),  # maxItems set to 0, but array is not empty
+            (
+                3,
+                5,
+                [42, True],
+                b"[42, true",
+                b"]",
+                {b","},
+            ),  # Array has one fewer item than required by minItems
         ],
     )
-    def test_id_with_file_URI_still_resolves_pointers___nix(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "file:///folder/file.json",
-            "$defs": {"foo": {"type": "number"}},
-            "$ref": "#/$defs/foo",
+    def test_bad_with_prefix_and_items(
+        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes
+    ):
+        schema_obj = {
+            "prefixItems": self.prefix_schema_obj,
+            "items": self.items_schema_obj,
+            "minItems": min_items,
+            "maxItems": max_items,
+            "type": "array",
         }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+        bad_string = json_dumps(bad_obj)
+        check_match_failure(
+            bad_string=bad_string,
+            good_bytes=good_bytes,
+            failure_byte=failure_byte,
+            allowed_bytes=allowed_bytes,
+            schema_obj=schema_obj,
+        )
 
     @pytest.mark.parametrize(
-        ["test_object", "valid"],
+        "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
-            # number is valid
-            (1, True),
-            # non-number is invalid
-            ("a", False),
+            (
+                2,
+                2,
+                [42],
+                b"[42",
+                b"]",
+                {b",", *INTEGER_FOLLOWING},
+            ),  # Array too short to meet minItems, despite matching prefixItems
+            (
+                1,
+                2,
+                [42, "not_bool"],
+                b"[42, ",
+                b'"',
+                {b"t", b"f"},
+            ),  # Second item violates prefixItems type requirement
+            (
+                0,
+                1,
+                [42, True],
+                b"[42",
+                b",",
+                {b"]", *INTEGER_FOLLOWING},
+            ),  # Array exceeds maxItems with valid prefixItems types
+            (
+                1,
+                5,
+                [42, True, "extra"],
+                b"[42, true",
+                b",",
+                {b"]"},
+            ),  # Item beyond prefixItems with no "items" schema
+            (
+                0,
+                0,
+                [42],
+                b"[",
+                b"4",
+                {b"]"},
+            ),  # maxItems set to 0, but array is not empty
         ],
     )
-    def test_id_with_file_URI_still_resolves_pointers___windows(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$id": "file:///c:/folder/file.json",
-            "$defs": {"foo": {"type": "number"}},
-            "$ref": "#/$defs/foo",
+    def test_bad_with_prefix(
+        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes
+    ):
+        schema_obj = {
+            "prefixItems": self.prefix_schema_obj,
+            "items": False,
+            "minItems": min_items,
+            "maxItems": max_items,
+            "type": "array",
         }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+        bad_string = json_dumps(bad_obj)
+        check_match_failure(
+            bad_string=bad_string,
+            good_bytes=good_bytes,
+            failure_byte=failure_byte,
+            allowed_bytes=allowed_bytes,
+            schema_obj=schema_obj,
+        )
 
     @pytest.mark.parametrize(
-        ["test_object", "valid"],
+        "min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
-            # number is valid
-            (1, True),
-            # non-number is invalid
-            ("a", False),
+            (
+                1,
+                2,
+                ["hello", "world", "extra"],
+                b'["hello", "world"',
+                b",",
+                {b"]"},
+            ),  # Too many items for maxItems
+            (
+                2,
+                3,
+                ["hello"],
+                b'["hello"',
+                b"]",
+                {b","},
+            ),  # Not enough items
+            (
+                2,
+                3,
+                ["hello", 42],
+                b'["hello", ',
+                b"4",
+                {b'"'},
+            ),  # Badly typed second item
+            (
+                0,
+                0,
+                ["hello"],
+                b"[",
+                b'"',
+                {b"]"},
+            ),  # maxItems set to 0, but array is not empty
         ],
     )
-    def test_empty_tokens_in_ref_json_pointer(self, test_object, valid):
-        schema = {
-            "$schema": "https://json-schema.org/draft/2020-12/schema",
-            "$defs": {"": {"$defs": {"": {"type": "number"}}}},
-            "allOf": [{"$ref": "#/$defs//$defs/"}],
+    def test_bad_with_items(
+        self, min_items, max_items, bad_obj, good_bytes, failure_byte, allowed_bytes
+    ):
+        schema_obj = {
+            "items": self.items_schema_obj,
+            "minItems": min_items,
+            "maxItems": max_items,
+            "type": "array",
         }
-        if valid:
-            validate(instance=test_object, schema=schema)
-            generate_and_check(test_object, schema)
-        else:
-            with pytest.raises(ValidationError):
-                validate(instance=test_object, schema=schema)
-            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+        bad_string = json_dumps(bad_obj)
+        check_match_failure(
+            bad_string=bad_string,
+            good_bytes=good_bytes,
+            failure_byte=failure_byte,
+            allowed_bytes=allowed_bytes,
+            schema_obj=schema_obj,
+        )
 
 
 class TestAnyOf:
@@ -2259,6 +1243,7 @@ def test_allOf_bad_schema(self):
             lm += gen_json(name=CAPTURE_KEY, schema=schema_obj)
         assert ve.value.args[0] == "Only support allOf with exactly one item"
 
+
 class TestOneOf:
     @pytest.mark.parametrize("target_obj", [123, 42])
     def test_oneOf_simple(self, target_obj):
@@ -2273,7 +1258,6 @@ def test_oneOf_simple(self, target_obj):
         # The actual check
         generate_and_check(target_obj, schema_obj)
 
-
     @pytest.mark.parametrize("target_obj", [123, True])
     def test_oneOf_compound(self, target_obj):
         schema = """{
@@ -2311,7 +1295,6 @@ def test_enum(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
-
     @pytest.mark.parametrize(
         "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
@@ -2331,7 +1314,6 @@ def test_bad_enum(self, bad_obj, good_bytes, failure_byte, allowed_bytes):
             schema_obj=schema_obj,
         )
 
-
     @pytest.mark.parametrize(
         "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
@@ -2359,13 +1341,10 @@ def test_bad_prefix_enum(self, bad_obj, good_bytes, failure_byte, allowed_bytes)
             ("2", False),
             ("1", False),
             (True, False),
-        ]
+        ],
     )
     def test_typed_enum_single_type(self, obj, valid):
-        schema_obj = {
-            "enum": [1, "2", True],
-            "type": "integer"
-        }
+        schema_obj = {"enum": [1, "2", True], "type": "integer"}
         if valid:
             validate(instance=obj, schema=schema_obj)
             generate_and_check(obj, schema_obj)
@@ -2382,13 +1361,10 @@ def test_typed_enum_single_type(self, obj, valid):
             ("2", True),
             ("1", False),
             (True, False),
-        ]
+        ],
     )
     def test_typed_enum_multiple_types(self, obj, valid):
-        schema_obj = {
-            "enum": [1, "2", True],
-            "type": ["integer", "string"]
-        }
+        schema_obj = {"enum": [1, "2", True], "type": ["integer", "string"]}
         if valid:
             validate(instance=obj, schema=schema_obj)
             generate_and_check(obj, schema_obj)
@@ -2398,14 +1374,12 @@ def test_typed_enum_multiple_types(self, obj, valid):
             check_match_failure(bad_string=json_dumps(obj), schema_obj=schema_obj)
 
     def test_invalid_typed_enum(self):
-        schema_obj = {
-            "enum": [1, "2"],
-            "type": "boolean"
-        }
+        schema_obj = {"enum": [1, "2"], "type": "boolean"}
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
         assert ve.value.args[0] == "No valid options found for enum with type 'boolean': [1, '2']"
 
+
 class TestConst:
     def test_constant_int(self):
         # First sanity check what we're setting up
@@ -2465,45 +1439,29 @@ def test_constant_precedence(self):
         )
 
     def test_valid_typed_const(self):
-        schema_obj = {
-            "const": 1,
-            "type": "integer"
-        }
+        schema_obj = {"const": 1, "type": "integer"}
         target_obj = 1
         validate(instance=target_obj, schema=schema_obj)
         generate_and_check(target_obj, schema_obj)
 
     def test_invalid_typed_const(self):
-        schema_obj = {
-            "const": 1,
-            "type": "boolean"
-        }
+        schema_obj = {"const": 1, "type": "boolean"}
         with pytest.raises(ValidationError):
             gen_json(schema=schema_obj)
 
     def test_valid_enum_const(self):
-        schema_obj = {
-            "const": 1,
-            "enum": [1, 2, 3]
-        }
+        schema_obj = {"const": 1, "enum": [1, 2, 3]}
         target_obj = 1
         validate(instance=target_obj, schema=schema_obj)
         generate_and_check(target_obj, schema_obj)
 
     def test_invalid_enum_const(self):
-        schema_obj = {
-            "const": 1,
-            "enum": [2, 3]
-        }
+        schema_obj = {"const": 1, "enum": [2, 3]}
         with pytest.raises(ValidationError):
             gen_json(schema=schema_obj)
 
     def test_valid_typed_enum_const(self):
-        schema_obj = {
-            "const": 1,
-            "enum": [1, "2", 3],
-            "type": "integer"
-        }
+        schema_obj = {"const": 1, "enum": [1, "2", 3], "type": "integer"}
         target_obj = 1
         validate(instance=target_obj, schema=schema_obj)
         generate_and_check(target_obj, schema_obj)
@@ -2511,17 +1469,13 @@ def test_valid_typed_enum_const(self):
     @pytest.mark.parametrize(
         "const",
         [
-            "2", # right enum, wrong type
-            2, # wrong enum, right type
-            "3", # wrong enum, wrong type
-        ]
+            "2",  # right enum, wrong type
+            2,  # wrong enum, right type
+            "3",  # wrong enum, wrong type
+        ],
     )
     def test_invalid_typed_enum_const(self, const):
-        schema_obj = {
-            "const": const,
-            "enum": [1, "2", 3],
-            "type": "integer"
-        }
+        schema_obj = {"const": const, "enum": [1, "2", 3], "type": "integer"}
         with pytest.raises(ValidationError):
             gen_json(schema=schema_obj)
 
@@ -2569,11 +1523,15 @@ def test_simple_additional_properties(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
-
     @pytest.mark.parametrize(
         "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
-            ({"a": "1"}, b'{"a": ', b'"', INTEGER_LEADING, ),
+            (
+                {"a": "1"},
+                b'{"a": ',
+                b'"',
+                INTEGER_LEADING,
+            ),
             (
                 {"a": 1, "b": 1.5},
                 b'{"a": 1, "b": 1',
@@ -2593,9 +1551,7 @@ def test_simple_bad_type(self, bad_obj, good_bytes, failure_byte, allowed_bytes)
             schema_obj=schema_obj,
         )
 
-    @pytest.mark.parametrize(
-        "target_obj", [{}, {"a": 1}, {"a": "2"}, {"a": 1, "b": "2"}]
-    )
+    @pytest.mark.parametrize("target_obj", [{}, {"a": 1}, {"a": "2"}, {"a": 1, "b": "2"}])
     def test_anyOf_additional_properties(self, target_obj):
         # First sanity check what we're setting up
         schema_obj = json.loads(self.anyOf_schema)
@@ -2604,7 +1560,6 @@ def test_anyOf_additional_properties(self, target_obj):
         # The actual check
         generate_and_check(target_obj, schema_obj)
 
-
     @pytest.mark.parametrize(
         "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
@@ -2646,7 +1601,6 @@ def test_properties_and_additional_properties(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
-
     @pytest.mark.parametrize(
         "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
@@ -2655,9 +1609,7 @@ def test_properties_and_additional_properties(self, target_obj, temperature):
             ({"a": 1, "b": 2}, b'{"', b"a", {b"m"}),
         ],
     )
-    def test_combined_missing_properties(
-        self, bad_obj, good_bytes, failure_byte, allowed_bytes
-    ):
+    def test_combined_missing_properties(self, bad_obj, good_bytes, failure_byte, allowed_bytes):
         schema_obj = json.loads(self.combined_schema)
         bad_string = json_dumps(bad_obj)
         check_match_failure(
@@ -2668,7 +1620,6 @@ def test_combined_missing_properties(
             schema_obj=schema_obj,
         )
 
-
     @pytest.mark.parametrize(
         "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
@@ -2797,7 +1748,6 @@ def test_empty_schema(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
-
     @pytest.mark.parametrize(
         "bad_string, good_bytes, failure_byte, allowed_bytes",
         [
@@ -2826,9 +1776,7 @@ def test_empty_schema(self, target_obj, temperature):
             ),
         ],
     )
-    def test_bad_empty_schema(
-        self, bad_string, good_bytes, failure_byte, allowed_bytes
-    ):
+    def test_bad_empty_schema(self, bad_string, good_bytes, failure_byte, allowed_bytes):
         schema_obj = json.loads(self.empty_schema)
         check_match_failure(
             bad_string=bad_string,
@@ -2844,7 +1792,12 @@ def test_bad_empty_schema(
             # Empty property
             {"type": "object", "properties": {"a": {}}, "required": ["a"]},
             # Empty reference
-            {"type": "object", "properties": {"a": {"$ref": "#/$defs/A"}}, "$defs": {"A": {}}, "required": ["a"]},
+            {
+                "type": "object",
+                "properties": {"a": {"$ref": "#/$defs/A"}},
+                "$defs": {"A": {}},
+                "required": ["a"],
+            },
         ],
     )
     @pytest.mark.parametrize(
@@ -2875,10 +1828,14 @@ def test_nested_empty_schema(self, schema_obj, target_obj, temperature):
             # Empty property
             {"type": "object", "properties": {"a": {}}, "required": ["a"]},
             # Empty reference
-            {"type": "object", "properties": {"a": {"$ref": "#/$defs/A"}}, "$defs": {"A": {}}, "required": ["a"]},
+            {
+                "type": "object",
+                "properties": {"a": {"$ref": "#/$defs/A"}},
+                "$defs": {"A": {}},
+                "required": ["a"],
+            },
         ],
     )
-
     @pytest.mark.parametrize(
         "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
@@ -2921,7 +1878,6 @@ def test_nested_empty_schema_with_props(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
-
     @pytest.mark.parametrize(
         "bad_obj, good_bytes, failure_byte, allowed_bytes",
         [
@@ -2956,7 +1912,6 @@ def test_items(self, schema_obj):
             [1, 0.4, "hello", False, None, {"a": 42}, [1, 2, 3, "four"]], schema_obj
         )
 
-
     def test_no_items(self):
         schema_obj = {"type": "array", "items": False}
         check_match_failure(
@@ -2989,7 +1944,6 @@ def test_additionalProperties(self, schema_obj):
             schema_obj,
         )
 
-
     def test_no_additionalProperties(self):
         schema_obj = {"type": "object", "additionalProperties": False}
         check_match_failure(
@@ -3000,17 +1954,17 @@ def test_no_additionalProperties(self):
             schema_obj=schema_obj,
         )
 
+
 def test_ignored_keys_allowed_as_properties():
     schema_obj = {
         "type": "object",
-        "properties": {
-            key: {"type": "string"} for key in IGNORED_KEYS
-        },
+        "properties": {key: {"type": "string"} for key in IGNORED_KEYS},
         "required": list(IGNORED_KEYS),
     }
     target_obj = {key: "value" for key in IGNORED_KEYS}
     generate_and_check(target_obj, schema_obj)
 
+
 class TestRequiredProperties:
     schema_obj = {
         "type": "object",
@@ -3019,10 +1973,19 @@ class TestRequiredProperties:
             "b": {"type": "number"},
             "c": {"type": "boolean"},
         },
-        "additionalProperties": True
+        "additionalProperties": True,
     }
     ALL_REQUIRED = ["a", "b", "c"]
-    SOME_REQUIRED_SUBSETS = [[], ["a"], ["b"], ["c"], ["a", "b"], ["a", "c"], ["b", "c"], ["a", "b", "c"]]
+    SOME_REQUIRED_SUBSETS = [
+        [],
+        ["a"],
+        ["b"],
+        ["c"],
+        ["a", "b"],
+        ["a", "c"],
+        ["b", "c"],
+        ["a", "b", "c"],
+    ]
     NONE_REQUIRED: list[str] = []
 
     @pytest.mark.parametrize(
@@ -3031,7 +1994,7 @@ class TestRequiredProperties:
             {},
             {"d": "hello"},
             {"d": 42, "e": True},
-        ]
+        ],
     )
     def test_all_required_good(self, extra_items):
         schema_obj = {**self.schema_obj, "required": self.ALL_REQUIRED}
@@ -3051,7 +2014,7 @@ def test_all_required_good(self, extra_items):
             ({"c": True}),
             # Missing all
             ({}),
-        ]
+        ],
     )
     def test_all_required_bad(self, bad_obj):
         schema_obj = {**self.schema_obj, "required": self.ALL_REQUIRED}
@@ -3066,7 +2029,7 @@ def test_all_required_bad(self, bad_obj):
             {},
             {"d": "hello"},
             {"d": 42, "e": True},
-        ]
+        ],
     )
     @pytest.mark.parametrize(
         "required",
@@ -3104,7 +2067,7 @@ def test_some_required_bad(self, required):
             {},
             {"d": "hello"},
             {"d": 42, "e": True},
-        ]
+        ],
     )
     @pytest.mark.parametrize(
         "target_obj",
@@ -3117,55 +2080,48 @@ def test_some_required_bad(self, required):
             {"a": "hello", "c": True},
             {"b": 42, "c": True},
             {"a": "hello", "b": 42, "c": True},
-        ]
+        ],
     )
     def test_none_required(self, target_obj, extra_items):
         schema_obj = {**self.schema_obj, "required": self.NONE_REQUIRED}
         generate_and_check({**target_obj, **extra_items}, schema_obj)
 
+
 class TestRequiredPropertiesScaling:
-    @pytest.mark.parametrize(
-        "num_properties",
-        [1, 2, 3, 4, 5, 10, 20, 50, 100]
-    )
+    @pytest.mark.parametrize("num_properties", [1, 2, 3, 4, 5, 10, 20, 50, 100])
     def test_many_optional_properties_doesnt_blow_up(self, num_properties):
         schema_obj = {
             "type": "object",
-            "properties": {
-                f"prop_{i}": {"type": "string"} for i in range(num_properties)
-            },
-            "required": [] # Empty should be worst-case scenario
+            "properties": {f"prop_{i}": {"type": "string"} for i in range(num_properties)},
+            "required": [],  # Empty should be worst-case scenario
         }
         from guidance.library._json import GenJson
+
         genjson = GenJson(schema=schema_obj)
         genjson._join.__wrapped__.cache_clear()
         _ = genjson.root()
         cache_info = genjson._join.__wrapped__.cache_info()
 
         # Theoretical number of cache misses under the current implementation
-        expected_misses = 2*num_properties - 1
-        MISSES_MAGIC_NUMBER = 5 # Where in the world is this coming from?
+        expected_misses = 2 * num_properties - 1
+        MISSES_MAGIC_NUMBER = 5  # Where in the world is this coming from?
         assert 0 < cache_info.misses <= expected_misses + MISSES_MAGIC_NUMBER
         # NOTE: that if the cache maxsize is hit, the number of misses will be more than expected
 
         # Theoretical number of total calls under the current implementation
-        expected_calls = num_properties*(num_properties - 1) // 2
-        CALLS_MAGIC_NUMBER = 12 # Where in the world is this coming from?
+        expected_calls = num_properties * (num_properties - 1) // 2
+        CALLS_MAGIC_NUMBER = 12  # Where in the world is this coming from?
         assert 0 < cache_info.hits + cache_info.misses <= expected_calls + CALLS_MAGIC_NUMBER
 
-    @pytest.mark.parametrize(
-        "num_properties",
-        [1, 2, 3, 4, 5, 10, 20, 50, 100]
-    )
+    @pytest.mark.parametrize("num_properties", [1, 2, 3, 4, 5, 10, 20, 50, 100])
     def test_all_required_properties_doesnt_blow_up(self, num_properties):
         schema_obj = {
             "type": "object",
-            "properties": {
-                f"prop_{i}": {"type": "string"} for i in range(num_properties)
-            },
-            "required": [f"prop_{i}" for i in range(num_properties)]
+            "properties": {f"prop_{i}": {"type": "string"} for i in range(num_properties)},
+            "required": [f"prop_{i}" for i in range(num_properties)],
         }
         from guidance.library._json import GenJson
+
         genjson = GenJson(schema=schema_obj)
         genjson._join.__wrapped__.cache_clear()
         _ = genjson.root()
@@ -3193,7 +2149,7 @@ class TestBooleanSchema:
             {"a": [1, 2, 3]},
             {"a": {"b": 1}},
             False,
-            True
+            True,
         ],
     )
     def test_true_schema(self, target_obj):
@@ -3206,13 +2162,14 @@ def test_true_schema(self, target_obj):
         [
             False,
             {"type": "object", "properties": {"a": False}, "required": ["a"]},
-        ]
+        ],
     )
     def test_false_schema(self, schema_obj):
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
         assert ve.value.args[0] == "No valid JSON can be generated from a schema of `False`"
 
+
 class TestWhitespace:
     seps = [
         (", ", ": "),
@@ -3230,7 +2187,7 @@ class TestWhitespace:
             ({"enum": [{"a": 1, "b": 2, "c": [1, 2, 3]}]}, {"a": 1, "b": 2, "c": [1, 2, 3]}),
             # Static object: const (both item and key seps)
             ({"const": {"a": 1, "b": 2, "c": [1, 2, 3]}}, {"a": 1, "b": 2, "c": [1, 2, 3]}),
-        ]
+        ],
     )
     @pytest.mark.parametrize(
         "separators",
@@ -3256,7 +2213,7 @@ def test_separators(self, separators, schema, obj):
             ({"enum": [{"a": 1, "b": 2, "c": [1, 2, 3]}]}, {"a": 1, "b": 2, "c": [1, 2, 3]}),
             # Static object: const (both item and key seps)
             ({"const": {"a": 1, "b": 2, "c": [1, 2, 3]}}, {"a": 1, "b": 2, "c": [1, 2, 3]}),
-        ]
+        ],
     )
     @pytest.mark.parametrize(
         "separators",
diff --git a/tests/unit/library/json/test_refs.py b/tests/unit/library/json/test_refs.py
new file mode 100644
index 000000000..50a2b4a92
--- /dev/null
+++ b/tests/unit/library/json/test_refs.py
@@ -0,0 +1,981 @@
+from json import dumps as json_dumps
+
+import pytest
+from jsonschema import ValidationError, validate
+
+from .utils import check_match_failure, generate_and_check
+
+
+class TestRefs:
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # match
+            ({"foo": False}, True),
+            # recursive match
+            ({"foo": {"foo": False}}, True),
+            # mismatch
+            ({"bar": False}, False),
+            # recursive mismatch
+            ({"foo": {"bar": False}}, False),
+        ],
+    )
+    def test_root_pointer_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {"foo": {"$ref": "#"}},
+            "additionalProperties": False,
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # match
+            ({"bar": 3}, True),
+            # mismatch
+            ({"bar": True}, False),
+        ],
+    )
+    def test_relative_pointer_ref_to_object(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {"foo": {"type": "integer"}, "bar": {"$ref": "#/properties/foo"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # match array
+            ([1, 2], True),
+            # mismatch array
+            ([1, "foo"], False),
+        ],
+    )
+    def test_relative_pointer_ref_to_array(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "prefixItems": [{"type": "integer"}, {"$ref": "#/prefixItems/0"}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # slash invalid
+            ({"slash": "aoeu"}, False),
+            # tilde invalid
+            ({"tilde": "aoeu"}, False),
+            # percent invalid
+            ({"percent": "aoeu"}, False),
+            # slash valid
+            ({"slash": 123}, True),
+            # tilde valid
+            ({"tilde": 123}, True),
+            # percent valid
+            ({"percent": 123}, True),
+        ],
+    )
+    def test_escaped_pointer_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {
+                "tilde~field": {"type": "integer"},
+                "slash/field": {"type": "integer"},
+                "percent%field": {"type": "integer"},
+            },
+            "properties": {
+                "tilde": {"$ref": "#/$defs/tilde~0field"},
+                "slash": {"$ref": "#/$defs/slash~1field"},
+                "percent": {"$ref": "#/$defs/percent%25field"},
+            },
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # nested ref valid
+            (5, True),
+            # nested ref invalid
+            ("a", False),
+        ],
+    )
+    def test_nested_refs(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {
+                "a": {"type": "integer"},
+                "b": {"$ref": "#/$defs/a"},
+                "c": {"$ref": "#/$defs/b"},
+            },
+            "$ref": "#/$defs/c",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # ref valid, maxItems valid
+            ({"foo": []}, True),
+            # ref valid, maxItems invalid
+            ({"foo": [1, 2, 3]}, False),
+            # ref invalid
+            ({"foo": "string"}, False),
+        ],
+    )
+    @pytest.mark.xfail(reason="sibling keywords to ref are not yet supported")
+    def test_ref_applies_alongside_sibling_keywords(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {"reffed": {"type": "array"}},
+            "properties": {"foo": {"$ref": "#/$defs/reffed", "maxItems": 2}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # remote ref valid
+            ({"minLength": 1}, True),
+            # remote ref invalid
+            ({"minLength": -1}, False),
+        ],
+    )
+    @pytest.mark.xfail(reason="Remote refs are not supported")
+    def test_remote_ref_containing_refs_itself(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "https://json-schema.org/draft/2020-12/schema",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # property named $ref valid
+            ({"$ref": "a"}, True),
+            # property named $ref invalid
+            ({"$ref": 2}, False),
+        ],
+    )
+    def test_property_named_ref_that_is_not_a_reference(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {"$ref": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # property named $ref valid
+            ({"$ref": "a"}, True),
+            # property named $ref invalid
+            ({"$ref": 2}, False),
+        ],
+    )
+    def test_property_named_ref_containing_an_actual_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {"$ref": {"$ref": "#/$defs/is-string"}},
+            "$defs": {"is-string": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # any value is valid
+            ("foo", True)
+        ],
+    )
+    def test_ref_to_boolean_schema_true(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "#/$defs/bool",
+            "$defs": {"bool": True},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # any value is invalid
+            ("foo", False)
+        ],
+    )
+    @pytest.mark.xfail(reason="false schema is not implemented")
+    def test_ref_to_boolean_schema_false(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "#/$defs/bool",
+            "$defs": {"bool": False},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # valid tree
+            (
+                {
+                    "meta": "root",
+                    "nodes": [
+                        {
+                            "value": 1,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [{"value": 1.1}, {"value": 1.2}],
+                            },
+                        },
+                        {
+                            "value": 2,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [{"value": 2.1}, {"value": 2.2}],
+                            },
+                        },
+                    ],
+                },
+                True,
+            ),
+            # invalid tree
+            (
+                {
+                    "meta": "root",
+                    "nodes": [
+                        {
+                            "value": 1,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [{"value": "string is invalid"}, {"value": 1.2}],
+                            },
+                        },
+                        {
+                            "value": 2,
+                            "subtree": {
+                                "meta": "child",
+                                "nodes": [{"value": 2.1}, {"value": 2.2}],
+                            },
+                        },
+                    ],
+                },
+                False,
+            ),
+        ],
+    )
+    def test_Recursive_references_between_schemas(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "http://localhost:1234/draft2020-12/tree",
+            "description": "tree of nodes",
+            "type": "object",
+            "properties": {
+                "meta": {"type": "string"},
+                "nodes": {"type": "array", "items": {"$ref": "node"}},
+            },
+            "required": ["meta", "nodes"],
+            "$defs": {
+                "node": {
+                    "$id": "http://localhost:1234/draft2020-12/node",
+                    "description": "node",
+                    "type": "object",
+                    "properties": {"value": {"type": "number"}, "subtree": {"$ref": "tree"}},
+                    "required": ["value"],
+                }
+            },
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # object with numbers is valid
+            ({'foo"bar': 1}, True),
+            # object with strings is invalid
+            ({'foo"bar': "1"}, False),
+        ],
+    )
+    def test_refs_with_quote(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {'foo"bar': {"$ref": "#/$defs/foo%22bar"}},
+            "$defs": {'foo"bar': {"type": "number"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # referenced subschema doesn't see annotations from properties
+            ({"prop1": "match"}, False)
+        ],
+    )
+    @pytest.mark.xfail(reason="unevaluatedProperties is not implemented")
+    def test_ref_creates_new_scope_when_adjacent_to_keywords(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {"A": {"unevaluatedProperties": False}},
+            "properties": {"prop1": {"type": "string"}},
+            "$ref": "#/$defs/A",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # do not evaluate the $ref inside the enum, matching any string
+            ("this is a string", False),
+            # do not evaluate the $ref inside the enum, definition exact match
+            ({"type": "string"}, False),
+            # match the enum exactly
+            ({"$ref": "#/$defs/a_string"}, True),
+        ],
+    )
+    def test_naive_replacement_of_ref_with_its_destination_is_not_correct(
+        self, test_object, valid
+    ):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {"a_string": {"type": "string"}},
+            "enum": [{"$ref": "#/$defs/a_string"}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # invalid on inner field
+            ({"foo": {"bar": 1}, "bar": "a"}, False),
+            # invalid on outer field
+            ({"foo": {"bar": "a"}, "bar": 1}, False),
+            # valid on both fields
+            ({"foo": {"bar": "a"}, "bar": "a"}, True),
+        ],
+    )
+    @pytest.mark.xfail(reason="refs with sibling keywords are not yet supported")
+    def test_refs_with_relative_uris_and_defs(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "http://example.com/schema-relative-uri-defs1.json",
+            "properties": {
+                "foo": {
+                    "$id": "schema-relative-uri-defs2.json",
+                    "$defs": {"inner": {"properties": {"bar": {"type": "string"}}}},
+                    "$ref": "#/$defs/inner",
+                }
+            },
+            "$ref": "schema-relative-uri-defs2.json",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # invalid on inner field
+            ({"foo": {"bar": 1}, "bar": "a"}, False),
+            # invalid on outer field
+            ({"foo": {"bar": "a"}, "bar": 1}, False),
+            # valid on both fields
+            ({"foo": {"bar": "a"}, "bar": "a"}, True),
+        ],
+    )
+    @pytest.mark.xfail(reason="refs with sibling keywords are not yet supported")
+    def test_relative_refs_with_absolute_uris_and_defs(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "http://example.com/schema-refs-absolute-uris-defs1.json",
+            "properties": {
+                "foo": {
+                    "$id": "http://example.com/schema-refs-absolute-uris-defs2.json",
+                    "$defs": {"inner": {"properties": {"bar": {"type": "string"}}}},
+                    "$ref": "#/$defs/inner",
+                }
+            },
+            "$ref": "schema-refs-absolute-uris-defs2.json",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # number is valid
+            (1, True),
+            # non-number is invalid
+            ("a", False),
+        ],
+    )
+    def test_id_must_be_resolved_against_nearest_parent_not_just_immediate_parent(
+        self, test_object, valid
+    ):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "http://example.com/a.json",
+            "$defs": {
+                "x": {
+                    "$id": "http://example.com/b/c.json",
+                    "not": {"$defs": {"y": {"$id": "d.json", "type": "number"}}},
+                }
+            },
+            "allOf": [{"$ref": "http://example.com/b/d.json"}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # data is valid against first definition
+            (5, True),
+            # data is invalid against first definition
+            (50, False),
+        ],
+    )
+    def test_order_of_evaluation_id_and_ref(self, test_object, valid):
+        schema = {
+            "$comment": "$id must be evaluated before $ref to get the proper $ref destination",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://example.com/draft2020-12/ref-and-id1/base.json",
+            "$ref": "int.json",
+            "$defs": {
+                "bigint": {
+                    "$comment": "canonical uri: https://example.com/ref-and-id1/int.json",
+                    "$id": "int.json",
+                    "maximum": 10,
+                },
+                "smallint": {
+                    "$comment": "canonical uri: https://example.com/ref-and-id1-int.json",
+                    "$id": "/draft2020-12/ref-and-id1-int.json",
+                    "maximum": 2,
+                },
+            },
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # data is valid against first definition
+            (5, True),
+            # data is invalid against first definition
+            (50, False),
+        ],
+    )
+    def test_order_of_evaluation_id_and_anchor_and_ref(self, test_object, valid):
+        schema = {
+            "$comment": "$id must be evaluated before $ref to get the proper $ref destination",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "https://example.com/draft2020-12/ref-and-id2/base.json",
+            "$ref": "#bigint",
+            "$defs": {
+                "bigint": {
+                    "$comment": "canonical uri: /ref-and-id2/base.json#/$defs/bigint; another valid uri for this location: /ref-and-id2/base.json#bigint",
+                    "$anchor": "bigint",
+                    "maximum": 10,
+                },
+                "smallint": {
+                    "$comment": "canonical uri: https://example.com/ref-and-id2#/$defs/smallint; another valid uri for this location: https://example.com/ref-and-id2/#bigint",
+                    "$id": "https://example.com/draft2020-12/ref-and-id2/",
+                    "$anchor": "bigint",
+                    "maximum": 2,
+                },
+            },
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # valid under the URN IDed schema
+            ({"foo": 37}, True),
+            # invalid under the URN IDed schema
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_simple_URN_base_URI_with_ref_via_the_URN(self, test_object, valid):
+        schema = {
+            "$comment": "URIs do not have to have HTTP(s) schemes",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:uuid:deadbeef-1234-ffff-ffff-4321feebdaed",
+            "minimum": 30,
+            "properties": {"foo": {"$ref": "urn:uuid:deadbeef-1234-ffff-ffff-4321feebdaed"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_simple_URN_base_URI_with_JSON_pointer(self, test_object, valid):
+        schema = {
+            "$comment": "URIs do not have to have HTTP(s) schemes",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:uuid:deadbeef-1234-00ff-ff00-4321feebdaed",
+            "properties": {"foo": {"$ref": "#/$defs/bar"}},
+            "$defs": {"bar": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_URN_base_URI_with_NSS(self, test_object, valid):
+        schema = {
+            "$comment": "RFC 8141 §2.2",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:example:1/406/47452/2",
+            "properties": {"foo": {"$ref": "#/$defs/bar"}},
+            "$defs": {"bar": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_URN_base_URI_with_r_component(self, test_object, valid):
+        schema = {
+            "$comment": "RFC 8141 §2.3.1",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:example:foo-bar-baz-qux?+CCResolve:cc=uk",
+            "properties": {"foo": {"$ref": "#/$defs/bar"}},
+            "$defs": {"bar": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_URN_base_URI_with_q_component(self, test_object, valid):
+        schema = {
+            "$comment": "RFC 8141 §2.3.2",
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:example:weather?=op=map&lat=39.56&lon=-104.85&datetime=1969-07-21T02:56:15Z",
+            "properties": {"foo": {"$ref": "#/$defs/bar"}},
+            "$defs": {"bar": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_URN_base_URI_with_URN_and_JSON_pointer_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:uuid:deadbeef-1234-0000-0000-4321feebdaed",
+            "properties": {
+                "foo": {"$ref": "urn:uuid:deadbeef-1234-0000-0000-4321feebdaed#/$defs/bar"}
+            },
+            "$defs": {"bar": {"type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ({"foo": "bar"}, True),
+            # a non-string is invalid
+            ({"foo": 12}, False),
+        ],
+    )
+    def test_URN_base_URI_with_URN_and_anchor_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "urn:uuid:deadbeef-1234-ff00-00ff-4321feebdaed",
+            "properties": {
+                "foo": {"$ref": "urn:uuid:deadbeef-1234-ff00-00ff-4321feebdaed#something"}
+            },
+            "$defs": {"bar": {"$anchor": "something", "type": "string"}},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ("bar", True),
+            # a non-string is invalid
+            (12, False),
+        ],
+    )
+    def test_URN_ref_with_nested_pointer_ref(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "urn:uuid:deadbeef-4321-ffff-ffff-1234feebdaed",
+            "$defs": {
+                "foo": {
+                    "$id": "urn:uuid:deadbeef-4321-ffff-ffff-1234feebdaed",
+                    "$defs": {"bar": {"type": "string"}},
+                    "$ref": "#/$defs/bar",
+                }
+            },
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a non-integer is invalid due to the $ref
+            ("foo", False),
+            # an integer is valid
+            (12, True),
+        ],
+    )
+    @pytest.mark.xfail(reason="if not implemented")
+    def test_ref_to_if(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "http://example.com/ref/if",
+            "if": {"$id": "http://example.com/ref/if", "type": "integer"},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a non-integer is invalid due to the $ref
+            ("foo", False),
+            # an integer is valid
+            (12, True),
+        ],
+    )
+    @pytest.mark.xfail(reason="then not implemented")
+    def test_ref_to_then(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "http://example.com/ref/then",
+            "then": {"$id": "http://example.com/ref/then", "type": "integer"},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a non-integer is invalid due to the $ref
+            ("foo", False),
+            # an integer is valid
+            (12, True),
+        ],
+    )
+    @pytest.mark.xfail(reason="else not implemented")
+    def test_ref_to_else(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$ref": "http://example.com/ref/else",
+            "else": {"$id": "http://example.com/ref/else", "type": "integer"},
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # a string is valid
+            ("foo", True),
+            # an integer is invalid
+            (12, False),
+        ],
+    )
+    def test_ref_with_absolute_path_reference(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "http://example.com/ref/absref.json",
+            "$defs": {
+                "a": {"$id": "http://example.com/ref/absref/foobar.json", "type": "number"},
+                "b": {"$id": "http://example.com/absref/foobar.json", "type": "string"},
+            },
+            "$ref": "/absref/foobar.json",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # number is valid
+            (1, True),
+            # non-number is invalid
+            ("a", False),
+        ],
+    )
+    def test_id_with_file_URI_still_resolves_pointers___nix(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "file:///folder/file.json",
+            "$defs": {"foo": {"type": "number"}},
+            "$ref": "#/$defs/foo",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # number is valid
+            (1, True),
+            # non-number is invalid
+            ("a", False),
+        ],
+    )
+    def test_id_with_file_URI_still_resolves_pointers___windows(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "file:///c:/folder/file.json",
+            "$defs": {"foo": {"type": "number"}},
+            "$ref": "#/$defs/foo",
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # number is valid
+            (1, True),
+            # non-number is invalid
+            ("a", False),
+        ],
+    )
+    def test_empty_tokens_in_ref_json_pointer(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$defs": {"": {"$defs": {"": {"type": "number"}}}},
+            "allOf": [{"$ref": "#/$defs//$defs/"}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
diff --git a/tests/unit/library/test_json_stringformat.py b/tests/unit/library/json/test_string_format.py
similarity index 88%
rename from tests/unit/library/test_json_stringformat.py
rename to tests/unit/library/json/test_string_format.py
index b484ccca2..7b2dd9bdc 100644
--- a/tests/unit/library/test_json_stringformat.py
+++ b/tests/unit/library/json/test_string_format.py
@@ -1,8 +1,10 @@
 """Adapted from https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/9fc880bfb6d8ccd093bc82431f17d13681ffae8e/tests/draft2020-12/optional/format"""
 
-import pytest
 import json
-from .test_json import generate_and_check, check_match_failure
+
+import pytest
+
+from .utils import check_match_failure, generate_and_check
 
 
 class TestDate:
@@ -43,17 +45,35 @@ def test_good(self, target_str):
         "bad_str",
         [
             '"2020-01-32"',  # a invalid date string with 32 days in January
-            pytest.param('"2021-02-29"', marks=pytest.mark.xfail(reason="number of days not yet tied to month")),  # a invalid date string with 29 days in February (normal)
-            pytest.param('"2020-02-30"', marks=pytest.mark.xfail(reason="number of days not yet tied to month")),  # a invalid date string with 30 days in February (leap)
+            pytest.param(
+                '"2021-02-29"',
+                marks=pytest.mark.xfail(reason="number of days not yet tied to month"),
+            ),  # a invalid date string with 29 days in February (normal)
+            pytest.param(
+                '"2020-02-30"',
+                marks=pytest.mark.xfail(reason="number of days not yet tied to month"),
+            ),  # a invalid date string with 30 days in February (leap)
             '"2020-03-32"',  # a invalid date string with 32 days in March
-            pytest.param('"2020-04-31"', marks=pytest.mark.xfail(reason="number of days not yet tied to month")),  # a invalid date string with 31 days in April
+            pytest.param(
+                '"2020-04-31"',
+                marks=pytest.mark.xfail(reason="number of days not yet tied to month"),
+            ),  # a invalid date string with 31 days in April
             '"2020-05-32"',  # a invalid date string with 32 days in May
-            pytest.param('"2020-06-31"', marks=pytest.mark.xfail(reason="number of days not yet tied to month")),  # a invalid date string with 31 days in June
+            pytest.param(
+                '"2020-06-31"',
+                marks=pytest.mark.xfail(reason="number of days not yet tied to month"),
+            ),  # a invalid date string with 31 days in June
             '"2020-07-32"',  # a invalid date string with 32 days in July
             '"2020-08-32"',  # a invalid date string with 32 days in August
-            pytest.param('"2020-09-31"', marks=pytest.mark.xfail(reason="number of days not yet tied to month")),  # a invalid date string with 31 days in September
+            pytest.param(
+                '"2020-09-31"',
+                marks=pytest.mark.xfail(reason="number of days not yet tied to month"),
+            ),  # a invalid date string with 31 days in September
             '"2020-10-32"',  # a invalid date string with 32 days in October
-            pytest.param('"2020-11-31"', marks=pytest.mark.xfail(reason="number of days not yet tied to month")),  # a invalid date string with 31 days in November
+            pytest.param(
+                '"2020-11-31"',
+                marks=pytest.mark.xfail(reason="number of days not yet tied to month"),
+            ),  # a invalid date string with 31 days in November
             '"2020-12-32"',  # a invalid date string with 32 days in December
             '"2020-13-01"',  # a invalid date string with invalid month
             '"06/19/1963"',  # an invalid date string
@@ -61,8 +81,13 @@ def test_good(self, target_str):
             '"1998-1-20"',  # non-padded month dates are not valid
             '"1998-01-1"',  # non-padded day dates are not valid
             '"1998-13-01"',  # invalid month
-            pytest.param('"1998-04-31"', marks=pytest.mark.xfail(reason="number of days not yet tied to month")),  # invalid month-day combination
-            pytest.param('"2021-02-29"', marks=pytest.mark.xfail(reason="leap days are hard")),  # 2021 is not a leap year
+            pytest.param(
+                '"1998-04-31"',
+                marks=pytest.mark.xfail(reason="number of days not yet tied to month"),
+            ),  # invalid month-day combination
+            pytest.param(
+                '"2021-02-29"', marks=pytest.mark.xfail(reason="leap days are hard")
+            ),  # 2021 is not a leap year
             '"1963-06-1\\u09ea"',  # invalid non-ASCII '৪' (a Bengali 4)
             '"20230328"',  # ISO8601 / non-RFC3339: YYYYMMDD without dashes (2023-03-28)
             '"2023-W01"',  # ISO8601 / non-RFC3339: week number implicit day of week (2023-01-02)
@@ -136,6 +161,7 @@ def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
         check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
+
 @pytest.mark.xfail(reason="idn-hostname format not implemented")
 class TestIdnHostname:
     schema = '{"$schema":"https://json-schema.org/draft/2020-12/schema","format":"idn-hostname"}'
@@ -299,6 +325,7 @@ def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
         check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
+
 @pytest.mark.xfail(reason="iri-reference format is not yet implemented")
 class TestIriReference:
     schema = '{"$schema":"https://json-schema.org/draft/2020-12/schema","format":"iri-reference"}'
@@ -488,20 +515,40 @@ def test_good(self, target_str):
             '"008:030:006Z"',  # invalid time string with extra leading zeros
             '"8:3:6Z"',  # invalid time string with no leading zero for single digit
             '"8:0030:6Z"',  # hour, minute, second must be two digits
-            pytest.param('"22:59:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # invalid leap second, Zulu (wrong hour)
-            pytest.param('"23:58:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # invalid leap second, Zulu (wrong minute)
-            pytest.param('"22:59:60+00:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # invalid leap second, zero time-offset (wrong hour)
-            pytest.param('"23:58:60+00:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # invalid leap second, zero time-offset (wrong minute)
-            pytest.param('"23:59:60+01:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # invalid leap second, positive time-offset (wrong hour)
-            pytest.param('"23:59:60+00:30"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # invalid leap second, positive time-offset (wrong minute)
-            pytest.param('"23:59:60-01:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # invalid leap second, negative time-offset (wrong hour)
-            pytest.param('"23:59:60-00:30"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # invalid leap second, negative time-offset (wrong minute)
+            pytest.param(
+                '"22:59:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # invalid leap second, Zulu (wrong hour)
+            pytest.param(
+                '"23:58:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # invalid leap second, Zulu (wrong minute)
+            pytest.param(
+                '"22:59:60+00:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # invalid leap second, zero time-offset (wrong hour)
+            pytest.param(
+                '"23:58:60+00:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # invalid leap second, zero time-offset (wrong minute)
+            pytest.param(
+                '"23:59:60+01:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # invalid leap second, positive time-offset (wrong hour)
+            pytest.param(
+                '"23:59:60+00:30"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # invalid leap second, positive time-offset (wrong minute)
+            pytest.param(
+                '"23:59:60-01:00"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # invalid leap second, negative time-offset (wrong hour)
+            pytest.param(
+                '"23:59:60-00:30"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # invalid leap second, negative time-offset (wrong minute)
             '"08:30:06-8:000"',  # hour, minute in time-offset must be two digits
             '"24:00:00Z"',  # an invalid time string with invalid hour
             '"00:60:00Z"',  # an invalid time string with invalid minute
             '"00:00:61Z"',  # an invalid time string with invalid second
-            pytest.param('"22:59:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # an invalid time string with invalid leap second (wrong hour)
-            pytest.param('"23:58:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # an invalid time string with invalid leap second (wrong minute)
+            pytest.param(
+                '"22:59:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # an invalid time string with invalid leap second (wrong hour)
+            pytest.param(
+                '"23:58:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # an invalid time string with invalid leap second (wrong minute)
             '"01:02:03+24:00"',  # an invalid time string with invalid time numoffset hour
             '"01:02:03+00:60"',  # an invalid time string with invalid time numoffset minute
             '"01:02:03Z+00:30"',  # an invalid time string with invalid time with both Z and numoffset
@@ -537,11 +584,23 @@ class TestIpv6:
             '"::42:ff:1"',  # leading colons is valid
             '"d6::"',  # trailing colons is valid
             '"1:d6::42"',  # single set of double colons in the middle is valid
-            pytest.param('"1::d6:192.168.0.1"', marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented")),  # mixed format with the ipv4 section as decimal octets
-            pytest.param('"1:2::192.168.0.1"', marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented")),  # mixed format with double colons between the sections
-            pytest.param('"::ffff:192.168.0.1"', marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented")),  # mixed format with leading double colons (ipv4-mapped ipv6 address)
+            pytest.param(
+                '"1::d6:192.168.0.1"',
+                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
+            ),  # mixed format with the ipv4 section as decimal octets
+            pytest.param(
+                '"1:2::192.168.0.1"',
+                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
+            ),  # mixed format with double colons between the sections
+            pytest.param(
+                '"::ffff:192.168.0.1"',
+                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
+            ),  # mixed format with leading double colons (ipv4-mapped ipv6 address)
             '"1:2:3:4:5:6:7:8"',  # 8 octets
-            pytest.param('"1000:1000:1000:1000:1000:1000:255.255.255.255"', marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented")),  # a long valid ipv6
+            pytest.param(
+                '"1000:1000:1000:1000:1000:1000:255.255.255.255"',
+                marks=pytest.mark.xfail(reason="Mixed format IPv6 not implemented"),
+            ),  # a long valid ipv6
         ],
     )
     def test_good(self, target_str):
@@ -709,11 +768,22 @@ class TestEmail:
             '"te~st@example.com"',  # tilde in local part is valid
             '"~test@example.com"',  # tilde before local part is valid
             '"test~@example.com"',  # tilde after local part is valid
-            pytest.param('"\\"joe bloggs\\"@example.com"', marks=pytest.mark.xfail(reason="Quoted strings not yet implemented in local part")),  # a quoted string with a space in the local part is valid
-            pytest.param('"\\"joe..bloggs\\"@example.com"', marks=pytest.mark.xfail(reason="Quoted strings not yet implemented in local part")),  # a quoted string with a double dot in the local part is valid
-            pytest.param('"\\"joe@bloggs\\"@example.com"', marks=pytest.mark.xfail(reason="Quoted strings not yet implemented in local part")),  # a quoted string with a @ in the local part is valid
+            pytest.param(
+                '"\\"joe bloggs\\"@example.com"',
+                marks=pytest.mark.xfail(reason="Quoted strings not yet implemented in local part"),
+            ),  # a quoted string with a space in the local part is valid
+            pytest.param(
+                '"\\"joe..bloggs\\"@example.com"',
+                marks=pytest.mark.xfail(reason="Quoted strings not yet implemented in local part"),
+            ),  # a quoted string with a double dot in the local part is valid
+            pytest.param(
+                '"\\"joe@bloggs\\"@example.com"',
+                marks=pytest.mark.xfail(reason="Quoted strings not yet implemented in local part"),
+            ),  # a quoted string with a @ in the local part is valid
             '"joe.bloggs@[127.0.0.1]"',  # an IPv4-address-literal after the @ is valid
-            pytest.param('"joe.bloggs@[IPv6:::1]"', marks=pytest.mark.xfail(reason="IPv6 is hard")),  # an IPv6-address-literal after the @ is valid
+            pytest.param(
+                '"joe.bloggs@[IPv6:::1]"', marks=pytest.mark.xfail(reason="IPv6 is hard")
+            ),  # an IPv6-address-literal after the @ is valid
             '"te.s.t@example.com"',  # two separated dots inside local part are valid
             '"riedgar+guidance@example.com"',  # plus sign in local part is valid
         ],
@@ -859,9 +929,16 @@ def test_good(self, target_str):
         "bad_str",
         [
             '"1998-12-31T23:59:61Z"',  # an invalid date-time past leap second, UTC
-            pytest.param('"1998-12-31T23:58:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # an invalid date-time with leap second on a wrong minute, UTC
-            pytest.param('"1998-12-31T22:59:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")),  # an invalid date-time with leap second on a wrong hour, UTC
-            pytest.param('"1990-02-31T15:59:59.123-08:00"', marks=pytest.mark.xfail(reason="valid days not yet tied to month")),  # an invalid day in date-time string
+            pytest.param(
+                '"1998-12-31T23:58:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # an invalid date-time with leap second on a wrong minute, UTC
+            pytest.param(
+                '"1998-12-31T22:59:60Z"', marks=pytest.mark.xfail(reason="leap seconds are hard")
+            ),  # an invalid date-time with leap second on a wrong hour, UTC
+            pytest.param(
+                '"1990-02-31T15:59:59.123-08:00"',
+                marks=pytest.mark.xfail(reason="valid days not yet tied to month"),
+            ),  # an invalid day in date-time string
             '"1990-12-31T15:59:59-24:00"',  # an invalid offset in date-time string
             '"1963-06-19T08:30:06.28123+01:00Z"',  # an invalid closing Z after time-zone offset
             '"06/19/1963 08:30:06 PST"',  # an invalid date-time string
@@ -876,6 +953,7 @@ def test_bad(self, bad_str):
         schema_obj = json.loads(self.schema)
         check_match_failure(bad_string=bad_str, schema_obj=schema_obj)
 
+
 @pytest.mark.xfail(reason="regex format not implemented")
 class TestRegex:
     schema = '{"$schema":"https://json-schema.org/draft/2020-12/schema","format":"regex"}'
diff --git a/tests/unit/library/json/utils.py b/tests/unit/library/json/utils.py
new file mode 100644
index 000000000..ffbbe3b5f
--- /dev/null
+++ b/tests/unit/library/json/utils.py
@@ -0,0 +1,60 @@
+import json
+from functools import partial
+from json import dumps as json_dumps
+from json import loads as json_loads
+from typing import Any, Optional, Set, Union
+
+from jsonschema import validate
+
+from guidance import json as gen_json
+from guidance.library._json import JSONSchema
+
+from ....utils import check_match_failure as _check_match_failure
+from ....utils import check_run_with_temperature
+from ....utils import generate_and_check as _generate_and_check
+
+
+def generate_and_check(
+    target_obj: Any,
+    schema_obj: Union[str, JSONSchema],
+    desired_temperature: Optional[float] = None,
+):
+    if isinstance(schema_obj, str):
+        schema_obj = json_loads(schema_obj)
+
+    # Sanity check what we're being asked
+    validate(instance=target_obj, schema=schema_obj)
+    prepared_json = json_dumps(target_obj)
+    assert json.loads(prepared_json) == target_obj
+
+    # Now test that the grammar can recognize and generate prepared_json
+    # We partial in the grammar_callable
+    if desired_temperature is not None:
+        grammar_callable = partial(gen_json, schema=schema_obj, temperature=desired_temperature)
+    else:
+        grammar_callable = partial(gen_json, schema=schema_obj)
+
+    lm = _generate_and_check(
+        grammar_callable,
+        test_string=prepared_json,
+    )
+    check_run_with_temperature(lm, desired_temperature)
+
+
+def check_match_failure(
+    *,
+    bad_string: str,
+    good_bytes: Optional[bytes] = None,
+    failure_byte: Optional[bytes] = None,
+    allowed_bytes: Optional[Set[bytes]] = None,
+    schema_obj: Union[str, JSONSchema],
+):
+    grammar = gen_json(schema=schema_obj)
+
+    _check_match_failure(
+        bad_string=bad_string,
+        good_bytes=good_bytes,
+        failure_byte=failure_byte,
+        allowed_bytes=allowed_bytes,
+        grammar=grammar,
+    )

From 94f9d33d51ee7cf63d93b2b3536b462fb23ad5ea Mon Sep 17 00:00:00 2001
From: Harsha-Nori <harsha.nori@live.com>
Date: Tue, 5 Nov 2024 14:58:53 -0800
Subject: [PATCH 08/30] lint this.

---
 .github/workflows/workflow-pr-gate.yml | 28 --------------------------
 1 file changed, 28 deletions(-)

diff --git a/.github/workflows/workflow-pr-gate.yml b/.github/workflows/workflow-pr-gate.yml
index a1c9eded8..3bf1ab5d0 100644
--- a/.github/workflows/workflow-pr-gate.yml
+++ b/.github/workflows/workflow-pr-gate.yml
@@ -11,32 +11,6 @@ jobs:
   # First Stage =======================================================================
   # Linting and basic CPU-based tests
 
-  linting-black:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      # https://black.readthedocs.io/en/stable/integrations/github_actions.html
-      - uses: psf/black@stable
-        with:
-          options: "--diff" # Remove this to start enforcement
-
-  linting-mypy:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Setup Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: 3.9
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install .[all,test]
-      - name: Run mypy
-        run: |
-          python -m mypy guidance
-
   bare-install:
     strategy:
       matrix:
@@ -77,8 +51,6 @@ jobs:
 
   end-stage-1:
     needs:
-      - linting-black
-      - linting-mypy
       - bare-install
       - basic-tests-linux-python-latest
     name: End Stage 1

From 0ace873bd64516422fbacee73792e1ac1e1ee436 Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Wed, 6 Nov 2024 13:25:43 -0800
Subject: [PATCH 09/30] [Feature] [JSON] Broader support of `allOf` JSON
 keyword (#1070)

Supports some `allOf`s by manually intersecting schemas. Tests are adapted from the JSON Schema test suite.
---
 guidance/library/_json.py             | 662 ++++++++++++++++++++------
 tests/unit/library/json/test_allOf.py | 497 +++++++++++++++++++
 tests/unit/library/json/test_json.py  | 222 +++++++--
 tests/unit/library/json/test_refs.py  |  11 +-
 tests/unit/library/json/utils.py      |   4 +-
 5 files changed, 1206 insertions(+), 190 deletions(-)
 create mode 100644 tests/unit/library/json/test_allOf.py

diff --git a/guidance/library/_json.py b/guidance/library/_json.py
index 0ca544726..61019e16a 100644
--- a/guidance/library/_json.py
+++ b/guidance/library/_json.py
@@ -4,7 +4,6 @@
 from typing import (
     Any,
     Callable,
-    Dict,
     Mapping,
     Optional,
     Sequence,
@@ -15,8 +14,17 @@
 )
 import warnings
 import referencing
-import contextlib
-from urllib.parse import urljoin
+from collections import defaultdict
+import urllib.parse
+import functools
+
+from .._guidance import guidance
+from ..library import optional, sequence
+from ..library._regex_utils import rx_int_range, rx_float_range
+
+from .._grammar import GrammarFunction, select, with_temperature, Not, And, quote_regex
+from ._pydantic import pydantic_to_json_schema
+from ._subgrammar import as_regular_grammar, lexeme, subgrammar
 
 try:
     import jsonschema
@@ -25,15 +33,7 @@
     if TYPE_CHECKING:
         raise
 
-from .._guidance import guidance
-from ..library import char_range, gen, one_or_more, optional, sequence
-from ..library._regex_utils import rx_int_range, rx_float_range
-
-from .._grammar import GrammarFunction, select, capture, with_temperature, Not, And, quote_regex
-from ._pydantic import pydantic_to_json_schema
-from ._subgrammar import as_regular_grammar, lexeme, subgrammar
-
-JSONSchema = Union[bool, Mapping[str, Any]]
+JSONSchema = Union[bool, dict[str, Any]]
 
 DRAFT202012_RESERVED_KEYWORDS = {
     # Anchors and References
@@ -129,6 +129,7 @@ class Keyword(str, Enum):
     ANYOF = "anyOf"
     ALLOF = "allOf" # Note: Partial support. Only supports exactly one item.
     ONEOF = "oneOf" # Note: Partial support. This is converted to anyOf.
+    ID = "$id"
     REF = "$ref"
     CONST = "const"
     ENUM = "enum"
@@ -169,7 +170,6 @@ class ObjectKeywords(str, Enum):
     "$anchor",
     "$defs",
     "$schema",
-    "$id",
     "id",
     "$comment",
     "title",
@@ -378,6 +378,14 @@ class ObjectKeywords(str, Enum):
     "unknown": r"(?s:.*)",
 }
 
+
+def urijoin(base: str, uri: str) -> str:
+    # Special case for fragment-only URIs
+    if uri.startswith("#"):
+        return f"{base}{uri}"
+    return urllib.parse.urljoin(base, uri)
+
+
 def _get_format_pattern(format: str) -> str:
     try:
         pattern = FORMAT_PATTERNS[format]
@@ -403,6 +411,19 @@ def get_sibling_keys(node: Mapping[str, Any], key: str) -> set[str]:
     return set(node.keys()) & VALID_KEYS - set(IGNORED_KEYS) - {key}
 
 
+def check_number_bounds(minimum: Union[float, int, None], maximum: Union[float, int, None], exclusiveMinimum: bool, exclusiveMaximum: bool):
+    if minimum is not None and maximum is not None:
+        if minimum > maximum:
+            raise UnsatisfiableSchemaError(f"minimum ({minimum}) is greater than maximum ({maximum})")
+        if minimum == maximum and (exclusiveMinimum or exclusiveMaximum):
+            minimum_repr = f"exclusiveMinimum ({minimum})" if exclusiveMinimum else f"minimum ({minimum})"
+            maximum_repr = f"exclusiveMaximum ({maximum})" if exclusiveMaximum else f"maximum ({maximum})"
+            raise UnsatisfiableSchemaError(f"{minimum_repr} is equal to {maximum_repr}")
+
+
+class UnsatisfiableSchemaError(ValueError):
+    pass
+
 class GenJson:
     item_separator = ", "
     key_separator = ": "
@@ -428,6 +449,7 @@ def ref(
         lm,
         *,
         reference: str,
+        base_uri: str,
     ):
         """
         Resolve a reference to another schema and return the grammar for that schema.
@@ -436,58 +458,31 @@ def ref(
         add it to the _defs cache. This allows us to avoid re-resolving the reference every time
         and to handle recursive references correctly.
         """
-        abspath = self._get_abspath(reference)
+        abspath = urijoin(base_uri, reference)
+
         if abspath not in self._defs:
             resolved = self._resolver.lookup(abspath)
             base_uri_of_resolved = resolved.resolver._base_uri
 
             @guidance(stateless=True, dedent=False, cache=True)
             def closure(lm):
-                with self._base_uri_context(base_uri_of_resolved):
-                    grammar = self.json(json_schema=resolved.contents)
+                grammar = self.json(json_schema=resolved.contents, base_uri=base_uri_of_resolved)
                 return lm + grammar
 
             self._defs[abspath] = closure
         return lm + self._defs[abspath]()
 
 
-    def _get_abspath(self, ref):
-        """
-        Convert a reference to an absolute path, resolving it against the base URI if necessary.
-        This will allow us to get a unique key for each reference and hit the _defs cache correctly.
-        """
-        if ref.startswith("#"):
-            # Special case for fragment-only references:
-            # for certain schemes (e.g. urn), urljoin may throw the base URI, but we need to keep them around
-            return f"{self._base_uri}{ref}"
-        return urljoin(self._base_uri, ref)
-
-
-    @contextlib.contextmanager
-    def _base_uri_context(self, base_uri: str):
-        """
-        Temporarily replace the base_uri for the duration of the context manager.
-        This allows refs with different base URIs to be resolved correctly without passing the resolver around.
-
-        Note: very much not thread-safe, but I don't expect instances of this class to be shared between threads.
-        TODO: ensure that the instance's hash depends on the base_uri before adding more caching to this class.
-        """
-        old_base_uri = self._base_uri
-        self._base_uri = base_uri
-        try:
-            yield
-        finally:
-            self._base_uri = old_base_uri
-
-
     @guidance(stateless=True)
     def root(self, lm):
-        return lm + self.json(json_schema=self.schema)
+        return lm + self.json(json_schema=self.schema, base_uri=self._base_uri)
 
 
     @classmethod
     @guidance(stateless=True)
     def integer(cls, lm, minimum: Union[float, int, None] = None, maximum: Union[float, int, None] = None, exclusiveMinimum: bool = False, exclusiveMaximum: bool = False):
+        check_number_bounds(minimum, maximum, exclusiveMinimum, exclusiveMaximum)
+
         if minimum is not None:
             if exclusiveMinimum:
                 if minimum != int(minimum):
@@ -513,6 +508,8 @@ def integer(cls, lm, minimum: Union[float, int, None] = None, maximum: Union[flo
     @classmethod
     @guidance(stateless=True)
     def number(cls, lm, minimum: Optional[float] = None, maximum: Optional[float] = None, exclusiveMinimum: bool = False, exclusiveMaximum: bool = False):
+        check_number_bounds(minimum, maximum, exclusiveMinimum, exclusiveMaximum)
+
         return lm + lexeme(
             rx_float_range(
                 minimum, maximum,
@@ -534,6 +531,9 @@ def string(
         regex: Union[str, None] = None,
         format: Union[str, None] = None,
     ):
+        if min_length is not None and max_length is not None and min_length > max_length:
+            raise UnsatisfiableSchemaError(f"String minLength ({min_length}) is greater than maxLength ({max_length})")
+
         if (regex is not None or format is not None) and (min_length > 0 or max_length is not None):
             raise ValueError(
                 "If a pattern or format is specified for a JSON string, minLength and maxLength must be left unspecified."
@@ -566,27 +566,51 @@ def object(
         properties: Mapping[str, JSONSchema],
         additional_properties: JSONSchema,
         required: Sequence[str],
+        base_uri: str,
     ):
-        # "required" keys will be validated against "properties" if they're present, otherwise against "additionalProperties".
-        # If "additionalProperties" is False, then required keys must be in "properties".
-        if any(k not in properties for k in required) and additional_properties is False:
-            raise ValueError(
-                f"Required properties not in properties but additionalProperties is False."
-                f" Missing required properties: {list(r for r in required if r not in properties)}"
-            )
+        illegal_keys = set()
+        property_grammars: dict[str, GrammarFunction] = {}
+        for name, schema in properties.items():
+            try:
+                property_grammars[name] = self.json(json_schema=schema, base_uri=base_uri)
+            except UnsatisfiableSchemaError as e:
+                # We get here if the schema is a literal False or is otherwise determined to be unsatisfiable
+                if name in required:
+                    raise UnsatisfiableSchemaError(f"Required property {name!r} is unsatisfiable") from e
+                # If the property is not required, we will just "blacklist" this key (e.g. if the schema was False)
+                # Note that we're just dropping this exception.
+                # Use json_dumps to properly quote / escape the key before adding it to the blacklist
+                key = json_dumps(name)
+                illegal_keys.add(key)
+
+        additional_properties_grammar: Optional[GrammarFunction] = None
+        try:
+            additional_properties_grammar = self.json(json_schema=additional_properties, base_uri=base_uri)
+        except UnsatisfiableSchemaError as e:
+            if any(k not in properties for k in required):
+                # "required" keys will be validated against "properties" if they're present, otherwise against "additionalProperties".
+                # If "additionalProperties" is unsatisfiable, then required keys must be in "properties".
+                raise UnsatisfiableSchemaError(
+                    f"Required properties not in properties but additionalProperties is unsatisfiable."
+                    f" Missing required properties: {list(r for r in required if r not in properties)}"
+                ) from e
+            else:
+                # If "additionalProperties" is unsatisfiable but there are no required properties that need to be validated against it,
+                # then we can safely ignore it. Note that this means that we are just going to drop this exception.
+                pass
 
         keys: list[str] = []
         required_items: list[bool] = []
-        grammars: list[GrammarFunction] = []
+        item_grammars: list[GrammarFunction] = []
         # First iterate over the properties in order, then iterate over any missing required keys, using additional_properties as the schema
-        for name in (*properties, *(r for r in required if r not in properties)):
+        for name in (*property_grammars.keys(), *(r for r in required if r not in properties)):
             # Use json_dumps to properly quote / escape the key
             key = json_dumps(name)
             keys.append(key)
             # Identify if the key is required
             required_items.append(name in required)
             # Build the grammar we'll use for this property
-            grammars.append(f'{key}{self.key_separator}' + self.json(json_schema=properties.get(name, additional_properties)))
+            item_grammars.append(f'{key}{self.key_separator}' + property_grammars.get(name, cast(GrammarFunction, additional_properties_grammar)))
 
         if additional_properties is not False:
             # Key for additionalProperties is a json string, but we need to disallow any properties that are already defined
@@ -595,20 +619,21 @@ def object(
                 additional_key_grammar = as_regular_grammar(
                     And([
                         lexeme(r'"([^"\\]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*"'),
-                        Not(lexeme('|'.join(map(quote_regex, keys)))),
+                        Not(lexeme('|'.join(map(quote_regex, (*keys, *illegal_keys))))),
                     ]),
                     lexeme = True,
                 )
             else:
                 additional_key_grammar = self.string()
 
-            additional_item_grammar = additional_key_grammar + self.key_separator + self.json(json_schema=additional_properties)
-            additional_items_grammar = sequence(additional_item_grammar + self.item_separator) + additional_item_grammar
-            grammars.append(additional_items_grammar)
-            required_items.append(False)
+            if additional_properties_grammar is not None:
+                additional_item_grammar = additional_key_grammar + self.key_separator + additional_properties_grammar
+                additional_items_grammar = sequence(additional_item_grammar + self.item_separator) + additional_item_grammar
+                item_grammars.append(additional_items_grammar)
+                required_items.append(False)
 
         return lm + "{" + self._join(
-            elements = tuple(grammars),
+            elements = tuple(item_grammars),
             required = tuple(required_items),
         ) + "}"
 
@@ -649,15 +674,25 @@ def array(
         item_schema: JSONSchema,
         min_items: int,
         max_items: Optional[int],
+        base_uri: str,
     ):
-        if len(prefix_items_schema) < min_items and item_schema is False:
-            raise ValueError(
-                f"PrefixItems has too few elements ({len(prefix_items_schema)}) to"
-                f" satisfy minItems ({min_items}) but no extra items were allowed"
-            )
+        if max_items is not None and min_items > max_items:
+            raise UnsatisfiableSchemaError(f"minItems ({min_items}) is greater than maxItems ({max_items})")
 
-        if max_items is not None and max_items < min_items:
-            raise ValueError(f"maxItems ({max_items}) can't be less than minItems ({min_items})")
+        items_grammar: Optional[GrammarFunction] = None
+        try:
+            items_grammar = self.json(json_schema=item_schema, base_uri=base_uri)
+        except UnsatisfiableSchemaError as e:
+            if len(prefix_items_schema) < min_items:
+                raise UnsatisfiableSchemaError(
+                    f"prefixItems has too few elements ({len(prefix_items_schema)}) to satisfy minItems ({min_items})"
+                    f" but item schema is unsatisfiable"
+                ) from e
+            else:
+                # If we've already satisfied min_items, we can just ignore the unsatisfiable item schema. This just means
+                # that we can't generate any more items after the prefix items.
+                # Note that this means that we are just going to drop this exception.
+                pass
 
         required_items = []
         optional_items = []
@@ -666,24 +701,31 @@ def array(
         n_to_add = max(len(prefix_items_schema), min_items) if max_items is None else max_items
         for i in range(n_to_add):
             if i < len(prefix_items_schema):
-                schema = prefix_items_schema[i]
-            elif item_schema is not False:
-                schema = item_schema
+                try:
+                    item = self.json(json_schema=prefix_items_schema[i], base_uri=base_uri)
+                except UnsatisfiableSchemaError as e:
+                    # i corresponds to the number of items we've already satisfied
+                    if i < min_items:
+                        raise UnsatisfiableSchemaError(f"prefixItems[{i}] is unsatisfiable but min_items is {min_items}") from e
+                    # Having an unsatisfiable prefix item is fine if we've already satisfied min_items, but this effectively sets max_items to i
+                    # Note that this means that we are just going to drop this exception.
+                    max_items = i
+                    break
+
+            elif items_grammar is not None:
+                item = items_grammar
             else:
                 assert i >= min_items
                 break
 
-            item = self.json(json_schema=schema)
-
             if i < min_items:
                 required_items.append(item)
             else:
                 optional_items.append(item)
 
-        if max_items is None and item_schema is not False:
+        if max_items is None and items_grammar is not None:
             # Add an infinite tail of items
-            item = self.json(json_schema=item_schema)
-            optional_items.append(item + sequence(self.item_separator + item))
+            optional_items.append(items_grammar + sequence(self.item_separator + items_grammar))
 
         lm += "["
 
@@ -718,30 +760,342 @@ def anyOf(
         lm,
         *,
         anyof_list: Sequence[JSONSchema],
+        base_uri: str,
     ):
-        options = [self.json(json_schema=item) for item in anyof_list]
+        if not anyof_list:
+            raise UnsatisfiableSchemaError("anyOf has no schemas")
+
+        options: list[GrammarFunction] = []
+        for item in anyof_list:
+            try:
+                options.append(self.json(json_schema=item, base_uri=base_uri))
+            except UnsatisfiableSchemaError:
+                # No need to raise an error if one of the schemas is unsatisfiable. We'll check again at the end and raise if ALL
+                # schemas are unsatisfiable. Note that this means that we are just going to drop this exception.
+                pass
+        if not options:
+            # Can't really point to any one schema that's unsatisfiable, so let's include all the schemas in the error message
+            raise UnsatisfiableSchemaError("all anyOf schemas are unsatisfiable: " + json_dumps(anyof_list))
         return lm + select(options)
 
+    @guidance(stateless=True)
+    def oneOf(
+        self,
+        lm,
+        *,
+        oneof_list: Sequence[JSONSchema],
+        base_uri: str,
+    ):
+        if not oneof_list:
+            raise UnsatisfiableSchemaError("oneOf has no schemas")
+        if len(oneof_list) == 1:
+            return lm + self.json(json_schema=oneof_list[0], base_uri=base_uri)
+        warnings.warn("oneOf not fully supported, falling back to anyOf. This may cause validation errors in some cases.")
+        return lm + self.anyOf(anyof_list=oneof_list, base_uri=base_uri)
+
+    def push_sibling_keys(self, json_schema: dict[str, Any]) -> dict[str, Any]:
+        """
+        If sibling keys are present next to anyOf, oneOf, or $ref, we push them down into an allOf.
+        """
+        parent_schema = json_schema.copy()
+        anyof_list = parent_schema.pop(Keyword.ANYOF, [])
+        oneof_list = parent_schema.pop(Keyword.ONEOF, [])
+        allof_list = parent_schema.pop(Keyword.ALLOF, [])
+        ref = parent_schema.pop(Keyword.REF, None)
+
+        common = []
+        if VALID_KEYS.intersection(parent_schema) - set(IGNORED_KEYS):
+            # If there are any sibling keys, we need to push them down into an allOf
+            common.append(parent_schema)
+        if allof_list:
+            common.extend(allof_list)
+        if ref:
+            # TODO: $id / base_uri?
+            common.append({Keyword.REF: ref})
+
+        if anyof_list and oneof_list:
+            return {
+                "oneOf": [
+                    {"allOf": common + [one_item, any_item]}
+                    for one_item in oneof_list
+                    for any_item in anyof_list
+                ],
+            }
+
+        if oneof_list:
+            if not common:
+                return {"oneOf": oneof_list}
+            return {
+                "oneOf": [
+                    {"allOf": common + [one_item]}
+                    for one_item in oneof_list
+                ],
+            }
+
+        if anyof_list:
+            if not common:
+                return {"anyOf": anyof_list}
+            return {
+                "anyOf": [
+                    {"allOf": common + [any_item]}
+                    for any_item in anyof_list
+                ],
+            }
+
+        if len(common) == 1:
+            return common[0]
+
+        return {"allOf": common}
+
+    def reduce_schema(self, orig_schema: dict[str, Any], base_uri: str) -> dict[str, Any]:
+        types: list[set[str]] = []
+        properties: defaultdict[str, list[JSONSchema]] = defaultdict(list)
+        required: dict[str, None] = dict() # use a dict for ordered-set behavior
+        additional_properties_list: list[tuple[JSONSchema, set[str]]] = []
+        prefix_items: defaultdict[int, list[JSONSchema]] = defaultdict(list)
+        items_list: list[tuple[JSONSchema, set[int]]] = []
+        other_data: dict[str, Any] = {}
+        enums: list[Sequence[Any]] = []
+        consts: list[Any] = []
+
+        def handle_keyword(key: str, value: Any, parent_schema: dict[str, Any], base_uri: str):
+            if key == Keyword.ANYOF:
+                raise NotImplementedError("anyOf in allOf not yet supported")
+
+            elif key == Keyword.ONEOF:
+                raise NotImplementedError("oneOf in allOf not yet supported")
+
+            elif key == Keyword.ALLOF:
+                value = cast(Sequence[JSONSchema], value)
+                for schema in value:
+                    add_schema(schema, base_uri)
+
+            elif key == Keyword.REF:
+                ref = cast(str, value)
+                abspath = urijoin(base_uri, ref)
+                resolved = self._resolver.lookup(abspath)
+                add_schema(resolved.contents, base_uri=resolved.resolver._base_uri)
+
+            elif key == Keyword.CONST:
+                consts.append(value)
+
+            elif key == Keyword.ENUM:
+                value = cast(list[Any], value)
+                enums.append(value)
+
+            elif key == Keyword.TYPE:
+                value = cast(Union[str, Sequence[str]], value)
+                if isinstance(value, str):
+                    value_set = {value}
+                else:
+                    value_set = set(value)
+                types.append(value_set)
+
+            elif key == ObjectKeywords.PROPERTIES:
+                value = cast(dict[str, JSONSchema], value)
+                for name, schema in value.items():
+                    if isinstance(schema, dict):
+                        this_base_uri = schema.get(Keyword.ID, base_uri)
+                        if Keyword.REF in schema:
+                            # Make the ref absolute so that it can be resolved in the right scope later
+                            schema = schema.copy()
+                            schema[Keyword.REF] = urijoin(this_base_uri, schema[Keyword.REF])
+                    properties[name].append(schema)
+
+            elif key == ObjectKeywords.REQUIRED:
+                value = cast(Sequence[str], value)
+                required.update({name: None for name in value})
+
+            elif key == ObjectKeywords.ADDITIONAL_PROPERTIES:
+                # TODO: unevaluatedProperties?
+                value = cast(JSONSchema, value)
+                # We need to keep track of which properties are exempt from this additionalProperties schema,
+                # i.e. the ones defined in the parent schema
+                exempt_properties: set[str] = set()
+                if ObjectKeywords.PROPERTIES in parent_schema:
+                    exempt_properties = set(parent_schema[ObjectKeywords.PROPERTIES])
+                additional_properties_list.append(
+                    (value, exempt_properties)
+                )
+
+            elif key == ArrayKeywords.PREFIX_ITEMS:
+                value = cast(Sequence[JSONSchema], value)
+                for i, schema in enumerate(value):
+                    prefix_items[i].append(schema)
+
+            elif key == ArrayKeywords.ITEMS:
+                # TODO: unevaluatedItems?
+                value = cast(JSONSchema, value)
+                # We need to keep track of which prefixItems are exempt from this additionalItems schema,
+                # i.e. the ones defined in the parent schema
+                exempt_prefix_items: set[int] = set()
+                if ArrayKeywords.PREFIX_ITEMS in parent_schema:
+                    exempt_prefix_items = set(range(len(parent_schema[ArrayKeywords.PREFIX_ITEMS])))
+                items_list.append(
+                    (value, exempt_prefix_items)
+                )
+
+            elif key in other_data:
+                if key in {
+                    NumberKeywords.MINIMUM, NumberKeywords.EXCLUSIVE_MINIMUM,
+                    StringKeywords.MIN_LENGTH, ArrayKeywords.MIN_ITEMS
+                }:
+                    other_data[key] = max(other_data[key], value)
+                elif key in {
+                    NumberKeywords.MAXIMUM, NumberKeywords.EXCLUSIVE_MAXIMUM,
+                    StringKeywords.MAX_LENGTH, ArrayKeywords.MAX_ITEMS
+                }:
+                    other_data[key] = min(other_data[key], value)
+                else:
+                    raise NotImplementedError(f"Don't yet know how to reduce multiple values of {key!r} in allOf")
+
+            else:
+                other_data[key] = value
+
+        def add_schema(schema: JSONSchema, base_uri: str):
+            if schema is True:
+                return
+            if schema is False:
+                raise UnsatisfiableSchemaError("allOf contains a 'false' schema")
+
+            # Validate the schema's keys (we have only validated the parent schema's keys so far)
+            # TODO: This will make us validate the parent twice... should probably be refactored
+            validate_json_node_keys(schema)
+
+            # Set the base_uri for this schema
+            if Keyword.ID in schema:
+                # TODO: avoid copies if possible..?
+                schema = schema.copy()
+                base_uri = urijoin(base_uri, schema.pop(Keyword.ID))
+
+            for key, value in schema.items():
+                if key in IGNORED_KEYS:
+                    continue
+                handle_keyword(key, value, schema, base_uri)
+
+        add_schema(orig_schema, base_uri)
+
+        combined_schema: dict[str, Any] = {}
+
+        # Post-process additional_properties to make sure we apply the additional properties of one
+        # schema to the properties of another schema
+        for additional_schema, exempt_properties in additional_properties_list:
+            for name in set(properties) - exempt_properties:
+                properties[name].append(additional_schema)
+
+        # Post-process items to make sure we apply the additional items of one schema to the prefix items of another schema
+        for additional_schema, exempt_prefix_items in items_list:
+            for i in set(prefix_items) - exempt_prefix_items:
+                prefix_items[i].append(additional_schema)
+
+        if properties:
+            combined_schema[ObjectKeywords.PROPERTIES] = {}
+            for name, schemas in properties.items():
+                if len(schemas) == 1:
+                    combined_schema[ObjectKeywords.PROPERTIES][name] = schemas[0]
+                else:
+                    combined_schema[ObjectKeywords.PROPERTIES][name] = {"allOf": schemas}
+
+        if required:
+            combined_schema[ObjectKeywords.REQUIRED] = list(required.keys())
+
+        if additional_properties_list:
+            if len(additional_properties_list) == 1:
+                combined_schema[ObjectKeywords.ADDITIONAL_PROPERTIES], _ = additional_properties_list[0]
+            else:
+                combined_schema[ObjectKeywords.ADDITIONAL_PROPERTIES] = {"allOf": [schema for schema, _ in additional_properties_list]}
+
+        if prefix_items:
+            combined_schema[ArrayKeywords.PREFIX_ITEMS] = []
+            for i in range(len(prefix_items)):
+                schemas = prefix_items[i]
+                if len(schemas) == 1:
+                    combined_schema[ArrayKeywords.PREFIX_ITEMS].append(schemas[0])
+                else:
+                    combined_schema[ArrayKeywords.PREFIX_ITEMS].append({"allOf": schemas})
+
+        if items_list:
+            if len(items_list) == 1:
+                combined_schema[ArrayKeywords.ITEMS], _ = items_list[0]
+            else:
+                combined_schema[ArrayKeywords.ITEMS] = {"allOf": [schema for schema, _ in items_list]}
+
+        if enums:
+            if len(enums) == 1:
+                enum = enums[0]
+            else:
+                def reduce_enums(enum_a, enum_b):
+                    try:
+                        enum = list(set(enum_a) & set(enum_b))
+                    except TypeError:
+                        # Check on equality, not on hash
+                        # Yes, this is O(n^2).
+                        # Hope the items were unique.
+                        # ¯\_(ツ)_/¯
+                        enum = [a for a in enum_a for b in enum_b if a == b]
+                    return enum
+                enum = functools.reduce(reduce_enums, enums)
+            if not enum:
+                raise UnsatisfiableSchemaError(f"allOf has enums with no common values: {enums}")
+            combined_schema[Keyword.ENUM] = enum
+
+        if consts:
+            const, *rest = consts
+            for c in rest:
+                if c != const:
+                    raise UnsatisfiableSchemaError(f"allOf has consts with different values: {consts}")
+            combined_schema[Keyword.CONST] = const
+
+        if types:
+            if len(types) == 1:
+                type = list(types[0])
+            else:
+                def reduce_types(type_a: set[str], type_b: set[str]) -> set[str]:
+                    common_types = type_a & type_b
+                    # Integer is a "subtype" of number, so ensure we keep integer if we have "number" in one and "integer" in the other
+                    if JSONType.INTEGER not in common_types and (
+                        (JSONType.NUMBER in type_a and JSONType.INTEGER in type_b) or
+                        (JSONType.INTEGER in type_a and JSONType.NUMBER in type_b)
+                    ):
+                        common_types.add(JSONType.INTEGER)
+                    return common_types
+                type = list(functools.reduce(reduce_types, types)) # type: ignore[arg-type]
+                if not type:
+                    raise UnsatisfiableSchemaError(f"allOf has conflicting types: {types}")
+            combined_schema[Keyword.TYPE] = type
+
+        assert not set(combined_schema) & set(other_data)
+        combined_schema.update(other_data)
+        return combined_schema
+
+
+    @guidance(stateless=True)
+    def allOf(
+        self,
+        lm,
+        *,
+        parent_schema: dict[str, Any],
+        base_uri: str,
+    ):
+        reduced_schema = self.reduce_schema(parent_schema, base_uri)
+        return lm + self.json(json_schema=reduced_schema, base_uri=base_uri)
+
+
     @guidance(stateless=True)
     def const(
         self,
         lm,
         *,
         value: Union[None, bool, int, float, str, Mapping, Sequence],
-        instance_type: Optional[Union[str, Sequence[str]]] = None,
-        enum: Optional[Sequence[Union[None, bool, int, float, str, Mapping, Sequence]]] = None,
+        parent_schema: JSONSchema,
     ):
-        schema_to_validate_against: dict[str, Any] = {}
-        if instance_type is not None:
-            schema_to_validate_against["type"] = instance_type
-        if enum is not None:
-            schema_to_validate_against["enum"] = enum
-        if schema_to_validate_against:
-            # Raise a validation error if the value doesn't match the type
+        try:
             jsonschema.validate(
                 instance=value,
-                schema=schema_to_validate_against,
+                schema=parent_schema,
             )
+        except jsonschema.ValidationError as e:
+            raise UnsatisfiableSchemaError(f"const {value!r} is inconsistent with parent schema: {parent_schema}") from e
         # Base case
         if isinstance(value, (type(None), bool, int, float, str)):
             return lm + json_dumps(value)
@@ -755,7 +1109,8 @@ def const(
                     "properties": {k: {"const": v} for k, v in dict(value).items()},
                     "required": list(value.keys()),
                     "additionalProperties": False,
-                }
+                },
+                base_uri="", # dummy value -- we don't need to resolve anything
             )
         if isinstance(value, Sequence):
             return lm + self.json(
@@ -765,7 +1120,8 @@ def const(
                     "minItems": len(value),
                     "maxItems": len(value),
                     "items": False,
-                }
+                },
+                base_uri="", # dummy value -- we don't need to resolve anything
             )
         raise TypeError(f"Unsupported value type: {type(value)} for value: {value!r}")
 
@@ -775,17 +1131,21 @@ def enum(
         lm,
         *,
         options: Sequence[Union[None, bool, int, float, str, Mapping, Sequence]],
-        instance_type: Optional[Union[str, Sequence[str]]] = None,
+        parent_schema: JSONSchema,
     ):
+        if not options:
+            raise UnsatisfiableSchemaError("enum has no options")
         all_opts: list[GrammarFunction] = []
         for instance in options:
             try:
-                grm = self.const(value=instance, instance_type=instance_type)
-            except jsonschema.ValidationError:
+                grm = self.const(value=instance, parent_schema=parent_schema)
+            except UnsatisfiableSchemaError:
+                # Like anyOf, we don't want to raise an error if one of the options is unsatisfiable. We'll check again at the end
+                # and raise if ALL options are unsatisfiable. Note that this means that we are just going to drop this exception.
                 continue
             all_opts.append(grm)
         if not all_opts:
-            raise ValueError(f"No valid options found for enum with type {instance_type!r}: {options}")
+            raise UnsatisfiableSchemaError(f"All enum options {options} are inconsistent with parent schema: {parent_schema}")
         return lm + select(options=all_opts)
 
 
@@ -793,23 +1153,26 @@ def enum(
     def any(self, lm):
         return lm + select(
             [
-                self.json(json_schema={"type": "null"}),
-                self.json(json_schema={"type": "boolean"}),
-                self.json(json_schema={"type": "integer"}),
-                self.json(json_schema={"type": "number"}),
-                self.json(json_schema={"type": "string"}),
+                # Dummy base uris ok since we're not resolving anything
+                self.json(json_schema={"type": "null"}, base_uri=""),
+                self.json(json_schema={"type": "boolean"}, base_uri=""),
+                self.json(json_schema={"type": "integer"}, base_uri=""),
+                self.json(json_schema={"type": "number"}, base_uri=""),
+                self.json(json_schema={"type": "string"}, base_uri=""),
                 # Recursive cases
                 self.json(
                     json_schema={
                         "type": "array",
                         "items": True,
                     },
+                    base_uri="",
                 ),
                 self.json(
                     json_schema={
                         "type": "object",
                         "additionalProperties": True,
                     },
+                    base_uri="",
                 ),
             ]
         )
@@ -821,74 +1184,53 @@ def json(
         lm,
         *,
         json_schema: JSONSchema,
+        base_uri: str,
     ):
         if json_schema is True:
             json_schema = {}
         elif json_schema is False:
-            raise ValueError("No valid JSON can be generated from a schema of `False`")
+            raise UnsatisfiableSchemaError("No valid JSON can be generated from a schema of `false`")
 
         if json_schema == {}:
             return lm + self.any()
 
-        validate_json_node_keys(json_schema)
+        # Early exit for simple cases
+        if Keyword.CONST in json_schema:
+            return lm + self.const(value=json_schema[Keyword.CONST], parent_schema=json_schema)
 
-        if Keyword.ANYOF in json_schema:
-            sibling_keys = get_sibling_keys(json_schema, Keyword.ANYOF)
-            if sibling_keys:
-                raise NotImplementedError(f"anyOf with sibling keys is not yet supported. Got {sibling_keys}")
-            return lm + self.anyOf(anyof_list=json_schema[Keyword.ANYOF])
+        if Keyword.ENUM in json_schema:
+            return lm + self.enum(options=json_schema[Keyword.ENUM], parent_schema=json_schema)
+
+        # More complex cases; validation needed
+        validate_json_node_keys(json_schema)
+        json_schema = self.push_sibling_keys(json_schema)
 
         if Keyword.ALLOF in json_schema:
             sibling_keys = get_sibling_keys(json_schema, Keyword.ALLOF)
-            if sibling_keys:
-                raise NotImplementedError(f"allOf with sibling keys is not yet supported. Got {sibling_keys}")
-            allof_list = json_schema[Keyword.ALLOF]
-            if len(allof_list) != 1:
-                raise ValueError("Only support allOf with exactly one item")
-            return lm + self.json(json_schema=allof_list[0])
+            assert not sibling_keys
+            return lm + self.allOf(parent_schema=json_schema, base_uri=base_uri)
+
+        if Keyword.ANYOF in json_schema:
+            sibling_keys = get_sibling_keys(json_schema, Keyword.ANYOF)
+            assert not sibling_keys
+            return lm + self.anyOf(anyof_list=json_schema[Keyword.ANYOF], base_uri=base_uri)
 
         if Keyword.ONEOF in json_schema:
             sibling_keys = get_sibling_keys(json_schema, Keyword.ONEOF)
-            if sibling_keys:
-                raise NotImplementedError(f"oneOf with sibling keys is not yet supported. Got {sibling_keys}")
-            oneof_list = json_schema[Keyword.ONEOF]
-            if len(oneof_list) == 1:
-                return lm + self.json(json_schema=oneof_list[0])
-            warnings.warn("oneOf not fully supported, falling back to anyOf. This may cause validation errors in some cases.")
-            return lm + self.anyOf(anyof_list=oneof_list)
+            assert not sibling_keys
+            return lm + self.oneOf(oneof_list=json_schema[Keyword.ONEOF], base_uri=base_uri)
 
         if Keyword.REF in json_schema:
             sibling_keys = get_sibling_keys(json_schema, Keyword.REF)
-            if sibling_keys:
-                raise NotImplementedError(f"$ref with sibling keys is not yet supported. Got {sibling_keys}")
-            return lm + self.ref(reference=json_schema[Keyword.REF])
-
-        if Keyword.CONST in json_schema:
-            sibling_keys = get_sibling_keys(json_schema, Keyword.CONST) - {Keyword.TYPE, Keyword.ENUM}
-            if sibling_keys:
-                raise NotImplementedError(f"const with sibling keys is not yet supported. Got {sibling_keys}")
-            return lm + self.const(value=json_schema[Keyword.CONST], instance_type=json_schema.get(Keyword.TYPE, None), enum=json_schema.get(Keyword.ENUM, None))
+            assert not sibling_keys
+            return lm + self.ref(reference=json_schema[Keyword.REF], base_uri=base_uri)
 
-        if Keyword.ENUM in json_schema:
-            sibling_keys = get_sibling_keys(json_schema, Keyword.ENUM) - {Keyword.TYPE}
-            if sibling_keys:
-                raise NotImplementedError(f"enum with sibling keys is not yet supported. Got {sibling_keys}")
-            return lm + self.enum(options=json_schema[Keyword.ENUM], instance_type=json_schema.get(Keyword.TYPE, None))
-
-        if Keyword.TYPE in json_schema:
-            target_types = cast(Union[str, Sequence[str]], json_schema[Keyword.TYPE])
-            if isinstance(target_types, str):
-                target_types = [target_types]
-        else:
-            target_types = list(JSONType)
-
-        options: list[Union[str, GrammarFunction]] = []
-        option: Union[str, GrammarFunction]
-        for target_type in target_types:
+        if Keyword.TYPE in json_schema and isinstance(json_schema[Keyword.TYPE], str):
+            target_type = json_schema[Keyword.TYPE]
             if target_type == JSONType.NULL:
-                option = "null"
+                return  lm + "null"
             elif target_type == JSONType.BOOLEAN:
-                option = select(["true", "false"])
+                return lm + select(["true", "false"])
             elif target_type in {JSONType.INTEGER, JSONType.NUMBER}:
                 minimum = cast(Union[int, float, None], json_schema.get(NumberKeywords.MINIMUM, None))
                 maximum = cast(Union[int, float, None], json_schema.get(NumberKeywords.MAXIMUM, None))
@@ -910,44 +1252,58 @@ def json(
                         exclusive_maximum_flag = True
 
                 if target_type == JSONType.INTEGER:
-                    option = self.integer(
+                    return lm + self.integer(
                         minimum=minimum,
                         maximum=maximum,
                         exclusiveMinimum=exclusive_minimum_flag,
                         exclusiveMaximum=exclusive_maximum_flag,
                     )
                 else:
-                    option = self.number(
+                    return lm + self.number(
                         minimum=minimum,
                         maximum=maximum,
                         exclusiveMinimum=exclusive_minimum_flag,
                         exclusiveMaximum=exclusive_maximum_flag,
                     )
             elif target_type == JSONType.STRING:
-                option = self.string(
+                return lm + self.string(
                     regex=json_schema.get(StringKeywords.PATTERN, None),
                     format=json_schema.get(StringKeywords.FORMAT, None),
                     min_length=json_schema.get(StringKeywords.MIN_LENGTH, 0),
                     max_length=json_schema.get(StringKeywords.MAX_LENGTH, None),
                 )
             elif target_type == JSONType.ARRAY:
-                option = self.array(
+                return lm + self.array(
                     prefix_items_schema=json_schema.get(ArrayKeywords.PREFIX_ITEMS, []),
                     item_schema=json_schema.get(ArrayKeywords.ITEMS, True),
                     min_items=json_schema.get(ArrayKeywords.MIN_ITEMS, 0),
                     max_items=json_schema.get(ArrayKeywords.MAX_ITEMS, None),
+                    base_uri=base_uri,
                 )
             elif target_type == JSONType.OBJECT:
-                option = self.object(
+                return lm + self.object(
                     properties=json_schema.get(ObjectKeywords.PROPERTIES, {}),
                     additional_properties=json_schema.get(ObjectKeywords.ADDITIONAL_PROPERTIES, True),
                     required=json_schema.get(ObjectKeywords.REQUIRED, set()),
+                    base_uri=base_uri,
                 )
             else:
                 raise ValueError(f"Unsupported type in schema: {target_type}")
-            options.append(option)
 
-        return lm + select(options)
+        if Keyword.TYPE in json_schema:
+            json_schema = json_schema.copy()
+            target_types = cast(Sequence[JSONType], json_schema.pop(Keyword.TYPE))
+        else:
+            target_types = list(JSONType)
+
+        assert Keyword.TYPE not in json_schema
+        # Punt to anyOf if we have multiple types so that it can ignore an unsatisfiable subset
+        return lm + self.anyOf(
+            anyof_list = [
+                {"type": target_type, **json_schema} for target_type in target_types
+            ],
+            base_uri=base_uri,
+        )
 
 
 @guidance(stateless=True)
diff --git a/tests/unit/library/json/test_allOf.py b/tests/unit/library/json/test_allOf.py
new file mode 100644
index 000000000..e27d93940
--- /dev/null
+++ b/tests/unit/library/json/test_allOf.py
@@ -0,0 +1,497 @@
+"""Adapted from https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/9fc880bfb6d8ccd093bc82431f17d13681ffae8e/tests/draft2020-12/allOf.json"""
+
+from json import dumps as json_dumps
+
+import pytest
+from jsonschema import ValidationError, validate
+
+from guidance import json as gen_json
+
+from .utils import check_match_failure, generate_and_check
+
+
+class TestAllOf:
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # allOf
+            ({"bar": 2, "foo": "baz"}, True),
+            # mismatch second
+            ({"foo": "baz"}, False),
+            # mismatch first
+            ({"bar": 2}, False),
+            # wrong type
+            ({"bar": "quux", "foo": "baz"}, False),
+        ],
+    )
+    def test_allOf(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [
+                {"properties": {"bar": {"type": "integer"}}, "required": ["bar"]},
+                {"properties": {"foo": {"type": "string"}}, "required": ["foo"]},
+            ],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # valid
+            ({"bar": 2, "foo": "quux", "baz": None}, True),
+            # mismatch base schema
+            ({"foo": "quux", "baz": None}, False),
+            # mismatch first allOf
+            ({"bar": 2, "baz": None}, False),
+            # mismatch second allOf
+            ({"bar": 2, "foo": "quux"}, False),
+            # mismatch both
+            ({"bar": 2}, False),
+        ],
+    )
+    def test_allOf_with_base_schema(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "properties": {"bar": {"type": "integer"}},
+            "required": ["bar"],
+            "allOf": [
+                {"properties": {"foo": {"type": "string"}}, "required": ["foo"]},
+                {"properties": {"baz": {"type": "null"}}, "required": ["baz"]},
+            ],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # valid
+            (25, True),
+            # mismatch one
+            (35, False),
+            # mismatch other
+            (15, False),
+        ],
+    )
+    def test_allOf_simple_types(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [{"maximum": 30}, {"minimum": 20}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # mismatch both
+            (15, False),
+            # mismatch one
+            (25, False),
+            # valid
+            (35, True),
+        ],
+    )
+    def test_allOf_simple_minimum(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [{"minimum": 30}, {"minimum": 20}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # mismatch both
+            (35, False),
+            # mismatch one
+            (25, False),
+            # valid
+            (15, True),
+        ],
+    )
+    def test_allOf_simple_maximum(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [{"maximum": 30}, {"maximum": 20}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # any value is valid
+            ("foo", True)
+        ],
+    )
+    def test_allOf_with_boolean_schemas_all_true(self, test_object, valid):
+        schema = {"$schema": "https://json-schema.org/draft/2020-12/schema", "allOf": [True, True]}
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # any value is invalid
+            ("foo", False)
+        ],
+    )
+    def test_allOf_with_boolean_schemas_some_false(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [True, False],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            with pytest.raises(ValueError) as ve:
+                _ = gen_json(schema=schema)
+            assert ve.value.args[0] == "allOf contains a 'false' schema"
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # any value is invalid
+            ("foo", False)
+        ],
+    )
+    def test_allOf_with_boolean_schemas_all_false(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [False, False],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            with pytest.raises(ValueError) as ve:
+                _ = gen_json(schema=schema)
+            assert ve.value.args[0] == "allOf contains a 'false' schema"
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # any data is valid
+            (1, True)
+        ],
+    )
+    def test_allOf_with_one_empty_schema(self, test_object, valid):
+        schema = {"$schema": "https://json-schema.org/draft/2020-12/schema", "allOf": [{}]}
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # any data is valid
+            (1, True)
+        ],
+    )
+    def test_allOf_with_two_empty_schemas(self, test_object, valid):
+        schema = {"$schema": "https://json-schema.org/draft/2020-12/schema", "allOf": [{}, {}]}
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # number is valid
+            (1, True),
+            # string is invalid
+            ("foo", False),
+        ],
+    )
+    def test_allOf_with_the_first_empty_schema(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [{}, {"type": "number"}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # number is valid
+            (1, True),
+            # string is invalid
+            ("foo", False),
+        ],
+    )
+    def test_allOf_with_the_last_empty_schema(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [{"type": "number"}, {}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # null is valid
+            (None, True),
+            # anything non-null is invalid
+            (123, False),
+        ],
+    )
+    def test_nested_allOf_to_check_validation_semantics(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [{"allOf": [{"type": "null"}]}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        ["test_object", "valid"],
+        [
+            # allOf: false, anyOf: false, oneOf: false
+            (1, False),
+            # allOf: false, anyOf: false, oneOf: true
+            (5, False),
+            # allOf: false, anyOf: true, oneOf: false
+            (3, False),
+            # allOf: false, anyOf: true, oneOf: true
+            (15, False),
+            # allOf: true, anyOf: false, oneOf: false
+            (2, False),
+            # allOf: true, anyOf: false, oneOf: true
+            (10, False),
+            # allOf: true, anyOf: true, oneOf: false
+            (6, False),
+            # allOf: true, anyOf: true, oneOf: true
+            (30, True),
+        ],
+    )
+    def test_allOf_combined_with_anyOf_oneOf(self, test_object, valid):
+        schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "allOf": [{"enum": [2, 6, 10, 30]}],
+            "anyOf": [{"enum": [3, 6, 15, 30]}],
+            "oneOf": [{"enum": [5, 10, 15, 30]}],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        "test_object, valid",
+        [
+            # valid: foo is integer and less than 4, bar is equal to 5, baz is integer greater than 5
+            ({"foo": 0, "bar": 5, "baz": 10}, True),
+            # valid: foo is null, bar is equal to 5, baz is null
+            ({"foo": None, "bar": 5, "baz": None}, True),
+            # valid: foo is integer and less than 4, bar is non-number, baz is integer greater than 5
+            ({"foo": 0, "bar": "quxx", "baz": 10}, True),
+            # invalid: foo is integer and greater than 4
+            ({"foo": 5, "bar": 5, "baz": 10}, False),
+            # invalid: foo is not an integer or None
+            ({"foo": "quxx", "bar": 5, "baz": 10}, False),
+            # invalid: bar is greater than 5
+            ({"foo": 0, "bar": 6, "baz": 10}, False),
+            # invalid: bar is less than 5
+            ({"foo": 0, "bar": 4, "baz": 10}, False),
+            # invalid: baz is less than 5
+            ({"foo": 0, "bar": 5, "baz": 4}, False),
+            # invalid: baz is not an integer or null
+            ({"foo": 0, "bar": 5, "baz": "quxx"}, False),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "schema",
+        [
+            # The following are equivalent to this:
+            {
+                "properties": {
+                    "foo": {"type": ["integer", "null"], "maximum": 4},
+                    "bar": {"minimum": 5, "maximum": 5},
+                },
+                "additionalProperties": {"type": ["integer", "null"], "minimum": 5},
+            },
+            # additionalProperties in parent schema
+            {
+                "allOf": [
+                    {"properties": {"bar": {"maximum": 5}}, "additionalProperties": {"type": ["integer", "null"]}}
+                ],
+                "properties": {"foo": {"maximum": 4}},
+                "additionalProperties": {"minimum": 5},
+            },
+            # additionalProperties in allOf
+            {
+                "allOf": [
+                    {
+                        "properties": {"foo": {"maximum": 4}},
+                        "additionalProperties": {"minimum": 5},
+                    },
+                    {
+                        "properties": {"bar": {"maximum": 5}},
+                        "additionalProperties": {"type": ["integer", "null"]},
+                    },
+                ]
+            },
+        ],
+    )
+    def test_additionalProperties_in_allOf(self, schema, test_object, valid):
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        "test_object, valid",
+        [
+            ({}, True),  # empty object is valid
+            ({"foo": 1}, False),  # foo is not a string
+            ({"foo": "x"}, False),  # foo is not an integer
+            ({"foo": True}, False),  # foo is not a string or an integer
+        ],
+    )
+    def test_inconsistent_additionalProperties_in_allOf(self, test_object, valid):
+        schema = {
+            "type": "object",
+            "allOf": [
+                {"additionalProperties": {"type": "integer"}},
+                {"additionalProperties": {"type": "string"}},
+            ],
+        }
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
+
+    @pytest.mark.parametrize(
+        "test_object, valid",
+        [
+            # valid: foo is integer and less than 4, bar is equal to 5, baz is integer greater than 5
+            ([0, 5, 10], True),
+            # valid: foo is null, bar is equal to 5, baz is null
+            ([None, 5, None], True),
+            # valid: foo is integer and less than 4, bar is non-number, baz is integer greater than 5
+            ([0, "quxx", 10], True),
+            # invalid: foo is integer and greater than 4
+            ([5, 5, 10], False),
+            # invalid: foo is not an integer or None
+            (["quxx", 5, 10], False),
+            # invalid: bar is greater than 5
+            ([0, 6, 10], False),
+            # invalid: bar is less than 5
+            ([0, 4, 10], False),
+            # invalid: baz is less than 5
+            ([0, 5, 4], False),
+            # invalid: baz is not an integer or null
+            ([0, 5, "quxx"], False),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "schema",
+        [
+            # The following are equivalent to this:
+            {
+                "prefixItems": [
+                    {"type": ["integer", "null"], "maximum": 4},
+                    {"minimum": 5, "maximum": 5},
+                ],
+                "items": {"type": ["integer", "null"], "minimum": 5},
+            },
+            # items in parent schema
+            {
+                "allOf": [
+                    {"prefixItems": [{"maximum": 4}], "items": {"minimum": 5}},
+                ],
+                "prefixItems": [{"type": ["integer", "null"]}, {"maximum": 5}],
+                "items": {"type": ["integer", "null"]},
+            },
+            # items in allOf
+            {
+                "allOf": [
+                    {"prefixItems": [{"maximum": 4}], "items": {"minimum": 5}},
+                    {
+                        "prefixItems": [{"type": ["integer", "null"]}, {"maximum": 5}],
+                        "items": {"type": ["integer", "null"]},
+                    },
+                ]
+            },
+        ],
+    )
+    def test_items_and_prefixitems_in_allOf(self, schema, test_object, valid):
+        if valid:
+            validate(instance=test_object, schema=schema)
+            generate_and_check(test_object, schema)
+        else:
+            with pytest.raises(ValidationError):
+                validate(instance=test_object, schema=schema)
+            check_match_failure(bad_string=json_dumps(test_object), schema_obj=schema)
diff --git a/tests/unit/library/json/test_json.py b/tests/unit/library/json/test_json.py
index 47adc45f9..c276d7dfc 100644
--- a/tests/unit/library/json/test_json.py
+++ b/tests/unit/library/json/test_json.py
@@ -1,4 +1,5 @@
 import json
+import re
 from json import dumps as json_dumps
 
 import pytest
@@ -76,6 +77,22 @@ def test_bad_integer(self, bad_string, good_bytes, failure_byte, allowed_bytes):
             schema_obj=schema_obj,
         )
 
+    @pytest.mark.parametrize(
+        "schema",
+        [
+            {"type": "integer", "minimum": 5, "maximum": 4},
+            {"type": "integer", "minimum": 5, "exclusiveMaximum": 5},
+            {"type": "integer", "exclusiveMinimum": 5, "maximum": 5},
+        ],
+    )
+    def test_unsatisfiable_min_max(self, schema):
+        with pytest.raises(ValueError) as ve:
+            _ = gen_json(schema=schema)
+        assert re.fullmatch(
+            r"(exclusiveMinimum|minimum) \(5\) is (greater than|equal to) (exclusiveMaximum|maximum) \((4|5)\)",
+            ve.value.args[0],
+        )
+
 
 class TestNumber:
     schema = """{"type": "number" }"""
@@ -130,6 +147,22 @@ def test_bad_number(self, bad_string, good_bytes, failure_byte, allowed_bytes):
             schema_obj=schema_obj,
         )
 
+    @pytest.mark.parametrize(
+        "schema",
+        [
+            {"type": "integer", "minimum": 5, "maximum": 4},
+            {"type": "integer", "minimum": 5, "exclusiveMaximum": 5},
+            {"type": "integer", "exclusiveMinimum": 5, "maximum": 5},
+        ],
+    )
+    def test_unsatisfiable_min_max(self, schema):
+        with pytest.raises(ValueError) as ve:
+            _ = gen_json(schema=schema)
+        assert re.fullmatch(
+            r"(exclusiveMinimum|minimum) \(5\) is (greater than|equal to) (exclusiveMaximum|maximum) \((4|5)\)",
+            ve.value.args[0],
+        )
+
 
 class TestBoundedNumeric:
     @pytest.mark.parametrize(
@@ -540,6 +573,12 @@ def test_maxLength_bad(self, bad_string: str, good_bytes, failure_byte, allowed_
             schema_obj=schema_obj,
         )
 
+    def test_unsatisfiable_length(self):
+        schema = {"type": "string", "minLength": 10, "maxLength": 5}
+        with pytest.raises(ValueError) as ve:
+            _ = gen_json(schema=schema)
+        assert ve.value.args[0] == "String minLength (10) is greater than maxLength (5)"
+
 
 class TestSimpleObject:
     # These are objects without cross references
@@ -671,6 +710,52 @@ def test_bad_object(self, bad_string, good_bytes, failure_byte, allowed_bytes):
             schema_obj=schema_obj,
         )
 
+    def test_unsatisfiable_properties_ok(self):
+        schema = {
+            "type": "object",
+            "properties": {"a": {"type": "integer"}, "b": False},
+            "additionalProperties": False,
+        }
+        generate_and_check({"a": 42}, schema)
+        check_match_failure(
+            bad_string=json_dumps({"a": 42, "b": 43}),
+            good_bytes=b'{"a": 42',
+            failure_byte=b",",
+            allowed_bytes={b"}"} | INTEGER_FOLLOWING,
+            schema_obj=schema,
+        )
+
+    def test_unsatisfiable_properties_raises(self):
+        schema = {
+            "type": "object",
+            "properties": {"a": {"type": "integer"}, "b": False},
+            "required": ["b"],
+            "additionalProperties": False,
+        }
+        with pytest.raises(ValueError) as ve:
+            _ = gen_json(schema=schema)
+        assert ve.value.args[0] == "Required property 'b' is unsatisfiable"
+        assert (
+            ve.value.__cause__.args[0] == "No valid JSON can be generated from a schema of `false`"
+        )
+
+    def test_unsatisfiable_additional_properties_raises(self):
+        schema = {
+            "type": "object",
+            "properties": {"a": {"type": "integer"}},
+            "required": ["a", "b"],
+            "additionalProperties": False,
+        }
+        with pytest.raises(ValueError) as ve:
+            _ = gen_json(schema=schema)
+        assert (
+            ve.value.args[0]
+            == "Required properties not in properties but additionalProperties is unsatisfiable. Missing required properties: ['b']"
+        )
+        assert (
+            ve.value.__cause__.args[0] == "No valid JSON can be generated from a schema of `false`"
+        )
+
 
 class TestObjectWithMissingRequired:
     def test_required_is_required(self):
@@ -707,7 +792,10 @@ def test_false_additionalProperties_fails(self):
             _ = gen_json(schema=schema)
         assert (
             ve.value.args[0]
-            == "Required properties not in properties but additionalProperties is False. Missing required properties: ['b', 'c']"
+            == "Required properties not in properties but additionalProperties is unsatisfiable. Missing required properties: ['b', 'c']"
+        )
+        assert (
+            ve.value.__cause__.args[0] == "No valid JSON can be generated from a schema of `false`"
         )
 
 
@@ -798,6 +886,60 @@ def test_bad_object(self, bad_string, good_bytes, failure_byte, allowed_bytes):
             schema_obj=schema_obj,
         )
 
+    def test_unsatisfiable_prefixItem_ok(self):
+        schema = {"type": "array", "prefixItems": [{"type": "integer"}, False]}
+        generate_and_check([42], schema)
+        check_match_failure(
+            bad_string="[42, 43]",
+            good_bytes=b"[42",
+            failure_byte=b",",
+            allowed_bytes={b"]"} | INTEGER_FOLLOWING,
+            schema_obj=schema,
+        )
+
+    def test_unsatisfiable_prefixItem_raises(self):
+        schema = {
+            "type": "array",
+            "prefixItems": [{"type": "integer"}, False],
+            "minItems": 2,
+        }
+        with pytest.raises(ValueError) as ve:
+            _ = gen_json(schema=schema)
+        assert ve.value.args[0] == "prefixItems[1] is unsatisfiable but min_items is 2"
+        assert (
+            ve.value.__cause__.args[0] == "No valid JSON can be generated from a schema of `false`"
+        )
+
+    def test_unsatisfiable_items_ok(self):
+        schema = {
+            "type": "array",
+            "prefixItems": [{"type": "integer"}],
+            "items": {"allOf": [{"type": "integer"}, False]},
+        }
+        generate_and_check([42], schema)
+        check_match_failure(
+            bad_string="[42, 43]",
+            good_bytes=b"[42",
+            failure_byte=b",",
+            allowed_bytes={b"]"} | INTEGER_FOLLOWING,
+            schema_obj=schema,
+        )
+
+    def test_unsatisfiable_items_raises(self):
+        schema = {
+            "type": "array",
+            "prefixItems": [{"type": "integer"}],
+            "items": {"allOf": [{"type": "integer"}, False]},
+            "minItems": 2,
+        }
+        with pytest.raises(ValueError) as ve:
+            _ = gen_json(schema=schema)
+        assert (
+            ve.value.args[0]
+            == "prefixItems has too few elements (1) to satisfy minItems (2) but item schema is unsatisfiable"
+        )
+        assert ve.value.__cause__.args[0] == "allOf contains a 'false' schema"
+
 
 class TestArrayWithLengthConstraints:
     prefix_schema_obj = [{"type": "integer"}, {"type": "boolean"}]
@@ -1082,6 +1224,12 @@ def test_bad_with_items(
             schema_obj=schema_obj,
         )
 
+    def test_unsatisfiable_length(self):
+        schema = {"type": "array", "minItems": 10, "maxItems": 5}
+        with pytest.raises(ValueError) as ve:
+            _ = gen_json(schema=schema)
+        assert ve.value.args[0] == "minItems (10) is greater than maxItems (5)"
+
 
 class TestAnyOf:
     @pytest.mark.parametrize("target_obj", [123, True])
@@ -1166,6 +1314,21 @@ def test_anyOf_objects(self, target_obj, temperature):
         # The actual check
         generate_and_check(target_obj, schema_obj, desired_temperature=temperature)
 
+    def test_anyOf_unsatisfiable_ok(self):
+        schema = {"anyOf": [{"type": "integer"}, False]}
+        generate_and_check(3, schema)
+
+    def test_anyOf_unsatisfiable_raises(self):
+        schema = {
+            "anyOf": [{"type": "integer", "minimum": 10, "maximum": 0}, False],
+        }
+        with pytest.raises(ValueError) as ve:
+            _ = gen_json(schema=schema)
+        assert (
+            ve.value.args[0]
+            == 'all anyOf schemas are unsatisfiable: [{"type": "integer", "minimum": 10, "maximum": 0}, false]'
+        )
+
 
 class TestAllOf:
     @pytest.mark.parametrize(
@@ -1224,24 +1387,11 @@ def test_allOf_ref(self):
         generate_and_check(target_obj, schema_obj)
 
     def test_allOf_bad_schema(self):
-        schema = """{
-        "allOf" : [{ "type": "integer" }, { "type": "number" }]
-        }
-        """
-        # First sanity check what we're setting up
-        schema_obj = json.loads(schema)
-
-        TARGET_VALUE = 20
-        validate(instance=TARGET_VALUE, schema=schema_obj)
-
-        prepared_string = f"<s>{json_dumps(TARGET_VALUE)}"
-        lm = models.Mock(prepared_string.encode())
-
-        # Run with the mock model
-        CAPTURE_KEY = "my_capture"
+        schema = {"allOf": [{"type": "integer"}, {"type": "string"}]}
         with pytest.raises(ValueError) as ve:
-            lm += gen_json(name=CAPTURE_KEY, schema=schema_obj)
-        assert ve.value.args[0] == "Only support allOf with exactly one item"
+            _ = gen_json(schema=schema)
+        assert ve.value.args[0] == "allOf has conflicting types: [{'integer'}, {'string'}]"
+
 
 
 class TestOneOf:
@@ -1377,7 +1527,7 @@ def test_invalid_typed_enum(self):
         schema_obj = {"enum": [1, "2"], "type": "boolean"}
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
-        assert ve.value.args[0] == "No valid options found for enum with type 'boolean': [1, '2']"
+        assert ve.value.args[0] == f"All enum options {[1, '2']} are inconsistent with parent schema: {schema_obj}"
 
 
 class TestConst:
@@ -1446,8 +1596,9 @@ def test_valid_typed_const(self):
 
     def test_invalid_typed_const(self):
         schema_obj = {"const": 1, "type": "boolean"}
-        with pytest.raises(ValidationError):
+        with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
+        assert ve.value.args[0] == f"const {1!r} is inconsistent with parent schema: {schema_obj}"
 
     def test_valid_enum_const(self):
         schema_obj = {"const": 1, "enum": [1, 2, 3]}
@@ -1457,8 +1608,9 @@ def test_valid_enum_const(self):
 
     def test_invalid_enum_const(self):
         schema_obj = {"const": 1, "enum": [2, 3]}
-        with pytest.raises(ValidationError):
+        with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
+        assert ve.value.args[0] == f"const {1!r} is inconsistent with parent schema: {schema_obj}"
 
     def test_valid_typed_enum_const(self):
         schema_obj = {"const": 1, "enum": [1, "2", 3], "type": "integer"}
@@ -1476,8 +1628,12 @@ def test_valid_typed_enum_const(self):
     )
     def test_invalid_typed_enum_const(self, const):
         schema_obj = {"const": const, "enum": [1, "2", 3], "type": "integer"}
-        with pytest.raises(ValidationError):
+        with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
+        assert (
+            ve.value.args[0]
+            == f"const {const!r} is inconsistent with parent schema: {schema_obj}"
+        )
 
 
 class TestAdditionalProperties:
@@ -2157,17 +2313,21 @@ def test_true_schema(self, target_obj):
         schema_obj = True
         generate_and_check(target_obj, schema_obj)
 
-    @pytest.mark.parametrize(
-        "schema_obj",
-        [
-            False,
-            {"type": "object", "properties": {"a": False}, "required": ["a"]},
-        ],
-    )
-    def test_false_schema(self, schema_obj):
+    def test_false_schema(self):
+        schema_obj = False
+        with pytest.raises(ValueError) as ve:
+            gen_json(schema=schema_obj)
+        assert ve.value.args[0] == "No valid JSON can be generated from a schema of `false`"
+
+    def test_false_required_property(self):
+        schema_obj = {"type": "object", "properties": {"a": False}, "required": ["a"]}
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
-        assert ve.value.args[0] == "No valid JSON can be generated from a schema of `False`"
+        assert ve.value.args[0] == "Required property 'a' is unsatisfiable"
+        assert (
+            ve.value.__cause__.args[0] == "No valid JSON can be generated from a schema of `false`"
+        )
+
 
 
 class TestWhitespace:
diff --git a/tests/unit/library/json/test_refs.py b/tests/unit/library/json/test_refs.py
index 50a2b4a92..db695cc7e 100644
--- a/tests/unit/library/json/test_refs.py
+++ b/tests/unit/library/json/test_refs.py
@@ -155,7 +155,6 @@ def test_nested_refs(self, test_object, valid):
             ({"foo": "string"}, False),
         ],
     )
-    @pytest.mark.xfail(reason="sibling keywords to ref are not yet supported")
     def test_ref_applies_alongside_sibling_keywords(self, test_object, valid):
         schema = {
             "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -442,10 +441,15 @@ def test_naive_replacement_of_ref_with_its_destination_is_not_correct(
             # invalid on outer field
             ({"foo": {"bar": "a"}, "bar": 1}, False),
             # valid on both fields
-            ({"foo": {"bar": "a"}, "bar": "a"}, True),
+            (
+                {
+                    "foo": {"bar": "a"},
+                    "bar": "a",
+                },
+                True,
+            ),
         ],
     )
-    @pytest.mark.xfail(reason="refs with sibling keywords are not yet supported")
     def test_refs_with_relative_uris_and_defs(self, test_object, valid):
         schema = {
             "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -478,7 +482,6 @@ def test_refs_with_relative_uris_and_defs(self, test_object, valid):
             ({"foo": {"bar": "a"}, "bar": "a"}, True),
         ],
     )
-    @pytest.mark.xfail(reason="refs with sibling keywords are not yet supported")
     def test_relative_refs_with_absolute_uris_and_defs(self, test_object, valid):
         schema = {
             "$schema": "https://json-schema.org/draft/2020-12/schema",
diff --git a/tests/unit/library/json/utils.py b/tests/unit/library/json/utils.py
index ffbbe3b5f..5498d718c 100644
--- a/tests/unit/library/json/utils.py
+++ b/tests/unit/library/json/utils.py
@@ -2,7 +2,7 @@
 from functools import partial
 from json import dumps as json_dumps
 from json import loads as json_loads
-from typing import Any, Optional, Set, Union
+from typing import Any, Optional, Union
 
 from jsonschema import validate
 
@@ -46,7 +46,7 @@ def check_match_failure(
     bad_string: str,
     good_bytes: Optional[bytes] = None,
     failure_byte: Optional[bytes] = None,
-    allowed_bytes: Optional[Set[bytes]] = None,
+    allowed_bytes: Optional[set[bytes]] = None,
     schema_obj: Union[str, JSONSchema],
 ):
     grammar = gen_json(schema=schema_obj)

From ed9f0781230ef7f309e45e1d856a2f2a22f6f93e Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Wed, 6 Nov 2024 16:40:38 -0800
Subject: [PATCH 10/30] [BUG] Reset role blocks when `model.reset` is called
 (#1073)

Empties the dict of open role blocks when `model.reset` is called.
Should close #1071
---
 guidance/models/_model.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/guidance/models/_model.py b/guidance/models/_model.py
index e4e08d0ff..f6529d331 100644
--- a/guidance/models/_model.py
+++ b/guidance/models/_model.py
@@ -378,6 +378,7 @@ def reset(self, clear_variables=True):
             If we should clear all the model object's variables in addition to reseting the byte state.
         """
         self._state = self._state[:0]
+        self.opened_blocks = {}
         if clear_variables:
             self._variables = {}
             self._variables_log_probs = {}

From b6bcee7f26957bf3ebb67ce25cf824807dff789b Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Sun, 10 Nov 2024 13:28:50 -0800
Subject: [PATCH 11/30] [Optimization] Advance parser concurrently with model
 forward pass (#1065)

Refactors `Engine.__call__` and `TokenParser._parse` coroutine/generator
to yield a _future_ wrapping `LLInterpreter.mid_process` (running in a
`ThreadPoolExecutor`) such that `mid_process` can run concurrently with
the forward pass. This function comes directly from the rust extension,
so it releases the GIL and threading *should* be sufficient to ensure
true concurrency.

---------

Co-authored-by: Loc Huynh <lohuynh@microsoft.com>
---
 guidance/_parser.py                   | 134 ++++++++++++++++----------
 guidance/models/_mock.py              |   4 +-
 guidance/models/_model.py             | 102 ++++++++++++++------
 setup.py                              |   2 +-
 tests/model_integration/test_model.py |  10 +-
 5 files changed, 166 insertions(+), 86 deletions(-)

diff --git a/guidance/_parser.py b/guidance/_parser.py
index e6a22671d..910315feb 100644
--- a/guidance/_parser.py
+++ b/guidance/_parser.py
@@ -1,6 +1,7 @@
 import json
 import os
-from typing import Any, Generator, Optional, Tuple, Union
+from typing import Any, Generator, Optional, Union
+from concurrent.futures import ThreadPoolExecutor, Future
 
 import llguidance  # type: ignore[import-untyped]
 import numpy as np
@@ -11,7 +12,6 @@
 from .models._byte_tokenizer import ByteTokenizer
 from .models._tokenizer import Tokenizer
 
-
 class TokenParserException(Exception):
     pass
 
@@ -52,8 +52,10 @@ def __init__(
             serialized_grammar,
             log_level=int(os.environ.get("LLGUIDANCE_LOG_LEVEL", "1")),
         )
+        self._threadpool = ThreadPoolExecutor(max_workers=1)
         self._generator = self._parse(prompt, ensure_bos_token)
         self._done = False
+        self._has_pending_stop = False
 
     def is_accepting(self) -> bool:
         return self.ll_interpreter.is_accepting()
@@ -63,12 +65,13 @@ def done(self) -> bool:
 
     def advance(
         self, token: Optional[int]
-    ) -> Tuple[Optional[GenData], EngineCallResponse]:
-        try:
-            return self._generator.send(token)
-        except StopIteration as e:
-            self._done = True
-            return None, e.value
+    ) -> tuple[list[int], Future[tuple[Optional[bytes], LLInterpreterResponse]]]:
+        if self.done():
+            raise TokenParserException("Cannot advance on a done parser")
+        return self._generator.send(token)
+
+    def has_pending_stop(self) -> bool:
+        return self._has_pending_stop
 
     def _process_prompt(self, prompt: bytes, ensure_bos_token: bool) -> list[int]:
         prompt_tokens = self.ll_interpreter.process_prompt(
@@ -84,55 +87,78 @@ def _process_prompt(self, prompt: bytes, ensure_bos_token: bool) -> list[int]:
 
         return self.tokenizer.recode(prompt_tokens)
 
+    def mid_process(self) -> tuple[Optional[bytes], LLInterpreterResponse]:
+        mask, ll_response_string = self.ll_interpreter.mid_process()
+        ll_response = LLInterpreterResponse.model_validate_json(ll_response_string)
+        return mask, ll_response
 
     def _parse(
         self,
         prompt: bytes,
         ensure_bos_token: bool,
-    ) -> Generator[Tuple[Optional[GenData], EngineCallResponse], Optional[int], EngineCallResponse]:
+    ) -> Generator[
+            tuple[
+                list[int],
+                Future[tuple[Optional[bytes], LLInterpreterResponse]],
+            ],
+            Optional[int],
+            None
+        ]:
         tokens = self._process_prompt(prompt=prompt, ensure_bos_token=ensure_bos_token)
 
         while True:
-            mask, resp = self.ll_interpreter.mid_process()
-            r = LLInterpreterResponse.model_validate_json(resp)
-            response = r.progress.to_engine_call_response()
-            if r.stop:
+            # Note: need to call/set has_pending_stop before spinning up the mid_process future
+            # as the two methods cannot be called concurrently
+            self._has_pending_stop = self.ll_interpreter.has_pending_stop()
+            mid_process_future = self._threadpool.submit(self.mid_process)
+            token = yield (tokens, mid_process_future)
+
+            # Upstairs should have already waited on this future
+            mask, ll_response = mid_process_future.result()
+
+            if ll_response.stop:
+                # This is the only case in which the mask is None
+                assert mask is None
+                # If we're done, our caller should NOT send us a token
+                if token is not None:
+                    raise TokenParserException(f"Expected None, got token {token}")
+                self._done = True
                 break
 
-            if mask is not None:
-                assert r.temperature is not None
-                gen_data = GenData(
-                    tokens=tokens,
-                    mask=mask,
-                    temperature=r.temperature,
+            assert mask is not None
+            if token is None:
+                raise TokenParserException("Expected token, got None")
+            if not mask[token]:
+                # Note: we could punt this probem to ll_interpreter.post_process,
+                # but it's a bit clearer to handle it here
+                raise InvalidTokenException(
+                    token=token,
+                    valid_tokens=[i for i in range(len(mask)) if mask[i]],
+                    prompt_tokens=tokens
                 )
-                # Send caller the mask and response; wait for token
-                token = yield (gen_data, response)
-                if token is None:
-                    raise TokenParserException("Expected token, got None")
-                if not mask[token]:
-                    # Note: we could punt this probem to ll_interpreter.post_process,
-                    # but it's a bit clearer to handle it here
-                    raise InvalidTokenException(token, gen_data.valid_next_tokens, tokens)
-            else:
-                gen_data = None
-                token = yield (gen_data, response)
-                if token is not None:
-                    raise TokenParserException(f"Expected None, got token {token}")
 
             backtrack, ff_tokens = self.ll_interpreter.post_process(token)
             if backtrack:
                 tokens = tokens[:-backtrack]
             tokens = tokens + ff_tokens
 
+    def cleanup(self):
+        # Rather than having our caller send us None at the end, we'll handle that internally
+        # so we can (1) verify that the generator actually stops and (2) check the stop reason
+        # and raise if needed
+        if not self.done():
+            try:
+                self._generator.send(None)
+            except StopIteration:
+                pass
+        if not self.done():
+            raise TokenParserException("Tried to cleanup but parser is not done")
         stop_reason = self.ll_interpreter.stop_reason()
         if stop_reason not in {"NoExtension", "EndOfSentence"}:
-            # TODO: extend exception handling
+            # Will raise if there is some "bad" stop reason (like hit token limit) OR we're NOT stopped.
+            # TODO: raise specific exceptions for reasons such as MaxTokensTotal
             raise TokenParserException(f"Unexpected stop reason: {stop_reason}")
 
-        return response
-
-
 class ByteParserException(Exception):
     def __init__(self, *args, **kwargs):
         self.current_byte = kwargs.pop("current_byte", None)
@@ -155,6 +181,8 @@ def __init__(
         self.pos = 0
         self._variables: dict[str, Any] = {}
         self._variables_log_probs: dict[str, Any] = {}
+        # Prime the parser
+        self._advance(None)
         self.consume_bytes(prompt)
 
     def matched(self) -> bool:
@@ -179,14 +207,26 @@ def next_byte_mask(self) -> NDArray[np.uint8]:
             mask[t[0]] = 1
         return mask
 
-    def consume_bytes(self, bts: bytes) -> None:
-        # Run underlying ll_parser and fast-forward all of our bytes
-        # until we have a "choice" (generation step) to make
-        while self.gen_data is None and not self.token_parser.done():
-            self.gen_data, response = self.token_parser.advance(None)
-            self._update_capture(response)
-            self.bytes += response.new_bytes
+    def _advance(self, token: Optional[int]) -> None:
+        tokens, mid_process_fut = self.token_parser.advance(token)
+        mask, ll_response = mid_process_fut.result()
+        if ll_response.stop:
+            assert mask is None
+            self.token_parser.cleanup()
+            self.gen_data = None
+        else:
+            assert mask is not None
+            assert ll_response.temperature is not None
+            self.gen_data = GenData(
+                tokens=tokens,
+                mask=mask,
+                temperature=ll_response.temperature,
+            )
+        response = ll_response.progress.to_engine_call_response()
+        self._update_capture(response)
+        self.bytes += response.new_bytes
 
+    def consume_bytes(self, bts: bytes) -> None:
         if not bts:
             return
 
@@ -228,9 +268,7 @@ def consume_bytes(self, bts: bytes) -> None:
                     consumed_bytes=self.bytes[: self.pos],
                 )
             # Byte was good, have ll_parser consume it so we can advance further
-            self.gen_data, response = self.token_parser.advance(b)
-            self._update_capture(response)
-            self.bytes += response.new_bytes
+            self._advance(b)
 
             # Run consume_bytes to advance ll_parser and consume the next byte
             self.consume_bytes(bts)
@@ -241,9 +279,7 @@ def force_done(self):
         if self.token_parser.done():
             return
 
-        self.gen_data, response = self.token_parser.advance(self.tokenizer.eos_token_id)
-        self._update_capture(response)
-        self.bytes += response.new_bytes
+        self._advance(self.tokenizer.eos_token_id)
         if not self.token_parser.done() or not self.matched():
             raise ByteParserException("Hit end of input before reaching a valid state")
 
diff --git a/guidance/models/_mock.py b/guidance/models/_mock.py
index 0f1e48b41..a2ae59a3a 100644
--- a/guidance/models/_mock.py
+++ b/guidance/models/_mock.py
@@ -80,9 +80,9 @@ def __init__(self, tokenizer, byte_patterns, compute_log_probs, force):
         # seed the random number generator
         self._rand_generator = np.random.default_rng(seed=42)
 
-    def get_next_token(self, token_ids: list[int], mask: Optional[bytes], temperature: float) -> int:
+    def sample_with_temperature(self, logits, mask, temperature):
         self.called_temperatures.append(temperature)
-        return super().get_next_token(token_ids, mask, temperature)
+        return super().sample_with_temperature(logits, mask, temperature)
 
     def get_logits(self, token_ids: list[int]) -> np.ndarray:
         """Pretends to compute the logits for the given token state."""
diff --git a/guidance/models/_model.py b/guidance/models/_model.py
index f6529d331..97bb48bb3 100644
--- a/guidance/models/_model.py
+++ b/guidance/models/_model.py
@@ -133,42 +133,86 @@ def __call__(self, prompt, grammar, ensure_bos_token=True) -> Iterator[EngineCal
         """
         parser = self.start(prompt, grammar, ensure_bos_token)
 
+        has_get_logits = True
         token = None
-        while not parser.done():
-            gen_data, response = parser.advance(token)
-
-            if gen_data is not None:
-                if parser.is_accepting() and self.tokenizer.eos_token_id is not None:
-                    # Whenever we are in an accepting state, we will allow the model to generate whatever it wants
-                    # but we will treat any "illegal" tokens as EOS, allowing the model to finish gracefully.
-                    assert gen_data.mask[self.tokenizer.eos_token_id]
-                    token = self.get_next_token(
-                        token_ids=gen_data.tokens,
-                        mask=None,
-                        temperature=gen_data.temperature
-                    )
-                    if not gen_data.mask[token]:
-                        token = self.tokenizer.eos_token_id
-                else:
-                    token = self.get_next_token(
-                        token_ids=gen_data.tokens,
-                        mask=gen_data.mask,
-                        temperature=gen_data.temperature
-                    )
+        while True:
+            tokens, mid_process_fut = parser.advance(token)
+
+            # Note that has_pending_stop implies that the response is a stop response,
+            # but the converse is not true. We can therefore avoid some (but not all)
+            # unnecessary calls to get_logits on the final iteration.
+            has_pending_stop = parser.has_pending_stop()
+
+            if has_get_logits and not has_pending_stop:
+                try:
+                    logits = self.get_logits(token_ids=tokens)
+                except NotImplementedError:
+                    # Permanently fall-back to get_next_token if get_logits is not implemented
+                    has_get_logits = False
+                    logits = None
             else:
-                token = None
+                logits = None
+
+            # Important: don't wait on this future until after getting the logits;
+            # this allows the mask to be built concurrently with model inference
+            mask, ll_response = mid_process_fut.result()
+
+            engine_response = ll_response.progress.to_engine_call_response()
+            yield engine_response
+
+            if ll_response.stop:
+                assert mask is None
+                # May raise an exception if the parser is in an bad state!
+                parser.cleanup()
+                # Ensure we break AFTER yielding the final response
+                break
+
+            # If there was a pending stop, we should have broken out of the loop
+            assert not has_pending_stop
+
+            # Help the type checker: assert that everything we need to get the next token is not None
+            assert mask is not None
+            assert ll_response.temperature is not None
+
+            can_finish_early = parser.is_accepting() and self.tokenizer.eos_token_id is not None
+
+            if can_finish_early:
+                # Type checker needs some help
+                assert self.tokenizer.eos_token_id is not None
+                # Should be equivalent to parser.is_accepting()
+                assert mask[self.tokenizer.eos_token_id]
+                # Whenever we are in an accepting state, we will allow the model to generate whatever it wants
+                # but we will treat any "illegal" tokens as EOS, allowing the model to finish gracefully.
+                # Hence, mask must be None
+                mask_for_sampling = None
+            else:
+                mask_for_sampling = mask
+
+            if logits is not None:
+                token = self.sample_with_temperature(
+                    logits=logits,
+                    mask=mask_for_sampling,
+                    temperature=ll_response.temperature,
+                )
+            else:
+                token = self.get_next_token(
+                    tokens,
+                    mask_for_sampling,
+                    ll_response.temperature
+                )
+
+            if can_finish_early and not mask[token]:
+                # Type checker needs some help
+                assert self.tokenizer.eos_token_id is not None
+                token = self.tokenizer.eos_token_id
 
-            yield response
 
     def get_next_token(self, token_ids: list[int], mask: Optional[bytes], temperature: float) -> int:
-        """Base implementation for getting the next token from the model which calls get_logits and sample_with_temperature.
-        Subclasses may override this method, e.g. if they use external APIs that do not support getting logits directly.
-        """
-        logits = self.get_logits(token_ids)
-        token = self.sample_with_temperature(logits, mask, temperature)
-        return token
+        # Prefer to implement get_logits over get_next_token as it allows for concurrent mask computation
+        raise NotImplementedError
 
     def get_logits(self, token_ids: list[int]) -> np.ndarray:
+        # Prefer to implement get_logits over get_next_token as it allows for concurrent mask computation
         raise NotImplementedError
 
     def sample_with_temperature(self, logits: np.ndarray, mask: Optional[bytes], temperature: float) -> int:
diff --git a/setup.py b/setup.py
index 45290dcf1..c8b801566 100644
--- a/setup.py
+++ b/setup.py
@@ -29,7 +29,7 @@
     "referencing",
     "requests",
     "tiktoken>=0.3",
-    "llguidance>=0.1.7",
+    "llguidance>=0.3.0",
 ]
 
 # Our basic list of 'extras'
diff --git a/tests/model_integration/test_model.py b/tests/model_integration/test_model.py
index 2b6a2489c..b02b719bc 100644
--- a/tests/model_integration/test_model.py
+++ b/tests/model_integration/test_model.py
@@ -74,18 +74,18 @@ def test_associativity(selected_model: models.Model):
     REMOTE_MODELS = [models.AzureGuidance]
     for rm in REMOTE_MODELS:
         if isinstance(selected_model, rm):
-            pytest.skip("Method get_next_token not available for remote models")
+            pytest.skip("Method get_logits not available for remote models")
     prompt = "pi = "
     grammar = gen("number", regex=r"\d")
     engine = selected_model.engine
 
-    with patch.object(engine, "get_next_token", side_effect=engine.get_next_token) as get_next_token_1:
+    with patch.object(engine, "get_logits", side_effect=engine.get_logits) as get_logits_1:
         _ = selected_model + (prompt + grammar)
-    prompt_tokens_1 = get_next_token_1.call_args.kwargs["token_ids"]
+    prompt_tokens_1 = get_logits_1.call_args_list[0].kwargs["token_ids"]
 
-    with patch.object(engine, "get_next_token", side_effect=engine.get_next_token) as get_next_token_2:
+    with patch.object(engine, "get_logits", side_effect=engine.get_logits) as get_logits_2:
         _ = (selected_model + prompt) + grammar
-    prompt_tokens_2 = get_next_token_2.call_args.kwargs["token_ids"]
+    prompt_tokens_2 = get_logits_2.call_args_list[0].kwargs["token_ids"]
 
     # Main assertion: the prompt tokens should be the same
     assert prompt_tokens_1 == prompt_tokens_2

From fec647ead77ab23840277cf8cd38eda6d442742c Mon Sep 17 00:00:00 2001
From: Matthias Cullmann <matthias.cullmann@gmail.com>
Date: Sun, 10 Nov 2024 22:29:39 +0100
Subject: [PATCH 12/30] Update README.md (#1045)

FIX typo
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 6b5001975..78abd4b09 100644
--- a/README.md
+++ b/README.md
@@ -714,7 +714,7 @@ character_lm = lm + character_maker(1, 'A nimble fighter', ['axe', 'sword', 'bow
 ```
 
 ### Vertex AI
-Remote endpoints that don't have explicit guidance integration are run "optimistically". This means that all the text that can be forced is given to the model as a prompt (or chat context) and then the model is run in streaming mode without hard constrants (since the remote API doesn't support them). If the model ever violates the contraints then the model stream is stopped and we optionally try it again at that point. This means that all the API-supported control work as expected, and more complex controls/parsing that is not supported by the API work if the model stays consistent with the program.
+Remote endpoints that don't have explicit guidance integration are run "optimistically". This means that all the text that can be forced is given to the model as a prompt (or chat context) and then the model is run in streaming mode without hard constraints (since the remote API doesn't support them). If the model ever violates the contraints then the model stream is stopped and we optionally try it again at that point. This means that all the API-supported control work as expected, and more complex controls/parsing that is not supported by the API work if the model stays consistent with the program.
 ```python
 palm2 = models.VertexAI("text-bison@001")
 

From 21b5a1b9c36763e17a8d857d4c258a9227cfac32 Mon Sep 17 00:00:00 2001
From: Xuan-Rui Fan <serfinxx@gmail.com>
Date: Mon, 11 Nov 2024 05:30:00 +0800
Subject: [PATCH 13/30] [Feature] Add qwen2.5 chat templates (#1066)

Add chat template support for qwen2.5 base language models and
instruction tuned models ranging from 0.5 to 72 billion parameters.
---
 guidance/chat.py                              | 27 +++++++++++++++++++
 tests/_llms_for_testing.py                    | 16 +++++++++++
 tests/need_credentials/test_chat_templates.py |  4 +++
 3 files changed, 47 insertions(+)

diff --git a/guidance/chat.py b/guidance/chat.py
index 7b3bd37f8..2908458dc 100644
--- a/guidance/chat.py
+++ b/guidance/chat.py
@@ -299,3 +299,30 @@ def get_role_end(self, role_name=None):
 
 
 CHAT_TEMPLATE_CACHE[gemma2_9b_it_template] = Gemma29BInstructChatTemplate
+
+# --------------------------------------------------
+# @@@@ Qwen2.5 @@@@
+# --------------------------------------------------
+# From https://huggingface.co/Qwen/Qwen2.5-0.5B/blob/060db6499f32faf8b98477b0a26969ef7d8b9987/tokenizer_config.json#L198
+qwen2dot5_template = "{%- if tools %}\n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- messages[0]['content'] }}\n    {%- else %}\n        {{- 'You are a helpful assistant.' }}\n    {%- endif %}\n    {{- \"\\n\\n# Tools\\n\\nYou may call one or more functions to assist with the user query.\\n\\nYou are provided with function signatures within <tools></tools> XML tags:\\n<tools>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- \"\\n</tools>\\n\\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\\n<tool_call>\\n{\\\"name\\\": <function-name>, \\\"arguments\\\": <args-json-object>}\\n</tool_call><|im_end|>\\n\" }}\n{%- else %}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- '<|im_start|>system\\n' + messages[0]['content'] + '<|im_end|>\\n' }}\n    {%- else %}\n        {{- '<|im_start|>system\\nYou are a helpful assistant.<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- for message in messages %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) or (message.role == \"assistant\" and not message.tool_calls) %}\n        {{- '<|im_start|>' + message.role + '\\n' + message.content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {{- '<|im_start|>' + message.role }}\n        {%- if message.content %}\n            {{- '\\n' + message.content }}\n        {%- endif %}\n        {%- for tool_call in message.tool_calls %}\n            {%- if tool_call.function is defined %}\n                {%- set tool_call = tool_call.function %}\n            {%- endif %}\n            {{- '\\n<tool_call>\\n{\"name\": \"' }}\n            {{- tool_call.name }}\n            {{- '\", \"arguments\": ' }}\n            {{- tool_call.arguments | tojson }}\n            {{- '}\\n</tool_call>' }}\n        {%- endfor %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != \"tool\") %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- message.content }}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != \"tool\") %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n{%- endif %}\n"
+
+# From https://huggingface.co/Qwen/Qwen2.5-0.5B-Instruct/blob/7ae557604adf67be50417f59c2c2f167def9a775/tokenizer_config.json#L198
+qwen2dot5_it_template = "{%- if tools %}\n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- messages[0]['content'] }}\n    {%- else %}\n        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}\n    {%- endif %}\n    {{- \"\\n\\n# Tools\\n\\nYou may call one or more functions to assist with the user query.\\n\\nYou are provided with function signatures within <tools></tools> XML tags:\\n<tools>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- \"\\n</tools>\\n\\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\\n<tool_call>\\n{\\\"name\\\": <function-name>, \\\"arguments\\\": <args-json-object>}\\n</tool_call><|im_end|>\\n\" }}\n{%- else %}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- '<|im_start|>system\\n' + messages[0]['content'] + '<|im_end|>\\n' }}\n    {%- else %}\n        {{- '<|im_start|>system\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- for message in messages %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) or (message.role == \"assistant\" and not message.tool_calls) %}\n        {{- '<|im_start|>' + message.role + '\\n' + message.content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {{- '<|im_start|>' + message.role }}\n        {%- if message.content %}\n            {{- '\\n' + message.content }}\n        {%- endif %}\n        {%- for tool_call in message.tool_calls %}\n            {%- if tool_call.function is defined %}\n                {%- set tool_call = tool_call.function %}\n            {%- endif %}\n            {{- '\\n<tool_call>\\n{\"name\": \"' }}\n            {{- tool_call.name }}\n            {{- '\", \"arguments\": ' }}\n            {{- tool_call.arguments | tojson }}\n            {{- '}\\n</tool_call>' }}\n        {%- endfor %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != \"tool\") %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- message.content }}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != \"tool\") %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n{%- endif %}\n"
+
+
+class Qwen2dot5ChatTemplate(ChatTemplate):
+    # available_roles = ["system", "user", "assistant"]
+    template_str = qwen2dot5_it_template
+
+    def get_role_start(self, role_name):
+        if role_name in ["system", "user", "assistant"]:
+            return f"<|im_start|>{role_name}\n"
+        else:
+            raise UnsupportedRoleException(role_name, self)
+
+    def get_role_end(self, role_name=None):
+        return "<|im_end|>\n"
+
+
+CHAT_TEMPLATE_CACHE[qwen2dot5_template] = Qwen2dot5ChatTemplate
+CHAT_TEMPLATE_CACHE[qwen2dot5_it_template] = Qwen2dot5ChatTemplate
diff --git a/tests/_llms_for_testing.py b/tests/_llms_for_testing.py
index 4f57af3c3..a228c32fa 100644
--- a/tests/_llms_for_testing.py
+++ b/tests/_llms_for_testing.py
@@ -100,6 +100,21 @@
     ),
 }
 
+_QWEN2DOT5 = {
+    "transformers_qwen2dot5_0dot5b_cpu": dict(
+        name="transformers:Qwen/Qwen2.5-0.5B", kwargs=dict()
+    ),
+    "transformers_qwen2dot5_0dot5b_gpu": dict(
+        name="transformers:Qwen/Qwen2.5-0.5B", kwargs={"device_map": "cuda:0"}
+    ),
+    "transformers_qwen2dot5_0dot5b_instruct_cpu": dict(
+        name="transformers:Qwen/Qwen2.5-0.5B-Instruct", kwargs=dict()
+    ),
+    "transformers_qwen2dot5_0dot5b_instruct_gpu": dict(
+        name="transformers:Qwen/Qwen2.5-0.5B-Instruct", kwargs={"device_map": "cuda:0"}
+    ),
+}
+
 AVAILABLE_MODELS = {
     "azure_guidance": dict(
         name="azure_guidance:",
@@ -115,3 +130,4 @@
 AVAILABLE_MODELS.update(_MISTRAL)
 AVAILABLE_MODELS.update(_PHI_2)
 AVAILABLE_MODELS.update(_PHI_3)
+AVAILABLE_MODELS.update(_QWEN2DOT5)
diff --git a/tests/need_credentials/test_chat_templates.py b/tests/need_credentials/test_chat_templates.py
index 8554d361f..299b87ea8 100644
--- a/tests/need_credentials/test_chat_templates.py
+++ b/tests/need_credentials/test_chat_templates.py
@@ -19,6 +19,8 @@
         ("mistralai/Mistral-7B-Instruct-v0.2", True),  # Mistral-7B-Instruct-v0.2
         ("google/gemma-2-9b-it", True),  # Gemma2
         ("HuggingFaceH4/zephyr-7b-beta", False),  # Have a test for model not in cache
+        ("Qwen/Qwen2.5-0.5B", True),  # Qwen2.5-0.5B
+        ("Qwen2.5-0.5B-Instruct", True),  # Qwen2.5-0.5B-Instruct
     ],
 )
 def test_popular_models_in_cache(model_id: str, should_pass: bool):
@@ -83,6 +85,8 @@ def test_chat_format_smoke(model_id: str):
     [
         "microsoft/Phi-3-mini-4k-instruct",
         "meta-llama/Meta-Llama-3-8B-Instruct",
+        "Qwen/Qwen2.5-0.5B",
+        "Qwen2.5-0.5B-Instruct",
         pytest.param(
             "meta-llama/Llama-2-7b-chat-hf",
             marks=pytest.mark.xfail(

From cfb303dbdf48ca021d943c49226d022eee7fad74 Mon Sep 17 00:00:00 2001
From: Harsha Nori <harsha.nori@live.com>
Date: Sun, 10 Nov 2024 16:44:41 -0800
Subject: [PATCH 14/30] First stage plumbing of fastforward/backtrack tokens.

---
 guidance/_parser.py                           |  4 ++
 guidance/models/_grammarless.py               |  2 +-
 guidance/models/_model.py                     | 44 +++++++++++--------
 guidance/models/llama_cpp/_llama_cpp.py       |  8 +++-
 guidance/models/transformers/_transformers.py |  8 +++-
 tests/model_specific/test_transformers.py     | 26 ++++++++++-
 6 files changed, 70 insertions(+), 22 deletions(-)

diff --git a/guidance/_parser.py b/guidance/_parser.py
index 910315feb..ca4b1405b 100644
--- a/guidance/_parser.py
+++ b/guidance/_parser.py
@@ -34,6 +34,8 @@ def __init__(
         tokenizer: Tokenizer,
         prompt: bytes = b"",
         ensure_bos_token: bool = True,
+        enable_backtrack: bool = True,
+        enable_ff_tokens: bool = True,
     ):
         if isinstance(grammar, GrammarFunction):
             # we can't have a terminal as the root
@@ -50,6 +52,8 @@ def __init__(
         self.ll_interpreter = llguidance.LLInterpreter(
             self.ll_tokenizer,
             serialized_grammar,
+            enable_backtrack,
+            enable_ff_tokens,
             log_level=int(os.environ.get("LLGUIDANCE_LOG_LEVEL", "1")),
         )
         self._threadpool = ThreadPoolExecutor(max_workers=1)
diff --git a/guidance/models/_grammarless.py b/guidance/models/_grammarless.py
index 9a622d426..f24cb81fa 100644
--- a/guidance/models/_grammarless.py
+++ b/guidance/models/_grammarless.py
@@ -171,7 +171,7 @@ def __init__(
                     Using a transformers, tiktoken, or guidance.GrammarlessTokenizer directly will solve this issue."
             )
         # build the Engine
-        super().__init__(tokenizer=tokenizer, compute_log_probs=compute_log_probs)
+        super().__init__(tokenizer=tokenizer, compute_log_probs=compute_log_probs, enable_backtrack=False, enable_ff_tokens=False)
 
         # build a prefix tree of the tokens
         self._token_trie = cpp.ByteTrie(
diff --git a/guidance/models/_model.py b/guidance/models/_model.py
index 97bb48bb3..3aaf3989b 100644
--- a/guidance/models/_model.py
+++ b/guidance/models/_model.py
@@ -30,6 +30,7 @@
 from .._utils import softmax, CaptureEvents
 from .._parser import TokenParser
 from .._grammar import (
+    Function, # for da types, just for you Hudson <3 
     GrammarFunction,
     string,
     _call_pool,
@@ -63,11 +64,22 @@ class Engine:
     Server so a single server can serve many clients' model objects through a single Engine object.
     """
 
-    def __init__(self, tokenizer: Tokenizer, compute_log_probs=False):
+    def __init__(self, tokenizer: Tokenizer, compute_log_probs=False, enable_backtrack=True, enable_ff_tokens=True):
         self.tokenizer = tokenizer
         self.compute_log_probs = compute_log_probs
+        self._enable_backtrack = enable_backtrack
+        self._enable_ff_tokens = enable_ff_tokens
         self.metrics = GuidanceEngineMetrics()
 
+    # These need to be properties because once an Engine is started, you can't change their behavior.
+    @property
+    def enable_backtrack(self):
+        return self._enable_backtrack
+    
+    @property
+    def enable_ff_tokens(self):
+        return self._enable_ff_tokens
+
     def get_chat_template(self): # TODO [HN]: Add more logic here...should we instantiate class here? do we even need to?
         return self.tokenizer.chat_template() # Instantiate the class before returning to client for now
     
@@ -75,19 +87,6 @@ def reset_metrics(self):
         self.metrics = GuidanceEngineMetrics()
 
     def start(self, prompt, grammar, ensure_bos_token=True) -> TokenParser:
-        """Start processing parser state executed through the grammar.
-
-        Parameters
-        ----------
-        prompt : str or Parser
-            This is represents the current state of a guidance parser that will be extended
-            using the passed grammar. If a string is given then we assume the previous parser
-            state is just a fixed string prompt, if a full Parser is given then we extend that
-            parser by appending the new grammar to the parser's current grammar and then
-            inferencing the model. (TODO: implement full parser extension support)
-        grammar: Grammar
-            This is the grammar we are extending the prompt with.
-        """
         # def __call__(self, grammar, max_tokens=1000000, n=1, top_p=1, temperature=0.0, ensure_bos_token=True):
         # assert n == 1, "Still need to add support for n > 1!"
 
@@ -113,10 +112,17 @@ def start(self, prompt, grammar, ensure_bos_token=True) -> TokenParser:
             grammar=grammar,
             tokenizer=self.tokenizer,
             prompt=prompt,
-            ensure_bos_token=ensure_bos_token
+            ensure_bos_token=ensure_bos_token,
+            enable_backtrack=self.enable_backtrack,
+            enable_ff_tokens=self.enable_ff_tokens,
         )
 
-    def __call__(self, prompt, grammar, ensure_bos_token=True) -> Iterator[EngineCallResponse]:
+    def __call__(
+            self, 
+            prompt: Union[str, TokenParser], 
+            grammar: Function,
+            ensure_bos_token: bool = True, 
+        ) -> Iterator[EngineCallResponse]:
         """Main entry point for the inference-parser loop. Yields EngineCallResponse objects as
         the parser advances through the grammar.
 
@@ -128,8 +134,10 @@ def __call__(self, prompt, grammar, ensure_bos_token=True) -> Iterator[EngineCal
             state is just a fixed string prompt, if a full Parser is given then we extend that
             parser by appending the new grammar to the parser's current grammar and then
             inferencing the model. (TODO: implement full parser extension support)
-        grammar: Grammar
-            This is the grammar we are extending the prompt with.
+        grammar: Function
+            Grammar (RawFunction or GrammarFunction) used to extend the prompt.
+        ensure_bos_token: bool
+            Ensures that the prompt ends with the BOS token.
         """
         parser = self.start(prompt, grammar, ensure_bos_token)
 
diff --git a/guidance/models/llama_cpp/_llama_cpp.py b/guidance/models/llama_cpp/_llama_cpp.py
index ee000d14a..3e0b7aa85 100644
--- a/guidance/models/llama_cpp/_llama_cpp.py
+++ b/guidance/models/llama_cpp/_llama_cpp.py
@@ -100,7 +100,7 @@ def encode(self, byte_string: bytes) -> list[int]:
 class LlamaCppEngine(Engine):
     """The core class that runs inference using llama.cpp."""
 
-    def __init__(self, model, compute_log_probs, chat_template=None, **kwargs):
+    def __init__(self, model, compute_log_probs, chat_template=None, enable_backtrack=True, enable_ff_tokens=True, **kwargs):
         if not is_llama_cpp:
             raise Exception(
                 "Please install llama-cpp-python with `pip install llama-cpp-python` in order to use guidance.models.LlamaCpp!"
@@ -149,6 +149,8 @@ def __init__(self, model, compute_log_probs, chat_template=None, **kwargs):
         super().__init__(
             LlamaCppTokenizer(self.model_obj, chat_template=chat_template),
             compute_log_probs=compute_log_probs,
+            enable_backtrack=enable_backtrack,
+            enable_ff_tokens=enable_ff_tokens,
         )
 
         self._n_vocab = len(self.tokenizer.tokens)
@@ -226,6 +228,8 @@ def __init__(
         compute_log_probs=False,
         api_key=None,
         chat_template=None,
+        enable_backtrack=True,
+        enable_ff_tokens=True,
         **llama_cpp_kwargs,
     ):
         """Build a new LlamaCpp model object that represents a model in a given state."""
@@ -237,6 +241,8 @@ def __init__(
                 model,
                 compute_log_probs=compute_log_probs,
                 chat_template=chat_template,
+                enable_backtrack=enable_backtrack,
+                enable_ff_tokens=enable_ff_tokens,
                 **llama_cpp_kwargs,
             )
 
diff --git a/guidance/models/transformers/_transformers.py b/guidance/models/transformers/_transformers.py
index d454bda2d..b33422588 100644
--- a/guidance/models/transformers/_transformers.py
+++ b/guidance/models/transformers/_transformers.py
@@ -371,7 +371,7 @@ def recode(self, tokens: Sequence[int]) -> list[int]:
 
 
 class TransformersEngine(Engine):
-    def __init__(self, model, tokenizer, compute_log_probs: bool, chat_template=None, **kwargs):
+    def __init__(self, model, tokenizer, compute_log_probs: bool, chat_template=None, enable_backtrack=True, enable_ff_tokens=True, **kwargs):
         # fill in default model value
         if model is None:
             model = os.environ.get("TRANSFORMERS_MODEL", None)
@@ -413,6 +413,8 @@ def __init__(self, model, tokenizer, compute_log_probs: bool, chat_template=None
         super().__init__(
             my_tokenizer,
             compute_log_probs=compute_log_probs,
+            enable_backtrack=enable_backtrack,
+            enable_ff_tokens=enable_ff_tokens
         )
 
     def _model(self, model, **kwargs):
@@ -524,6 +526,8 @@ def __init__(
         echo=True,
         compute_log_probs=False,
         chat_template=None,
+        enable_backtrack=True,
+        enable_ff_tokens=True,
         **kwargs,
     ):
         """Build a new Transformers model object that represents a model in a given state."""
@@ -533,6 +537,8 @@ def __init__(
                 tokenizer,
                 compute_log_probs,
                 chat_template=chat_template,
+                enable_backtrack=enable_backtrack,
+                enable_ff_tokens=enable_ff_tokens,
                 **kwargs,
             ),
             echo=echo,
diff --git a/tests/model_specific/test_transformers.py b/tests/model_specific/test_transformers.py
index 2b744e925..d8bad37cc 100644
--- a/tests/model_specific/test_transformers.py
+++ b/tests/model_specific/test_transformers.py
@@ -1,6 +1,6 @@
 import pytest
 
-from guidance import gen, select, models, assistant, system, user
+from guidance import gen, select, models, assistant, system, user, guidance
 
 from ..utils import get_model
 
@@ -27,6 +27,30 @@ def test_gpt2():
 
     assert len(str(lm)) > len("this is a test")
 
+def test_gpt2_fastforward(): # TODO [HN]: figure out how all the get_model and fixture stuff works
+    @guidance
+    def ff_prompt(lm):
+        big_opts = [
+            "Lorem ipsum dolor sit amet",
+            "Duis aute irure dolor "
+        ]
+        lm += "Example text: " + select(big_opts, name="choice")
+        return lm
+
+    # We should have significantly less output tokens in the fast-forwarded version (1 output)
+
+    # gpt2_noff = models.Transformers("gpt2", enable_ff_tokens=False, enable_backtrack=False) 
+    # gpt2_noff += ff_prompt()
+    # assert gpt2_noff.engine.metrics.engine_output_tokens > 1
+
+    gpt2_ff = models.Transformers("gpt2", enable_ff_tokens=True) 
+    gpt2_ff += ff_prompt()
+    assert gpt2_ff.engine.metrics.engine_output_tokens == 1
+
+
+
+
+
 
 def test_recursion_error():
     """This checks for an infinite recursion error resulting from a terminal node at the root of a grammar."""

From 71226141db19be4089746190c019400c7c4020a8 Mon Sep 17 00:00:00 2001
From: S Jenkins <nopdive@gmail.com>
Date: Sun, 10 Nov 2024 17:37:14 -0800
Subject: [PATCH 15/30] Fixed assertions for fast forward and backtrack tests.

---
 tests/model_specific/test_transformers.py | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/tests/model_specific/test_transformers.py b/tests/model_specific/test_transformers.py
index d8bad37cc..03f950c64 100644
--- a/tests/model_specific/test_transformers.py
+++ b/tests/model_specific/test_transformers.py
@@ -39,13 +39,21 @@ def ff_prompt(lm):
 
     # We should have significantly less output tokens in the fast-forwarded version (1 output)
 
-    # gpt2_noff = models.Transformers("gpt2", enable_ff_tokens=False, enable_backtrack=False) 
-    # gpt2_noff += ff_prompt()
-    # assert gpt2_noff.engine.metrics.engine_output_tokens > 1
+    gpt2_noff = models.Transformers("gpt2", enable_ff_tokens=False)
+    gpt2_noff += ff_prompt()
+    noff_count = gpt2_noff.engine.metrics.engine_output_tokens
 
-    gpt2_ff = models.Transformers("gpt2", enable_ff_tokens=True) 
+    gpt2_nobt = models.Transformers("gpt2", enable_backtrack=False)
+    gpt2_nobt += ff_prompt()
+    nobt_count = gpt2_nobt.engine.metrics.engine_output_tokens
+
+    gpt2_ff = models.Transformers("gpt2")
     gpt2_ff += ff_prompt()
-    assert gpt2_ff.engine.metrics.engine_output_tokens == 1
+    ff_count = gpt2_ff.engine.metrics.engine_output_tokens
+
+    assert nobt_count == 3
+    assert ff_count == 3
+    assert noff_count > ff_count
 
 
 

From ba8502d51d5dfce74c13e71533c07df7c3de7ef6 Mon Sep 17 00:00:00 2001
From: Harsha-Nori <harsha.nori@live.com>
Date: Sun, 10 Nov 2024 17:46:09 -0800
Subject: [PATCH 16/30] Update README.md

temporarily remove AzureGuidance instructions while integration is being updated
---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 78abd4b09..989a54ed0 100644
--- a/README.md
+++ b/README.md
@@ -21,11 +21,11 @@ Guidance is available through PyPI and supports a variety of backends (Transform
 pip install guidance
 ```
 
-_Note: To use Guidance on Phi models in Azure AI, or to use the new accelerated Rust-based parser, please install the release-candidate v0.2.0 guidance package_:
+_Note: To use Guidance with our new accelerated Rust-based parser, please install the release-candidate v0.2.0 guidance package_:
 ```bash
 pip install guidance --pre
 ```
-For a detailed walkthrough of using Guidance on hosted Phi models, check the [Azure AI specific loading instructions.](#azure-ai) and the [Phi-3 + Guidance cookbook](https://github.com/microsoft/Phi-3CookBook/blob/main/code/01.Introduce/guidance.ipynb).
+<!-- For a detailed walkthrough of using Guidance on hosted Phi models, check the [Azure AI specific loading instructions.](#azure-ai) and the [Phi-3 + Guidance cookbook](https://github.com/microsoft/Phi-3CookBook/blob/main/code/01.Introduce/guidance.ipynb). -->
 
 <!-- <a href="https://www.youtube.com/watch?v=9oXjP5IIMzQ"  aria-label="Watch demo"><img alt="Watch demo" src="docs/figures/watch_demo_button.png" width="120"></a> <a href="#get-started" aria-label="Get started"><img alt="Watch demo" src="docs/figures/get_started_button.png" width="120"></a> -->
 
@@ -669,7 +669,7 @@ from guidance import models
 lm = models.Transformers(model_name_or_path)
 ```
 
-### Azure AI
+<!-- ### Azure AI
 Azure AI is experimenting with a serverside Guidance integration, first available on the Phi-3.5-mini model. To use Guidance with AzureAI, you need to run the pre-release candidate of the `guidance` library (v0.2.0rc1).
 
 ```bash
@@ -689,7 +689,7 @@ phi3_api_key = os.getenv("AZURE_PHI3_KEY")
 lm = AzureGuidance(f"{phi3_url}/guidance#auth={phi3_api_key}") # note the URL structure using the new /guidance endpoint
 ```
 
-Pull the deployment URL and Key from the Azure deployment to instantiate the class. You can now attach _any_ stateless guidance function to the `AzureGuidance` lm, and have it execute in a single API call. Stateless guidance functions executing in the cloud benefit from many key guidance features the same way local models do, including token healing, guidance acceleration, and fine-grained model control. Considerable effort and resources went into preparing this experimental pre-release, so please let us know if you encounter any bugs or have helpful feedback!
+Pull the deployment URL and Key from the Azure deployment to instantiate the class. You can now attach _any_ stateless guidance function to the `AzureGuidance` lm, and have it execute in a single API call. Stateless guidance functions executing in the cloud benefit from many key guidance features the same way local models do, including token healing, guidance acceleration, and fine-grained model control. Considerable effort and resources went into preparing this experimental pre-release, so please let us know if you encounter any bugs or have helpful feedback! -->
 
 ```python
 @guidance(stateless=True) # Note the stateless=True flag in the decorator -- this enables maximal efficiency on the guidance program execution

From c7e2fbcaf6a132a716177bcd48e6ffb759dd8641 Mon Sep 17 00:00:00 2001
From: Harsha Nori <harsha.nori@live.com>
Date: Sun, 10 Nov 2024 19:43:50 -0800
Subject: [PATCH 17/30] Adding WIP support for llama3.2 chat template. Needs
 infra work to fully support

---
 guidance/chat.py | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/guidance/chat.py b/guidance/chat.py
index 2908458dc..e606ab4c4 100644
--- a/guidance/chat.py
+++ b/guidance/chat.py
@@ -326,3 +326,25 @@ def get_role_end(self, role_name=None):
 
 CHAT_TEMPLATE_CACHE[qwen2dot5_template] = Qwen2dot5ChatTemplate
 CHAT_TEMPLATE_CACHE[qwen2dot5_it_template] = Qwen2dot5ChatTemplate
+
+
+# TODO WIP [HN]: Llama 3.2 has the same issues as Phi-3 mini, where trim behavior is defined in the template.
+# Additionally, they use some crazy jinja trick to dynamically pull the current date (but have a fallback of July 26, 2024).
+# There's an additional problem that system roles are ALWAYS defined. Might need a refactor the entire system to handle.
+class Llama3dot2ChatTemplate(ChatTemplate):
+    # available_roles = ["user", "assistant"]
+    template_str = '{{- bos_token }}\n{%- if custom_tools is defined %}\n    {%- set tools = custom_tools %}\n{%- endif %}\n{%- if not tools_in_user_message is defined %}\n    {%- set tools_in_user_message = true %}\n{%- endif %}\n{%- if not date_string is defined %}\n    {%- if strftime_now is defined %}\n        {%- set date_string = strftime_now("%d %b %Y") %}\n    {%- else %}\n        {%- set date_string = "26 Jul 2024" %}\n    {%- endif %}\n{%- endif %}\n{%- if not tools is defined %}\n    {%- set tools = none %}\n{%- endif %}\n\n{#- This block extracts the system message, so we can slot it into the right place. #}\n{%- if messages[0][\'role\'] == \'system\' %}\n    {%- set system_message = messages[0][\'content\']|trim %}\n    {%- set messages = messages[1:] %}\n{%- else %}\n    {%- set system_message = "" %}\n{%- endif %}\n\n{#- System message #}\n{{- "<|start_header_id|>system<|end_header_id|>\\n\\n" }}\n{%- if tools is not none %}\n    {{- "Environment: ipython\\n" }}\n{%- endif %}\n{{- "Cutting Knowledge Date: December 2023\\n" }}\n{{- "Today Date: " + date_string + "\\n\\n" }}\n{%- if tools is not none and not tools_in_user_message %}\n    {{- "You have access to the following functions. To call a function, please respond with JSON for a function call." }}\n    {{- \'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.\' }}\n    {{- "Do not use variables.\\n\\n" }}\n    {%- for t in tools %}\n        {{- t | tojson(indent=4) }}\n        {{- "\\n\\n" }}\n    {%- endfor %}\n{%- endif %}\n{{- system_message }}\n{{- "<|eot_id|>" }}\n\n{#- Custom tools are passed in a user message with some extra guidance #}\n{%- if tools_in_user_message and not tools is none %}\n    {#- Extract the first user message so we can plug it in here #}\n    {%- if messages | length != 0 %}\n        {%- set first_user_message = messages[0][\'content\']|trim %}\n        {%- set messages = messages[1:] %}\n    {%- else %}\n        {{- raise_exception("Cannot put tools in the first user message when there\'s no first user message!") }}\n{%- endif %}\n    {{- \'<|start_header_id|>user<|end_header_id|>\\n\\n\' -}}\n    {{- "Given the following functions, please respond with a JSON for a function call " }}\n    {{- "with its proper arguments that best answers the given prompt.\\n\\n" }}\n    {{- \'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.\' }}\n    {{- "Do not use variables.\\n\\n" }}\n    {%- for t in tools %}\n        {{- t | tojson(indent=4) }}\n        {{- "\\n\\n" }}\n    {%- endfor %}\n    {{- first_user_message + "<|eot_id|>"}}\n{%- endif %}\n\n{%- for message in messages %}\n    {%- if not (message.role == \'ipython\' or message.role == \'tool\' or \'tool_calls\' in message) %}\n        {{- \'<|start_header_id|>\' + message[\'role\'] + \'<|end_header_id|>\\n\\n\'+ message[\'content\'] | trim + \'<|eot_id|>\' }}\n    {%- elif \'tool_calls\' in message %}\n        {%- if not message.tool_calls|length == 1 %}\n            {{- raise_exception("This model only supports single tool-calls at once!") }}\n        {%- endif %}\n        {%- set tool_call = message.tool_calls[0].function %}\n        {{- \'<|start_header_id|>assistant<|end_header_id|>\\n\\n\' -}}\n        {{- \'{"name": "\' + tool_call.name + \'", \' }}\n        {{- \'"parameters": \' }}\n        {{- tool_call.arguments | tojson }}\n        {{- "}" }}\n        {{- "<|eot_id|>" }}\n    {%- elif message.role == "tool" or message.role == "ipython" %}\n        {{- "<|start_header_id|>ipython<|end_header_id|>\\n\\n" }}\n        {%- if message.content is mapping or message.content is iterable %}\n            {{- message.content | tojson }}\n        {%- else %}\n            {{- message.content }}\n        {%- endif %}\n        {{- "<|eot_id|>" }}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- \'<|start_header_id|>assistant<|end_header_id|>\\n\\n\' }}\n{%- endif %}\n'
+
+    def get_role_start(self, role_name):
+        if role_name == "system":
+            # TODO: Figure out how Jinja detects datetime and replace with strftime() if needed - currently using fallback
+            return "<|start_header_id|>system<|end_header_id|>\n\nCutting Knowledge Date: December 2023\nToday Date: 26 Jul 2024"
+        elif role_name == "user":
+            return "<|start_header_id|>user<|end_header_id|>\n\n"
+        elif role_name == "assistant":
+            return "<|start_header_id|>assistant<|end_header_id|>\n\n"
+        else:
+            raise UnsupportedRoleException(role_name, self)
+
+    def get_role_end(self, role_name=None):
+        return "<|eot_id|>"
\ No newline at end of file

From 13ef66e85fc36e93f95baeb0ac9b7d8902ffc5b3 Mon Sep 17 00:00:00 2001
From: S Jenkins <69673492+nopdive@users.noreply.github.com>
Date: Mon, 11 Nov 2024 13:14:38 -0800
Subject: [PATCH 18/30] [Bug] Fix for environment detection in barebones
 environments. (#1076)

---
 guidance/visual/_environment.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/guidance/visual/_environment.py b/guidance/visual/_environment.py
index ce35a70af..fc10b35cc 100644
--- a/guidance/visual/_environment.py
+++ b/guidance/visual/_environment.py
@@ -102,7 +102,7 @@ def _detect_ipython(flags: EnvFlags) -> bool:
     try:
         from IPython import get_ipython
         found = get_ipython() is not None
-    except NameError:  # pragma: no cover
+    except (NameError, ImportError):  # pragma: no cover
         pass
     return found
 
@@ -129,7 +129,7 @@ def _detect_ipython_zmq(flags: EnvFlags) -> bool:
             found = False  # Terminal running IPython
         else:
             found = False  # Other type (?)
-    except NameError:  # pragma: no cover
+    except (NameError, ImportError):  # pragma: no cover
         found = False  # Probably standard Python interpreter
 
     flags.is_notebook |= found

From 08959d6bc27a5bac7d766c5b8fda9e3f2c17d60e Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Thu, 21 Nov 2024 17:40:53 -0800
Subject: [PATCH 19/30] Update setup.py to limit llguidance version (#1080)

Setting upper-bound on llguidance version to make sure new changes
aren't breaking
---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index c8b801566..0996670c9 100644
--- a/setup.py
+++ b/setup.py
@@ -29,7 +29,7 @@
     "referencing",
     "requests",
     "tiktoken>=0.3",
-    "llguidance>=0.3.0",
+    "llguidance>=0.3.0,<0.4.0",
 ]
 
 # Our basic list of 'extras'

From 2f114670904119be93abe240c6a6855f8afdb192 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Moskal?= <michal@moskal.me>
Date: Mon, 25 Nov 2024 10:58:53 -0800
Subject: [PATCH 20/30] update to llguidance 0.4.1 (#1081)

---
 guidance/_parser.py       | 20 ++++++++++----------
 guidance/models/_model.py |  4 ++--
 setup.py                  |  2 +-
 tests/unit/test_ll.py     |  6 +++---
 4 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/guidance/_parser.py b/guidance/_parser.py
index ca4b1405b..d4df1c108 100644
--- a/guidance/_parser.py
+++ b/guidance/_parser.py
@@ -91,8 +91,8 @@ def _process_prompt(self, prompt: bytes, ensure_bos_token: bool) -> list[int]:
 
         return self.tokenizer.recode(prompt_tokens)
 
-    def mid_process(self) -> tuple[Optional[bytes], LLInterpreterResponse]:
-        mask, ll_response_string = self.ll_interpreter.mid_process()
+    def compute_mask(self) -> tuple[Optional[bytes], LLInterpreterResponse]:
+        mask, ll_response_string = self.ll_interpreter.compute_mask()
         ll_response = LLInterpreterResponse.model_validate_json(ll_response_string)
         return mask, ll_response
 
@@ -111,14 +111,14 @@ def _parse(
         tokens = self._process_prompt(prompt=prompt, ensure_bos_token=ensure_bos_token)
 
         while True:
-            # Note: need to call/set has_pending_stop before spinning up the mid_process future
-            # as the two methods cannot be called concurrently
+            # Note: need to call/set has_pending_stop before spinning up the compute mask 
+            # future as the two methods cannot be called concurrently
             self._has_pending_stop = self.ll_interpreter.has_pending_stop()
-            mid_process_future = self._threadpool.submit(self.mid_process)
-            token = yield (tokens, mid_process_future)
+            mask_future = self._threadpool.submit(self.compute_mask)
+            token = yield (tokens, mask_future)
 
             # Upstairs should have already waited on this future
-            mask, ll_response = mid_process_future.result()
+            mask, ll_response = mask_future.result()
 
             if ll_response.stop:
                 # This is the only case in which the mask is None
@@ -141,7 +141,7 @@ def _parse(
                     prompt_tokens=tokens
                 )
 
-            backtrack, ff_tokens = self.ll_interpreter.post_process(token)
+            backtrack, ff_tokens = self.ll_interpreter.commit_token(token)
             if backtrack:
                 tokens = tokens[:-backtrack]
             tokens = tokens + ff_tokens
@@ -212,8 +212,8 @@ def next_byte_mask(self) -> NDArray[np.uint8]:
         return mask
 
     def _advance(self, token: Optional[int]) -> None:
-        tokens, mid_process_fut = self.token_parser.advance(token)
-        mask, ll_response = mid_process_fut.result()
+        tokens, mask_fut = self.token_parser.advance(token)
+        mask, ll_response = mask_fut.result()
         if ll_response.stop:
             assert mask is None
             self.token_parser.cleanup()
diff --git a/guidance/models/_model.py b/guidance/models/_model.py
index 3aaf3989b..81b1cd4b2 100644
--- a/guidance/models/_model.py
+++ b/guidance/models/_model.py
@@ -144,7 +144,7 @@ def __call__(
         has_get_logits = True
         token = None
         while True:
-            tokens, mid_process_fut = parser.advance(token)
+            tokens, mask_fut = parser.advance(token)
 
             # Note that has_pending_stop implies that the response is a stop response,
             # but the converse is not true. We can therefore avoid some (but not all)
@@ -163,7 +163,7 @@ def __call__(
 
             # Important: don't wait on this future until after getting the logits;
             # this allows the mask to be built concurrently with model inference
-            mask, ll_response = mid_process_fut.result()
+            mask, ll_response = mask_fut.result()
 
             engine_response = ll_response.progress.to_engine_call_response()
             yield engine_response
diff --git a/setup.py b/setup.py
index 0996670c9..a869fa046 100644
--- a/setup.py
+++ b/setup.py
@@ -29,7 +29,7 @@
     "referencing",
     "requests",
     "tiktoken>=0.3",
-    "llguidance>=0.3.0,<0.4.0",
+    "llguidance>=0.4.1,<0.5.0",
 ]
 
 # Our basic list of 'extras'
diff --git a/tests/unit/test_ll.py b/tests/unit/test_ll.py
index 211fe3998..bfc22f349 100644
--- a/tests/unit/test_ll.py
+++ b/tests/unit/test_ll.py
@@ -115,7 +115,7 @@ def check_grammar(grm: GrammarFunction, output: List[str]):
     idx = 1
     gen_tokens = tokenize_trace(output[idx])
     for _ in range(200):
-        mask, cmd = interp.mid_process()
+        mask, cmd = interp.compute_mask()
         cmd = json.loads(cmd)
         if log_level >= 1:
             print(mask is not None, cmd)
@@ -129,7 +129,7 @@ def check_grammar(grm: GrammarFunction, output: List[str]):
             tok = gen_tokens[0]
             del gen_tokens[0:1]
             assert mask[tok] > 0, f"Token {tok} not allowed"
-            bt, toks = interp.post_process(tok)
+            bt, toks = interp.commit_token(tok)
             if not toks or toks[0] != tok:
                 if output[idx + 1].startswith("1↶"):
                     # fast-forward with fake backtrack
@@ -149,7 +149,7 @@ def check_grammar(grm: GrammarFunction, output: List[str]):
                 assert len(toks) == 1
                 continue  # normal path
         else:
-            bt, toks = interp.post_process(None)
+            bt, toks = interp.commit_token(None)
 
         # forced byte checking
         assert not gen_tokens, "Expected more tokens to generate"

From 50a5c395c061620110af39f000304bfbc3d9277e Mon Sep 17 00:00:00 2001
From: Paul Koch <46825734+paulbkoch@users.noreply.github.com>
Date: Tue, 26 Nov 2024 07:31:02 -0800
Subject: [PATCH 21/30] fix current failures in pytest when run locally (#1083)

---
 CONTRIBUTING.md                               | 11 +++++------
 tests/bench/test_powerlift.py                 |  1 -
 tests/need_credentials/test_azureai_openai.py | 18 +++++++++---------
 tests/need_credentials/test_chat_templates.py |  8 ++++----
 tests/need_credentials/test_tokenizers.py     | 10 ++++++++--
 tests/notebooks/test_notebooks.py             |  6 ++++--
 tests/utils.py                                |  8 +++++++-
 7 files changed, 37 insertions(+), 25 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index fb49ff24c..1c27b1eeb 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -12,7 +12,7 @@ We welcome contributions to `guidance`, and this document exists to provide usef
 
 The quickest way to get started is to run (in a fresh environment):
 ```bash
-pip install -e .[all,test]
+pip install -e .[all,test,bench]
 ```
 which should bring in all of the basic required dependencies.
 Note that if you want to use GPU acceleration, then you will need to do whatever is required to allow `torch` and `llama-cpp` to access your GPU too.
@@ -32,16 +32,16 @@ However, if you have your own means of installing Rust and CUDA, you should be a
 
 ## Running Tests
 
-Because we run tests on GPU-equipped machines and also tests which call LLM endpoints, approval is required before our GitHub workflows will run on external Pull Requests.
-To run a basic test suite locally, we suggest:
+To run a basic test suite locally:
 ```bash
-python -m pytest -m "not (needs_credentials or use_gpu or server)" ./tests/
+python -m pytest ./tests/
 ```
 which runs our basic test suite.
 Where an LLM is required, this will default to using GPT2 on the CPU.
+
 To change that default, run
 ```bash
-python -m pytest -m "not (needs_credentials or use_gpu or server)" --selected_model <MODELNAME> ./tests/
+python -m pytest --selected_model <MODELNAME> ./tests/
 ```
 where `<MODELNAME>` is taken from the `AVAILABLE_MODELS` dictionary defined in `_llms_for_testing.py`.
 
@@ -68,7 +68,6 @@ If your model requires credentials, then those will need to be added to our GitH
 The endpoint itself (and any other required information) should be configured as environment variables too.
 When the test runs, the environment variables will be set, and can then be used to configure the model as required.
 See `test_azureai_openai.py` for examples of this being done.
-The tests should also be marked as `needs_credentials` - if this is needed for the entire module, then `pytestmark` can be used - see `test_azureai_openai.py` again for this.
 
 The environment variables and secrets will also need to be configured in the `ci_tests.yml` file.
 
diff --git a/tests/bench/test_powerlift.py b/tests/bench/test_powerlift.py
index 4a2cec6f6..9940eb9be 100644
--- a/tests/bench/test_powerlift.py
+++ b/tests/bench/test_powerlift.py
@@ -11,7 +11,6 @@ def test_retrieve_langchain_err(monkeypatch):
         _ = list(gen)
 
 @pytest.mark.skip("Waiting on CI upgrades. Need access to env var LANGCHAIN_API_KEY.")
-# @pytest.mark.needs_credentials
 def test_retrieve_langchain_basic():
     with tempfile.TemporaryDirectory() as tmp_dir:
         # Run once
diff --git a/tests/need_credentials/test_azureai_openai.py b/tests/need_credentials/test_azureai_openai.py
index 8e360539a..c5ec19cca 100644
--- a/tests/need_credentials/test_azureai_openai.py
+++ b/tests/need_credentials/test_azureai_openai.py
@@ -9,13 +9,13 @@
 from guidance import assistant, gen, models, system, user
 
 from ..model_specific import common_chat_testing
-from ..utils import env_or_fail
+from ..utils import env_or_skip
 
 
 @pytest.fixture(scope="function")
 def azureai_chat_model(rate_limiter):
-    azureai_endpoint = env_or_fail("AZUREAI_CHAT_ENDPOINT")
-    model = env_or_fail("AZUREAI_CHAT_MODEL")
+    azureai_endpoint = env_or_skip("AZUREAI_CHAT_ENDPOINT")
+    model = env_or_skip("AZUREAI_CHAT_MODEL")
 
     print(f"{azureai_endpoint=}")
     print(f"{model=}")
@@ -46,8 +46,8 @@ def test_azureai_openai_chat_longer_2(azureai_chat_model):
 
 
 def test_azureai_openai_chat_alt_args(rate_limiter):
-    azureai_endpoint = env_or_fail("AZUREAI_CHAT_ENDPOINT")
-    model = env_or_fail("AZUREAI_CHAT_MODEL")
+    azureai_endpoint = env_or_skip("AZUREAI_CHAT_ENDPOINT")
+    model = env_or_skip("AZUREAI_CHAT_MODEL")
 
     parsed_url = urlparse(azureai_endpoint)
     parsed_query = parse_qs(parsed_url.query)
@@ -71,8 +71,8 @@ def test_azureai_openai_chat_alt_args(rate_limiter):
 
 
 def test_azureai_openai_completion_smoke(rate_limiter):
-    azureai_endpoint = env_or_fail("AZUREAI_COMPLETION_ENDPOINT")
-    model = env_or_fail("AZUREAI_COMPLETION_MODEL")
+    azureai_endpoint = env_or_skip("AZUREAI_COMPLETION_ENDPOINT")
+    model = env_or_skip("AZUREAI_COMPLETION_MODEL")
 
     print(f"endpoint: {' '.join(azureai_endpoint)}")
     print(f"model: {' '.join(model)}")
@@ -95,8 +95,8 @@ def test_azureai_openai_completion_smoke(rate_limiter):
 
 
 def test_azureai_openai_completion_alt_args(rate_limiter):
-    azureai_endpoint = env_or_fail("AZUREAI_COMPLETION_ENDPOINT")
-    model = env_or_fail("AZUREAI_COMPLETION_MODEL")
+    azureai_endpoint = env_or_skip("AZUREAI_COMPLETION_ENDPOINT")
+    model = env_or_skip("AZUREAI_COMPLETION_MODEL")
 
     parsed_url = urlparse(azureai_endpoint)
     parsed_query = parse_qs(parsed_url.query)
diff --git a/tests/need_credentials/test_chat_templates.py b/tests/need_credentials/test_chat_templates.py
index 299b87ea8..78a602198 100644
--- a/tests/need_credentials/test_chat_templates.py
+++ b/tests/need_credentials/test_chat_templates.py
@@ -5,7 +5,7 @@
 
 from guidance.chat import CHAT_TEMPLATE_CACHE
 
-from ..utils import env_or_fail
+from ..utils import env_or_skip
 
 
 @pytest.mark.parametrize(
@@ -26,7 +26,7 @@
 def test_popular_models_in_cache(model_id: str, should_pass: bool):
     # This test simply checks to make sure the chat_templates haven't changed, and that they're still in our cache.
     # If this fails, the models have had their templates updated, and we need to fix the cache manually.
-    hf_token = env_or_fail("HF_TOKEN")
+    hf_token = env_or_skip("HF_TOKEN")
 
     tokenizer = transformers.AutoTokenizer.from_pretrained(
         model_id, token=hf_token, trust_remote_code=True
@@ -56,7 +56,7 @@ def test_popular_models_in_cache(model_id: str, should_pass: bool):
     ],
 )
 def test_chat_format_smoke(model_id: str):
-    hf_token = env_or_fail("HF_TOKEN")
+    hf_token = env_or_skip("HF_TOKEN")
 
     tokenizer = transformers.AutoTokenizer.from_pretrained(
         model_id, token=hf_token, trust_remote_code=True
@@ -97,7 +97,7 @@ def test_chat_format_smoke(model_id: str):
     ],
 )
 def test_chat_format_smoke_with_system(model_id: str):
-    hf_token = env_or_fail("HF_TOKEN")
+    hf_token = env_or_skip("HF_TOKEN")
 
     tokenizer = transformers.AutoTokenizer.from_pretrained(
         model_id, token=hf_token, trust_remote_code=True
diff --git a/tests/need_credentials/test_tokenizers.py b/tests/need_credentials/test_tokenizers.py
index 41870a22e..a85e7056c 100644
--- a/tests/need_credentials/test_tokenizers.py
+++ b/tests/need_credentials/test_tokenizers.py
@@ -19,9 +19,15 @@ class TestAuthenticatedTransformerTokenizers(BaseTestTransformerTokenizers):
         TRANSFORMER_MODELS,
     )
     def test_smoke(self, model_name: str):
-        self.base_smoke(model_name)
+        try:
+            self.base_smoke(model_name)
+        except OSError:
+            pytest.skip("HuggingFace raises OSError if user is not authenticated.")
 
     @pytest.mark.parametrize("model_name", TRANSFORMER_MODELS)
     @pytest.mark.parametrize("target_string", TOKENIZER_ROUND_TRIP_STRINGS)
     def test_string_roundtrip(self, model_name: str, target_string: str):
-        self.base_string_roundtrip(model_name, target_string)
+        try:
+            self.base_string_roundtrip(model_name, target_string)
+        except OSError:
+            pytest.skip("HuggingFace raises OSError if user is not authenticated.")
diff --git a/tests/notebooks/test_notebooks.py b/tests/notebooks/test_notebooks.py
index 350feab93..5ec517bf6 100644
--- a/tests/notebooks/test_notebooks.py
+++ b/tests/notebooks/test_notebooks.py
@@ -7,6 +7,8 @@
 import papermill as pm
 import pytest
 
+from ..utils import env_or_skip
+
 BASE_NB_PATH = pathlib.Path("./notebooks").absolute()
 
 
@@ -23,7 +25,7 @@ class TestTutorials:
     BASE_TUTORIAL_PATH = BASE_NB_PATH / "tutorials"
 
     def test_chat(self, rate_limiter):
-        azureai_endpoint = os.getenv("AZUREAI_CHAT_ENDPOINT", None)
+        azureai_endpoint = env_or_skip("AZUREAI_CHAT_ENDPOINT")
 
         parsed_url = urlparse(azureai_endpoint)
         parsed_query = parse_qs(parsed_url.query)
@@ -54,7 +56,7 @@ class TestModels:
     BASE_MODEL_PATH = BASE_NB_PATH / "api_examples" / "models"
 
     def test_azure_openai(self, rate_limiter):
-        azureai_endpoint = os.getenv("AZUREAI_CHAT_ENDPOINT", None)
+        azureai_endpoint = env_or_skip("AZUREAI_CHAT_ENDPOINT")
 
         parsed_url = urlparse(azureai_endpoint)
         parsed_query = parse_qs(parsed_url.query)
diff --git a/tests/utils.py b/tests/utils.py
index 8dc479ba7..735838bed 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -15,10 +15,16 @@
 def env_or_fail(var_name: str) -> str:
     env_value = os.getenv(var_name, None)
 
-    assert env_value is not None, f"Env '{var_name}' not found"
+    assert env_value is not None, f"Env '{var_name}' not found."
 
     return env_value
 
+def env_or_skip(var_name: str) -> str:
+    env_value = os.getenv(var_name, None)
+    if env_value is None:
+        pytest.skip(f"Env '{var_name}' not found.")
+    return env_value
+
 
 def get_model(model_name, caching=False, **kwargs):
     """Get an LLM by name."""

From 567528a5437a13783aab4681c4b6a99d1612948d Mon Sep 17 00:00:00 2001
From: JC1DA <nlhuynh.2014@phdis.smu.edu.sg>
Date: Wed, 4 Dec 2024 16:21:09 -0800
Subject: [PATCH 22/30] Force Transformers engine to return float logits
 (#1086)

Problem: Logits cannot be converted directly to CPU numpy if its type is
in BFloat16

Signed-off-by: JC1DA <jc1da.3011@gmail.com>
---
 guidance/models/transformers/_transformers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/guidance/models/transformers/_transformers.py b/guidance/models/transformers/_transformers.py
index b33422588..3afd0be70 100644
--- a/guidance/models/transformers/_transformers.py
+++ b/guidance/models/transformers/_transformers.py
@@ -510,7 +510,7 @@ def get_logits(self, token_ids):
             cache_token_ids.extend(new_token_ids)
             # Need to add special truncating logic here for weird models that have a different output size than tokenizer vocab
             self._cached_logits = (
-                model_out.logits[0, -1, : len(self.tokenizer.tokens)].cpu().numpy()
+                model_out.logits[0, -1, : len(self.tokenizer.tokens)].float().cpu().numpy()
             )
             self.metrics.engine_input_tokens += len(new_token_ids)
             self.metrics.engine_output_tokens += 1

From c78e0b40460a6419b019550b52e4292bb1e49f7b Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Tue, 10 Dec 2024 16:19:27 -0800
Subject: [PATCH 23/30] Bump runners from macos-12 to macos-14 (#1088)

Co-authored-by: Michal Moskal <michal@moskal.me>
---
 .github/workflows/pypi_upload.yml      | 4 ++--
 .github/workflows/workflow-pr-gate.yml | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/pypi_upload.yml b/.github/workflows/pypi_upload.yml
index 6813eb7f8..e3fa04eac 100644
--- a/.github/workflows/pypi_upload.yml
+++ b/.github/workflows/pypi_upload.yml
@@ -32,7 +32,7 @@ jobs:
               cibuildwheel --print-build-identifiers --platform linux --archs x86_64 \
               | jq -nRc '{"only": inputs, "os": "ubuntu-latest"}' \
               && cibuildwheel --print-build-identifiers --platform macos --archs x86_64 \
-              | jq -nRc '{"only": inputs, "os": "macos-12"}' \
+              | jq -nRc '{"only": inputs, "os": "macos-14"}' \
               && cibuildwheel --print-build-identifiers --platform macos --archs arm64 \
               | jq -nRc '{"only": inputs, "os": "macos-latest"}' \
               && cibuildwheel --print-build-identifiers --platform windows --archs auto64 \
@@ -143,7 +143,7 @@ jobs:
     needs: [assemble_wheels]
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-12, macos-latest]
+        os: [ubuntu-latest, windows-latest, macos-14, macos-latest]
         python-version: ["3.11", "3.12"]
     runs-on: ${{ matrix.os }}
     steps:
diff --git a/.github/workflows/workflow-pr-gate.yml b/.github/workflows/workflow-pr-gate.yml
index 3bf1ab5d0..a1e3cfb70 100644
--- a/.github/workflows/workflow-pr-gate.yml
+++ b/.github/workflows/workflow-pr-gate.yml
@@ -14,7 +14,7 @@ jobs:
   bare-install:
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-12]
+        os: [ubuntu-latest, windows-latest, macos-14]
         python-version: ["3.9", "3.10", "3.11", "3.12"]
     runs-on: ${{ matrix.os }}
     steps:
@@ -130,7 +130,7 @@ jobs:
           - "llamacpp_phi3_mini_4k_instruct_cpu"
     uses: ./.github/workflows/action_plain_basic_tests.yml
     with:
-      os: macos-12
+      os: macos-14
       python-version: ${{ matrix.python-version }}
       model: ${{ matrix.model }}
 

From c92d80ade2e1b84a45f340f67c12dfbf500c12a2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Moskal?= <michal@moskal.me>
Date: Wed, 11 Dec 2024 08:56:23 -0800
Subject: [PATCH 24/30] update llguidance to 0.5.0 (#1087)

Includes some changes to llguidance's handling of max_tokens
---
 setup.py                                  | 2 +-
 tests/model_specific/test_transformers.py | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/setup.py b/setup.py
index a869fa046..7bab97840 100644
--- a/setup.py
+++ b/setup.py
@@ -29,7 +29,7 @@
     "referencing",
     "requests",
     "tiktoken>=0.3",
-    "llguidance>=0.4.1,<0.5.0",
+    "llguidance==0.5.0",
 ]
 
 # Our basic list of 'extras'
diff --git a/tests/model_specific/test_transformers.py b/tests/model_specific/test_transformers.py
index 03f950c64..07e332db2 100644
--- a/tests/model_specific/test_transformers.py
+++ b/tests/model_specific/test_transformers.py
@@ -39,7 +39,7 @@ def ff_prompt(lm):
 
     # We should have significantly less output tokens in the fast-forwarded version (1 output)
 
-    gpt2_noff = models.Transformers("gpt2", enable_ff_tokens=False)
+    gpt2_noff = models.Transformers("gpt2", enable_backtrack=False, enable_ff_tokens=False)
     gpt2_noff += ff_prompt()
     noff_count = gpt2_noff.engine.metrics.engine_output_tokens
 
@@ -51,8 +51,8 @@ def ff_prompt(lm):
     gpt2_ff += ff_prompt()
     ff_count = gpt2_ff.engine.metrics.engine_output_tokens
 
-    assert nobt_count == 3
-    assert ff_count == 3
+    assert nobt_count == 2
+    assert ff_count == 2
     assert noff_count > ff_count
 
 

From d913f68e32c76a41b3e3ecff34c914b14f60373c Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Fri, 13 Dec 2024 09:05:58 -0800
Subject: [PATCH 25/30] Use `llguidance` JSON grammar (#1085)

Replaces the python JSON grammar implementation with `llguidance`'s rust `JsonCompiler`

---------

Co-authored-by: Michal Moskal <michal@moskal.me>
---
 guidance/_grammar.py                   |  284 ++---
 guidance/library/_gen.py               |    4 +-
 guidance/library/_json.py              | 1347 +-----------------------
 guidance/library/_regex_utils.py       |  272 -----
 guidance/library/_subgrammar.py        |    2 +-
 setup.py                               |    1 -
 tests/unit/library/json/test_allOf.py  |    6 +-
 tests/unit/library/json/test_json.py   |  166 +--
 tests/unit/library/test_regex_utils.py |  163 ---
 9 files changed, 242 insertions(+), 2003 deletions(-)
 delete mode 100644 guidance/library/_regex_utils.py
 delete mode 100644 tests/unit/library/test_regex_utils.py

diff --git a/guidance/_grammar.py b/guidance/_grammar.py
index 99425aa69..145afd53c 100644
--- a/guidance/_grammar.py
+++ b/guidance/_grammar.py
@@ -30,10 +30,10 @@ class Function:
     represent guidance grammars that can be serialized and sent across the wire, while
     RawFunctions represent unconstrained native Python functions.
     """
+    __slots__ = ("name",)
 
-    def __init__(self, name, value=None) -> None:
+    def __init__(self, name):
         self.name = name
-        self.value = value
 
     def __str__(self):
         """Creates a string tag that can be used to retrieve this object."""
@@ -51,6 +51,7 @@ class RawFunction(Function):
     __slots__ = ("f", "args", "kwargs")
 
     def __init__(self, f, args, kwargs):
+        super().__init__(f.__name__)
         self.f = f
         self.args = args
         self.kwargs = kwargs
@@ -122,14 +123,14 @@ def __repr__(self):
 
 
 class GrammarFunction(Function):
-    __slots__ = "capture_name"
+    __slots__ = ("capture_name",)
     num_used_names = 0
 
-    def __init__(self, capture_name: Union[str, None] = None):
+    def __init__(self, *, name: Optional[str] = None, capture_name: Optional[str] = None):
+        super().__init__(name or capture_name or self._new_name())
         self.capture_name = capture_name
 
     def __add__(self, value):
-
         # see if we have a string with calls or a simple string
         if isinstance(value, str) or isinstance(value, bytes):
             if isinstance(value, str) and re.search(_tag_pattern, value):
@@ -197,9 +198,9 @@ def forced_prefix(self) -> str:
         parser = _parser.ByteParser(self)
         return parser.bytes.decode("utf-8", errors="ignore")
 
-    @staticmethod
-    def _new_name():
-        num_used = GrammarFunction.num_used_names
+    @classmethod
+    def _new_name(cls):
+        num_used = cls.num_used_names
 
         a_ord = ord("a")
 
@@ -212,7 +213,7 @@ def _new_name():
                 if num_used >= 17576:
                     name = chr(a_ord + (num_used % 456976) // 17576) + name
 
-        GrammarFunction.num_used_names += 1
+        cls.num_used_names += 1
 
         return name
 
@@ -232,22 +233,22 @@ def ll_serialize(self):
 
 
 class Terminal(GrammarFunction):
-    __slots__ = "temperature"
+    __slots__ = ("temperature",)
 
-    def __init__(self, *, temperature: float, capture_name: Union[str, None]):
-        super().__init__(capture_name=capture_name)
+    def __init__(self, *, name: Optional[str] = None, capture_name: Optional[str] = None, temperature: Optional[float] = None):
+        super().__init__(name=name, capture_name=capture_name)
         self.temperature = temperature
-        self.max_tokens = 1000000000000
 
     def match_byte(self, byte):
         pass  # abstract
 
+
 class DeferredReference(Terminal):
     """Container to hold a value that is resolved at a later time. This is useful for recursive definitions."""
-    __slots__ = "_value"
+    __slots__ = ("_resolved", "_value")
 
     def __init__(self) -> None:
-        super().__init__(temperature=-1, capture_name=None)
+        super().__init__()
         self._resolved = False
         self._value: Optional[GrammarFunction] = None
 
@@ -266,18 +267,14 @@ def value(self, value: GrammarFunction) -> None:
         self._resolved = True
 
 class Byte(Terminal):
-    __slots__ = ("byte", "temperature")
+    __slots__ = ("byte",)
 
     def __init__(self, byte: bytes):
-        super().__init__(temperature=-1, capture_name=None)
         assert isinstance(byte, bytes)
         assert len(byte) == 1
+        super().__init__(name=str(byte))
         self.byte = byte
 
-    @property
-    def name(self) -> str:
-        return str(self.byte)
-
     def __hash__(self):
         return self.byte[0]
 
@@ -295,25 +292,17 @@ def match_byte(self, byte: bytes) -> bool:
 
 
 class ByteRange(Terminal):
-    __slots__ = "byte_range"
+    __slots__ = ("byte_range",)
 
     def __init__(self, byte_range: bytes):
-        super().__init__(temperature=-1, capture_name=None)
         assert isinstance(byte_range, bytes)
         assert len(byte_range) == 2
+        super().__init__(name=str(byte_range))
         self.byte_range = byte_range
 
     def match_byte(self, byte: bytes) -> bool:
         return self.byte_range[0] <= byte[0] <= self.byte_range[1]
 
-    @property
-    def name(self) -> str:
-        return str(self.byte_range)
-
-    @name.setter
-    def name(self, value):
-        pass  # we ignore name changes
-
     def __hash__(self):
         return self.byte_range[0] + 256 * self.byte_range[1]
 
@@ -332,11 +321,8 @@ def __len__(self) -> int:
 
 
 class Null(Terminal):
-    __slots__ = "name"
-
     def __init__(self):
-        super().__init__(temperature=-1, capture_name=None)
-        self.name = "ε"
+        super().__init__(name="ε")
 
     def __add__(self, other):
         # see if we have a string with calls or a simple string
@@ -360,13 +346,8 @@ class ModelVariable(GrammarFunction):
     Note that the name is the name of the attribute on the model object this node
     will get replaced with.
     """
-
-    __slots__ = "name"
-
     def __init__(self, name):
-        super().__init__(capture_name=None)
-        self.name = name
-
+        super().__init__(name=name)
 
 def replace_model_variables(grammar, model, allowed_vars=None):
     """Replace all the ModelVariable nodes with their values in an iterative manner."""
@@ -444,26 +425,21 @@ def commit_point(value, hidden=False):
 
 
 class Join(GrammarFunction):
-    __slots__ = (
-        "values",
-        "name",
-        "max_tokens",
-    )
+    __slots__ = ("values",)
 
     def __init__(
         self,
         values: Sequence[ComposableGrammar],
-        name: Union[str, None] = None,
-        max_tokens=100000000,
+        *,
+        name: Optional[str] = None,
+        capture_name: Optional[str] = None,
     ) -> None:
-        super().__init__(capture_name=None)
+        super().__init__(name=name, capture_name=capture_name)
         # wrap raw strings
         converted_values = [string(v) if isinstance(v, (str, bytes)) else v for v in values]
         self.values: list[GrammarFunction] = [
             v for v in converted_values if not isinstance(v, Null)
         ]
-        self.name = name if name is not None else GrammarFunction._new_name()
-        self.max_tokens = max_tokens
 
     def __repr__(self, indent="", done=None):
         if done is None:
@@ -487,28 +463,35 @@ def quote_regex(value: str) -> str:
     return re.sub(r"([\\+*?^$(){}\[\]\.|])", r"\\\1", value)
 
 
-class Gen(Terminal):
+class WithMaxTokens(Terminal):
+    __slots__ = ("max_tokens",)
+
+    def __init__(self, *, name: Optional[str] = None, capture_name: Optional[str] = None, temperature: Optional[float] = None, max_tokens: Optional[int] = None):
+        super().__init__(name=name, capture_name=capture_name, temperature=temperature)
+        self.max_tokens = max_tokens
+
+
+class Gen(WithMaxTokens):
     __slots__ = (
         "body_regex",
         "stop_regex",
         "save_stop_text",
-        "name",
     )
 
     def __init__(
         self,
         body_regex: str,
         stop_regex: str,
-        name: Union[str, None] = None,
         save_stop_text: Optional[str] = None,
-        max_tokens=100000000,
+        *,
+        capture_name: Union[str, None] = None,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
     ) -> None:
-        super().__init__(temperature=-1, capture_name=None)
+        super().__init__(capture_name=capture_name, temperature=temperature, max_tokens=max_tokens)
         self.body_regex = body_regex
         self.stop_regex = stop_regex
-        self.name = name if name is not None else GrammarFunction._new_name()
         self.save_stop_text = save_stop_text
-        self.max_tokens = max_tokens
 
     def __repr__(self, indent="", done=None, lbl="Gen"):
         if done is None:
@@ -532,19 +515,21 @@ def __repr__(self, indent="", done=None, lbl="Gen"):
         return s
 
 
-class Lexeme(Gen):
-    __slots__ = ("contextual", "json_string")
+class Lexeme(WithMaxTokens):
+    __slots__ = ("rx", "contextual", "json_string")
 
     def __init__(
         self,
-        *,
-        body_regex: str,
+        rx: str,
         contextual: bool = False,
         json_string: bool = False,
-        name: Union[str, None] = None,
-        max_tokens=100000000,
+        *,
+        capture_name: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
     ) -> None:
-        super().__init__(body_regex, "", name=name, max_tokens=max_tokens)
+        super().__init__(capture_name=capture_name, temperature=temperature, max_tokens=max_tokens)
+        self.rx = rx
         self.contextual = contextual
         self.json_string = json_string
 
@@ -552,52 +537,50 @@ def __repr__(self, indent="", done=None):
         return super().__repr__(indent, done, "Lex")
 
 
-class RegularGrammar(Terminal):
-    __slots__ = ("grammar", "name")
+class RegularGrammar(WithMaxTokens):
+    __slots__ = ("grammar", "lexeme")
 
     def __init__(
         self,
         grammar: GrammarFunction,
         lexeme: bool = False,
-        name: Union[str, None] = None,
-        max_tokens=100000000,
+        *,
+        capture_name: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
     ) -> None:
-        super().__init__(capture_name=None, temperature=-1)
+        super().__init__(capture_name=capture_name, temperature=temperature, max_tokens=max_tokens)
         self.grammar = grammar
         self.lexeme = lexeme
-        self.name = name if name is not None else GrammarFunction._new_name()
-        self.max_tokens = max_tokens
 
     def __repr__(self, indent="", done=None):
         # TODO add grammar repr
         return super().__repr__(indent, done, "RegularGrammar")
 
+
 class And(Terminal):
-    __slots__ = ("values", "name")
+    __slots__ = ("values")
 
     def __init__(
         self,
         values: Sequence[GrammarFunction],
-        name: Union[str, None] = None,
     ):
-        super().__init__(temperature=-1, capture_name=None)
+        super().__init__()
         self.values = list(values)
-        self.name = name if name is not None else GrammarFunction._new_name()
+
 
 class Not(Terminal):
-    __slots__ = ("value", "name")
+    __slots__ = ("value")
 
     def __init__(
         self,
         value: GrammarFunction,
-        name: Union[str, None] = None,
     ):
-        super().__init__(temperature=-1, capture_name=None)
+        super().__init__()
         self.value = value
-        self.name = name if name is not None else GrammarFunction._new_name()
 
 
-class Subgrammar(Gen):
+class Subgrammar(WithMaxTokens):
     __slots__ = (
         "body",
         "skip_regex",
@@ -609,13 +592,14 @@ def __init__(
         body: GrammarFunction,
         skip_regex: Optional[str] = None,
         no_initial_skip: bool = False,
-        name: Union[str, None] = None,
-        max_tokens=100000000,
+        *,
+        capture_name: Optional[str] = None,
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
     ) -> None:
         super().__init__(
-            body_regex="",
-            stop_regex="",
-            name=name,
+            capture_name=capture_name,
+            temperature=temperature,
             max_tokens=max_tokens,
         )
         self.body = body
@@ -629,23 +613,18 @@ def __repr__(self) -> str:  # type: ignore[override]
 class Select(GrammarFunction):
     __slots__ = (
         "_values",
-        "name",
-        "max_tokens",
         "recursive",
     )
 
     def __init__(
         self,
         values: Sequence[GrammarFunction],
-        capture_name: Union[str, None] = None,
-        name: Union[str, None] = None,
-        max_tokens: int = 10000000,
         recursive: bool = False,
+        *,
+        capture_name: Union[str, None] = None,
     ) -> None:
         super().__init__(capture_name=capture_name)
         self.values: list[GrammarFunction] = values
-        self.name = name if name is not None else GrammarFunction._new_name()
-        self.max_tokens = max_tokens
         self.recursive = recursive
 
     @property
@@ -672,6 +651,13 @@ def __repr__(self, indent="", done=None):
         return s
 
 
+class LLGrammar(WithMaxTokens):
+    __slots__ = ("grammar_with_lexer",)
+    def __init__(self, grammar_with_lexer: dict[str, Any], *, capture_name: Optional[float] = None, temperature: Optional[float] = None, max_tokens: Optional[int] = None):
+        super().__init__(capture_name=capture_name, temperature=temperature, max_tokens=max_tokens)
+        self.grammar_with_lexer = grammar_with_lexer
+
+
 def string(value: Union[str, bytes]) -> Union[Null, Join]:
     if isinstance(value, str):
         b = bytes(value, encoding="utf8")
@@ -753,7 +739,7 @@ def select(
             raise ValueError("list_append requires a name")
 
     if recurse:
-        node = Select([], capture_name=name, recursive=True)
+        node = Select(values=[], capture_name=name, recursive=True)
         if "" in options:
             # if we have an empty option, 'node + v' also covers the case of 'v' itself
             # thus, we don't have to add 'options' (except for the empty string)
@@ -779,34 +765,26 @@ def capture(value: GrammarFunction, name: str) -> GrammarFunction:
     #     name += ":__LOG_PROBS"
     if not (isinstance(value, Join) and len(value.values) == 1):  # don't double wrap
         value = Join(
-            [value]
+            values=[value],
+            capture_name=name,
         )  # this ensures we capture what we want, and not something surprisingly self_recursive
-    value.capture_name = name
+    else:
+        value.capture_name = name
     return value
 
 
-def token_limit(value, max_tokens: int):
-    _rec_token_limit(value, max_tokens)
+def token_limit(value: GrammarFunction, max_tokens: int):
+    if isinstance(value, WithMaxTokens):
+        value.max_tokens = max_tokens
+    else:
+        return Subgrammar(
+            body=value,
+            max_tokens=max_tokens,
+        )
     return value
 
 
-def _rec_token_limit(grammar, max_tokens: int):
-    if grammar.max_tokens > max_tokens and not isinstance(grammar, Terminal):
-        if getattr(
-            grammar, "recursive", False
-        ):  # only restrict recursive selects, otherwise we would block all ways to complete the grammar
-            grammar.max_tokens = max_tokens
-            for value in getattr(
-                grammar, "values", []
-            ):  # restrict recursive selects recursive nodes
-                if not isinstance(value, Terminal):
-                    value.max_tokens = max_tokens
-        if hasattr(grammar, "values"):
-            for g in grammar.values:
-                _rec_token_limit(g, max_tokens)
-
-
-def with_temperature(value, temperature: float):
+def with_temperature(value: GrammarFunction, temperature: float):
     """This sets the sampling temperature to be used for the given portion of the grammar.
 
     Note that if the grammar passed to us already has some portions with a temperature
@@ -816,7 +794,7 @@ def with_temperature(value, temperature: float):
     return value
 
 
-def _re_with_temperature(grammar, temperature: float, visited_set):
+def _re_with_temperature(grammar: GrammarFunction, temperature: float, visited_set):
 
     # don't go down the same path twice
     if grammar in visited_set:
@@ -825,10 +803,12 @@ def _re_with_temperature(grammar, temperature: float, visited_set):
 
     # if getattr(grammar, "temperature", 100000000) > temperature:
     if (
-        isinstance(grammar, Terminal) and not isinstance(grammar, Null) and grammar.temperature < 0
-    ):  # only need to set temp for terminals
+        isinstance(grammar, Terminal) and not isinstance(grammar, Null) and (grammar.temperature is None or grammar.temperature < 0)
+    ):  # only need to set temp for terminals, and only if it hasn't been set yet
         grammar.temperature = temperature
-    elif getattr(grammar, "temperature", 100000000) > temperature and hasattr(grammar, "values"):
+    elif (
+        hasattr(grammar, "values") and not isinstance(grammar, Terminal)
+    ):
         for g in grammar.values:
             _re_with_temperature(g, temperature, visited_set)
 
@@ -969,7 +949,7 @@ def check_unserializable_attrs(node: GrammarFunction):
                 raise ValueError(
                     f"Regex serialization does not support captures. Node: {node.__repr__()}"
                 )
-            if getattr(node, "temperature", -1) >= 0:
+            if getattr(node, "temperature", None):
                 raise ValueError(
                     f"Regex serialization does not support temperature. Node: {node.__repr__()}"
                 )
@@ -1038,7 +1018,7 @@ def check_unserializable_attrs(node: GrammarFunction):
             elif isinstance(node, Lexeme):
                 if node.json_string:
                     raise ValueError("Cannot serialize lexeme with `json_string=True` as regex: " + node.__repr__())
-                res = self._add_regex("Regex", node.body_regex)
+                res = self._add_regex("Regex", node.rx)
             elif isinstance(node, And):
                 if not all_finished(node.values):
                     add_todo(node)
@@ -1077,6 +1057,16 @@ def grammar(self, grammar: Subgrammar) -> int:
         self.grammar_todo.append(grammar)
         return id
 
+    def llgrammar(self, llgrammar: LLGrammar) -> int:
+        if llgrammar in self.grammar_id_cache:
+            return self.grammar_id_cache[llgrammar]
+        id = len(self.grammars)
+        self.grammar_id_cache[llgrammar] = id
+        self.grammars.append(
+            llgrammar.grammar_with_lexer
+        )
+        return id
+
     def node(self, node: GrammarFunction) -> int:
         if node in self.node_id_cache:
             return self.node_id_cache[node]
@@ -1092,37 +1082,47 @@ def process(self, node: GrammarFunction):
             obj = {
                 "Select": {
                     "among": [self.node(v) for v in node.values],
+                    "capture_name": node.capture_name,
                 }
             }
         elif isinstance(node, Join):
             if all(isinstance(v, Byte) for v in node.values):
-                literal = b"".join(cast(Byte, v).byte for v in node.values)
+                byte_values = [cast(Byte, v) for v in node.values]
+                literal = b"".join([b.byte for b in byte_values])
+                # TODO: split up into multiple strings if temperature isn't homogeneous?
+                temperature = max((b.temperature for b in byte_values if b.temperature is not None), default=None)
                 obj = {
                     "String": {
                         "literal": literal.decode("utf-8", errors="strict"),
+                        "temperature": temperature,
                     }
                 }
             else:
                 obj = {
                     "Join": {
                         "sequence": [self.node(v) for v in node.values],
+                        "capture_name": node.capture_name,
                     }
                 }
         elif isinstance(node, Lexeme):
             obj = {
                 "Lexeme": {
-                    "rx": node.body_regex,
+                    "rx": node.rx,
                     "contextual": node.contextual,
                     "json_string": node.json_string,
+                    "capture_name": node.capture_name,
+                    "max_tokens": node.max_tokens,
+                    "temperature": node.temperature,
                 }
             }
         elif isinstance(node, Subgrammar):
             obj = {
                 "GenGrammar": {
                     "grammar": self.grammar(node),
-                    "stop_rx": node.stop_regex,
                     "no_initial_skip": node.no_initial_skip,
-                    "temperature": node.temperature if node.temperature >= 0 else None,
+                    "capture_name": node.capture_name,
+                    "max_tokens": node.max_tokens,
+                    "temperature": node.temperature,
                 }
             }
         elif isinstance(node, RegularGrammar):
@@ -1132,6 +1132,9 @@ def process(self, node: GrammarFunction):
                         "rx": self.regex(node.grammar),
                         "contextual": False,
                         "json_string": False,
+                        "capture_name": node.capture_name,
+                        "max_tokens": node.max_tokens,
+                        "temperature": node.temperature,
                     }
                 }
             else:
@@ -1139,8 +1142,10 @@ def process(self, node: GrammarFunction):
                     "Gen": {
                         "body_rx": self.regex(node.grammar),
                         "stop_rx": "",
-                        "lazy": False,  # TODO this should be True
-                        "temperature": node.temperature if node.temperature >= 0 else None,
+                        "lazy": False, # TODO: false needed to support substring, but it should maybe be true?
+                        "capture_name": node.capture_name,
+                        "max_tokens": node.max_tokens,
+                        "temperature": node.temperature,
                     }
                 }
         elif isinstance(node, Gen):
@@ -1150,30 +1155,36 @@ def process(self, node: GrammarFunction):
                     "stop_rx": node.stop_regex,
                     "lazy": node.stop_regex != "",
                     "stop_capture_name": node.save_stop_text,
-                    "temperature": node.temperature if node.temperature >= 0 else None,
+                    "capture_name": node.capture_name,
+                    "max_tokens": node.max_tokens,
+                    "temperature": node.temperature,
                 }
             }
         elif isinstance(node, ByteRange):
-            # TODO: maybe raise a warning in this case, as user should probably be using a larger
-            # GenCommitPoint?
+            # TODO: maybe raise a warning in this case, as user should probably be using a larger RegularGrammar?
             obj = {
                 "Gen": {
                     "body_rx": self.regex(node),
                     "stop_rx": "",
                     "lazy": True,
-                    "temperature": node.temperature if node.temperature >= 0 else None,
+                    "temperature": node.temperature,
+                    "capture_name": node.capture_name,
                 }
             }
         elif isinstance(node, Byte):
             obj = {
                 "String": {
                     "literal": node.byte.decode("utf-8", errors="strict"),
+                    "temperature": node.temperature,
+                    "capture_name": node.capture_name,
                 }
             }
         elif isinstance(node, Null):
             obj = {
                 "String": {
                     "literal": "",
+                    "temperature": node.temperature,
+                    "capture_name": node.capture_name,
                 }
             }
         elif isinstance(node, DeferredReference):
@@ -1184,6 +1195,15 @@ def process(self, node: GrammarFunction):
                     "sequence": [self.node(node.value)],
                 }
             }
+        elif isinstance(node, LLGrammar):
+            obj = {
+                "GenGrammar": {
+                    "grammar": self.llgrammar(node),
+                    "capture_name": node.capture_name,
+                    "max_tokens": node.max_tokens,
+                    "temperature": node.temperature
+                }
+            }
         else:
             raise Exception("Unknown node type:", type(node))
         tp = next(iter(obj))
@@ -1193,7 +1213,7 @@ def process(self, node: GrammarFunction):
         # Names on nodes are mostly useless
         # if getattr(node, "name", None):
         #     inner["name"] = node.name
-        if (max_tokens := getattr(node, "max_tokens")) and max_tokens < 1000000:
+        if (max_tokens := getattr(node, "max_tokens", None)) and max_tokens < 1000000:
             inner["max_tokens"] = max_tokens
         self.nodes[self.node(node)] = obj
 
diff --git a/guidance/library/_gen.py b/guidance/library/_gen.py
index 644bf3b61..8e7a0b5aa 100644
--- a/guidance/library/_gen.py
+++ b/guidance/library/_gen.py
@@ -16,7 +16,7 @@ def gen(
     lm,
     name=None,
     *,
-    max_tokens=1e10,
+    max_tokens=None,
     list_append=False,
     regex=None,
     tools=None,
@@ -174,7 +174,7 @@ def gen(
                     break
         return lm
 
-    pattern = Gen(body_regex=regex, stop_regex=gen_stop, save_stop_text=save_stop_text, name=tagged_name, max_tokens=max_tokens)
+    pattern = Gen(body_regex=regex, stop_regex=gen_stop, save_stop_text=save_stop_text, capture_name=tagged_name, max_tokens=max_tokens)
 
     # define any capture group for non-tool calls
     if name is not None and tools is None:
diff --git a/guidance/library/_json.py b/guidance/library/_json.py
index 61019e16a..3e504960b 100644
--- a/guidance/library/_json.py
+++ b/guidance/library/_json.py
@@ -1,1325 +1,35 @@
-from json import dumps as json_dumps, loads as json_loads
-from enum import Enum
-import math
+from json import loads as json_loads, dumps as json_dumps
 from typing import (
     Any,
-    Callable,
     Mapping,
     Optional,
-    Sequence,
     Union,
     Type,
     TYPE_CHECKING,
     cast,
 )
 import warnings
-import referencing
-from collections import defaultdict
-import urllib.parse
-import functools
+import pydantic
 
-from .._guidance import guidance
-from ..library import optional, sequence
-from ..library._regex_utils import rx_int_range, rx_float_range
+from llguidance import JsonCompiler
 
-from .._grammar import GrammarFunction, select, with_temperature, Not, And, quote_regex
+from .._grammar import LLGrammar, with_temperature, capture
 from ._pydantic import pydantic_to_json_schema
-from ._subgrammar import as_regular_grammar, lexeme, subgrammar
 
-try:
-    import jsonschema
-    import pydantic
-except ImportError:
-    if TYPE_CHECKING:
-        raise
+JSONSchema = Mapping[str, Any]
 
-JSONSchema = Union[bool, dict[str, Any]]
-
-DRAFT202012_RESERVED_KEYWORDS = {
-    # Anchors and References
-    '$anchor',
-    '$dynamicAnchor',
-    '$dynamicRef',
-    '$id',
-    '$recursiveAnchor',
-    '$recursiveRef',
-    '$ref',
-    '$schema',
-    '$vocabulary',
-
-    # Schema Structure and Combining Schemas
-    '$defs',
-    'allOf',
-    'anyOf',
-    'definitions',
-    'dependencies',
-    'dependentRequired',
-    'dependentSchemas',
-    'else',
-    'if',
-    'not',
-    'oneOf',
-    'then',
-
-    # Validation Keywords for Any Instance Type
-    'const',
-    'enum',
-    'type',
-
-    # Validation Keywords for Numeric Instances
-    'exclusiveMaximum',
-    'exclusiveMinimum',
-    'maximum',
-    'minimum',
-    'multipleOf',
-
-    # Validation Keywords for Strings
-    'format',
-    'maxLength',
-    'minLength',
-    'pattern',
-
-    # Validation Keywords for Arrays
-    'contains',
-    'items',
-    'maxContains',
-    'maxItems',
-    'minContains',
-    'minItems',
-    'prefixItems',
-    'uniqueItems',
-
-    # Validation Keywords for Objects
-    'additionalProperties',
-    'maxProperties',
-    'minProperties',
-    'patternProperties',
-    'properties',
-    'propertyNames',
-    'required',
-    'unevaluatedItems',
-    'unevaluatedProperties',
-
-    # Metadata Keywords
-    '$comment',
-    'default',
-    'deprecated',
-    'description',
-    'examples',
-    'readOnly',
-    'title',
-    'writeOnly',
-
-    # Content Validation
-    'contentEncoding',
-    'contentMediaType',
-    'contentSchema',
-}
-
-class JSONType(str, Enum):
-    NULL = "null"
-    BOOLEAN = "boolean"
-    INTEGER = "integer"
-    NUMBER = "number"
-    STRING = "string"
-    ARRAY = "array"
-    OBJECT = "object"
-
-class Keyword(str, Enum):
-    ANYOF = "anyOf"
-    ALLOF = "allOf" # Note: Partial support. Only supports exactly one item.
-    ONEOF = "oneOf" # Note: Partial support. This is converted to anyOf.
-    ID = "$id"
-    REF = "$ref"
-    CONST = "const"
-    ENUM = "enum"
-    TYPE = "type"
-
-class NumberKeywords(str, Enum):
-    MINIMUM = "minimum"
-    MAXIMUM = "maximum"
-    EXCLUSIVE_MINIMUM = "exclusiveMinimum"
-    EXCLUSIVE_MAXIMUM = "exclusiveMaximum"
-
-class StringKeywords(str, Enum):
-    PATTERN = "pattern"
-    FORMAT = "format"
-    MIN_LENGTH = "minLength"
-    MAX_LENGTH = "maxLength"
-
-class ArrayKeywords(str, Enum):
-    PREFIX_ITEMS = "prefixItems"
-    ITEMS = "items"
-    MIN_ITEMS = "minItems"
-    MAX_ITEMS = "maxItems"
-
-class ObjectKeywords(str, Enum):
-    PROPERTIES = "properties"
-    ADDITIONAL_PROPERTIES = "additionalProperties"
-    REQUIRED = "required"
-
-TYPE_SPECIFIC_KEYWORDS = {
-    JSONType.INTEGER: NumberKeywords,
-    JSONType.NUMBER: NumberKeywords,
-    JSONType.STRING: StringKeywords,
-    JSONType.ARRAY: ArrayKeywords,
-    JSONType.OBJECT: ObjectKeywords,
-}
-
-IGNORED_KEYS = {
-    "$anchor",
-    "$defs",
-    "$schema",
-    "id",
-    "$comment",
-    "title",
-    "default",
-    "definitions",
-    "description",
-    "examples",
-}
-
-# discriminator is part of OpenAPI 3.1, not JSON Schema itself
-# https://json-schema.org/blog/posts/validating-openapi-and-json-schema
-# TODO: While ignoring this key shouldn't lead to invalid outputs, forcing
-# the model to choose the value of the marked field before other fields
-# are generated (statefully or statelessly) would reduce grammar ambiguity
-# and possibly improve quality.
-IGNORED_KEYS.add("discriminator")
-
-WHITESPACE = {b" ", b"\t", b"\n", b"\r"}
-VALID_KEYS = set(Keyword) | set(NumberKeywords) | set(StringKeywords) | set(ArrayKeywords) | set(ObjectKeywords) | IGNORED_KEYS
-
-FORMAT_PATTERNS: dict[str, Optional[str]] = {
-    # https://json-schema.org/understanding-json-schema/reference/string#built-in-formats
-    # Dates and times
-    "date-time": (
-        r'(?P<date>[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01]))'
-        r'[tT]'
-        r'(?P<time>'
-            r'(?:[01][0-9]|2[0-3]):[0-5][0-9]:(?:[0-5][0-9]|60)'
-            r'(?P<time_fraction>\.[0-9]+)?'
-            r'(?P<time_zone>[zZ]|[+-](?:[01][0-9]|2[0-3]):[0-5][0-9])'
-        r')'
-    ),
-    "time": (
-        r'(?:[01][0-9]|2[0-3]):[0-5][0-9]:(?:[0-5][0-9]|60)'
-        r'(?P<time_fraction>\.[0-9]+)?'
-        r'(?P<time_zone>[zZ]|[+-](?:[01][0-9]|2[0-3]):[0-5][0-9])'
-    ),
-    "date": r'[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])',
-    "duration": (
-        r'P'                                     # Start with 'P'
-        r'(?:'                                   # Non-capturing group for main alternatives
-            r'(?P<dur_date>'                     # Named group for date duration
-                r'(?:'                           # Non-capturing group for date components
-                    r'(?P<dur_year>'             # Named group for years
-                        r'[0-9]+Y'                  # One or more digits followed by 'Y'
-                        r'(?:'                   # Optional month
-                            r'[0-9]+M'              # One or more digits followed by 'M'
-                            r'(?:[0-9]+D)?'         # Optional days
-                        r')?'
-                    r')'
-                    r'|'                         # OR
-                    r'(?P<dur_month>'            # Named group for months
-                        r'[0-9]+M'                  # One or more digits followed by 'M'
-                        r'(?:[0-9]+D)?'             # Optional days
-                    r')'
-                    r'|'                         # OR
-                    r'(?P<dur_day>'              # Named group for days
-                        r'[0-9]+D'                  # One or more digits followed by 'D'
-                    r')'
-                r')'
-                r'(?:'                           # Optional time
-                    r'T'                         # Time starts with 'T'
-                    r'(?:'                       # Non-capturing group for time components
-                        r'(?P<dur_hour>'         # Named group for hours
-                            r'[0-9]+H'              # One or more digits followed by 'H'
-                            r'(?:'               # Optional minutes
-                                r'[0-9]+M'          # One or more digits followed by 'M'
-                                r'(?:[0-9]+S)?'     # Optional seconds
-                            r')?'
-                        r')'
-                        r'|'                     # OR
-                        r'(?P<dur_minute>'       # Named group for minutes
-                            r'[0-9]+M'              # One or more digits followed by 'M'
-                            r'(?:[0-9]+S)?'         # Optional seconds
-                        r')'
-                        r'|'                     # OR
-                        r'(?P<dur_second>'       # Named group for seconds
-                            r'[0-9]+S'              # One or more digits followed by 'S'
-                        r')'
-                    r')'
-                r')?'
-            r')'
-            r'|'                                 # OR
-            r'(?P<dur_time>'                     # Named group for time-only duration
-                r'T'                             # Time starts with 'T'
-                r'(?:'                           # Non-capturing group for time components
-                    r'(?P<dur_hour2>'             # Named group for hours
-                        r'[0-9]+H'                  # One or more digits followed by 'H'
-                        r'(?:'                   # Optional minutes
-                            r'[0-9]+M'              # One or more digits followed by 'M'
-                            r'(?:[0-9]+S)?'         # Optional seconds
-                        r')?'
-                    r')'
-                    r'|'                         # OR
-                    r'(?P<dur_minute2>'           # Named group for minutes
-                        r'[0-9]+M'                  # One or more digits followed by 'M'
-                        r'(?:[0-9]+S)?'             # Optional seconds
-                    r')'
-                    r'|'                         # OR
-                    r'(?P<dur_second2>'           # Named group for seconds
-                        r'[0-9]+S'                  # One or more digits followed by 'S'
-                    r')'
-                r')'
-            r')'
-            r'|'                                 # OR
-            r'(?P<dur_week>'                     # Named group for weeks
-                r'[0-9]+W'                          # One or more digits followed by 'W'
-            r')'
-        r')'
-    ),
-    # Email addresses
-    "email": (
-        r'(?P<local_part>'
-            r'(?P<dot_string>'
-                r'[^\s@\.]+'
-                r'(\.[^\s@\.]+)*'
-            r')'
-            # TODO: Add support for quoted strings
-        r')'
-        r'@'
-        r'('
-            r'(?P<domain>'
-                r'(?P<sub_domain>'
-                    r'[a-zA-Z0-9]'
-                    r'([a-zA-Z0-9-]*[a-zA-Z0-9])?'
-                r')'
-                r'(\.(?P<sub_domain2>'
-                    r'[a-zA-Z0-9]'
-                    r'([a-zA-Z0-9-]*[a-zA-Z0-9])?'
-                r'))*'
-            r')'
-            r'|' # OR
-            r'\[(?P<ipv4>((([0-9])|(([1-9])[0-9]|(25[0-5]|(2[0-4]|(1)[0-9])[0-9])))\.){3}(([0-9])|(([1-9])[0-9]|(25[0-5]|(2[0-4]|(1)[0-9])[0-9]))))\]'
-        r')'
-    ),
-    "idn-email": None,
-    # Hostnames
-    "hostname": r"[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*",
-    "idn-hostname": None,
-    "ipv4": r'((([0-9])|(([1-9])[0-9]|(25[0-5]|(2[0-4]|(1)[0-9])[0-9])))\.){3}(([0-9])|(([1-9])[0-9]|(25[0-5]|(2[0-4]|(1)[0-9])[0-9])))',
-    "ipv6": (
-        # Full IPv6 address without "::"
-        r'(?:'
-            r'(?P<full>(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4})'
-        r')'
-        r'|'  # OR
-        # Leading "::" (shortens leading zeros)
-        r'(?:'
-            r'::(?:[0-9a-fA-F]{1,4}:){0,5}(?P<ls32>[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4})'
-        r')'
-        r'|'  # OR
-        # "::" within the address, and variants reducing the length of the address
-        r'(?:'
-            r'(?P<h16_1>[0-9a-fA-F]{1,4})?::(?:[0-9a-fA-F]{1,4}:){0,4}(?P<ls32_1>[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4})'
-        r')'
-        r'|'  # OR
-        r'(?:'
-            r'((?:[0-9a-fA-F]{1,4}:){0,1}[0-9a-fA-F]{1,4})?::(?:[0-9a-fA-F]{1,4}:){0,3}(?P<ls32_2>[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4})'
-        r')'
-        r'|'  # OR
-        r'(?:'
-            r'((?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4})?::(?:[0-9a-fA-F]{1,4}:){0,2}(?P<ls32_3>[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4})'
-        r')'
-        r'|'  # OR
-        r'(?:'
-            r'((?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4})?::[0-9a-fA-F]{1,4}:(?P<ls32_4>[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4})'
-        r')'
-        r'|'  # OR
-        r'(?:'
-            r'((?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4})?::(?P<ls32_5>[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4})'
-        r')'
-        r'|'  # OR
-        r'(?:'
-            r'((?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4})?::(?P<h16_2>[0-9a-fA-F]{1,4})'
-        r')'
-        r'|'  # OR
-        r'(?:'
-            r'((?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4})?::'
-        r')'
-    ),
-    # Resource identifiers
-    "uuid": (
-        r'(?P<time_low>[0-9a-fA-F]{8})'      # 4 hex octets for time-low
-        r'-'                                 # Literal hyphen
-        r'(?P<time_mid>[0-9a-fA-F]{4})'      # 2 hex octets for time-mid
-        r'-'                                 # Literal hyphen
-        r'(?P<time_high_and_version>[0-9a-fA-F]{4})'  # 2 hex octets for time-high-and-version
-        r'-'                                 # Literal hyphen
-        r'(?P<clock_seq_and_reserved>[0-9a-fA-F]{2})' # 1 hex octet for clock-seq-and-reserved
-        r'(?P<clock_seq_low>[0-9a-fA-F]{2})' # 1 hex octet for clock-seq-low
-        r'-'                                 # Literal hyphen
-        r'(?P<node>[0-9a-fA-F]{12})'         # 6 hex octets for node
-    ),
-    "uri": None,
-    "uri-reference": None,
-    "iri": None,
-    "iri-reference": None,
-    # URI template
-    "uri-template": None,
-    # JSON pointers
-    "json-pointer": None,
-    "relative-json-pointer": None,
-    # Regular expressions
-    "regex": None, # Might need a full CFG?,
-    # Unknown
-    "unknown": r"(?s:.*)",
-}
-
-
-def urijoin(base: str, uri: str) -> str:
-    # Special case for fragment-only URIs
-    if uri.startswith("#"):
-        return f"{base}{uri}"
-    return urllib.parse.urljoin(base, uri)
-
-
-def _get_format_pattern(format: str) -> str:
-    try:
-        pattern = FORMAT_PATTERNS[format]
-    except KeyError:
-        raise ValueError(f"Format {format!r} is not supported")
-    if pattern is None:
-        raise NotImplementedError(f"Format {format!r} is not yet supported")
-    return pattern
-
-
-def validate_json_node_keys(node: Mapping[str, Any]):
-    keys = set(node.keys())
-    # Any key that is a valid JSON schema keyword but not one that we have explicit support for is "invalid"
-    invalid_keys = (keys - VALID_KEYS).intersection(DRAFT202012_RESERVED_KEYWORDS)
-    if invalid_keys:
-        raise ValueError(
-            f"JSON schema had keys that could not be processed: {invalid_keys}" f"\nSchema: {node}"
-        )
-
-
-def get_sibling_keys(node: Mapping[str, Any], key: str) -> set[str]:
-    # Get the set of functional (non-ignored) keys that are siblings of the given key
-    return set(node.keys()) & VALID_KEYS - set(IGNORED_KEYS) - {key}
-
-
-def check_number_bounds(minimum: Union[float, int, None], maximum: Union[float, int, None], exclusiveMinimum: bool, exclusiveMaximum: bool):
-    if minimum is not None and maximum is not None:
-        if minimum > maximum:
-            raise UnsatisfiableSchemaError(f"minimum ({minimum}) is greater than maximum ({maximum})")
-        if minimum == maximum and (exclusiveMinimum or exclusiveMaximum):
-            minimum_repr = f"exclusiveMinimum ({minimum})" if exclusiveMinimum else f"minimum ({minimum})"
-            maximum_repr = f"exclusiveMaximum ({maximum})" if exclusiveMaximum else f"maximum ({maximum})"
-            raise UnsatisfiableSchemaError(f"{minimum_repr} is equal to {maximum_repr}")
-
-
-class UnsatisfiableSchemaError(ValueError):
-    pass
-
-class GenJson:
-    item_separator = ", "
-    key_separator = ": "
-    def __init__(self, schema: JSONSchema, separators: Optional[tuple[str, str]] = None) -> None:
-        self.schema = schema
-        if separators is not None:
-            self.item_separator, self.key_separator = separators
-
-        registry: referencing.Registry[JSONSchema] = referencing.Registry()
-        resource: referencing.Resource[JSONSchema] = referencing.jsonschema.DRAFT202012.create_resource(schema)
-        self._base_uri = resource.id() or ""
-        registry = registry.with_resource(
-            uri=self._base_uri,
-            resource=resource
-        )
-        self._resolver = registry.resolver()
-        self._defs: dict[str, Callable[[], GrammarFunction]] = {}
-
-
-    @guidance(stateless=True)
-    def ref(
-        self,
-        lm,
-        *,
-        reference: str,
-        base_uri: str,
-    ):
-        """
-        Resolve a reference to another schema and return the grammar for that schema.
-
-        Note: we define a zero-argument closure that will return the grammar for the reference and
-        add it to the _defs cache. This allows us to avoid re-resolving the reference every time
-        and to handle recursive references correctly.
-        """
-        abspath = urijoin(base_uri, reference)
-
-        if abspath not in self._defs:
-            resolved = self._resolver.lookup(abspath)
-            base_uri_of_resolved = resolved.resolver._base_uri
-
-            @guidance(stateless=True, dedent=False, cache=True)
-            def closure(lm):
-                grammar = self.json(json_schema=resolved.contents, base_uri=base_uri_of_resolved)
-                return lm + grammar
-
-            self._defs[abspath] = closure
-        return lm + self._defs[abspath]()
-
-
-    @guidance(stateless=True)
-    def root(self, lm):
-        return lm + self.json(json_schema=self.schema, base_uri=self._base_uri)
-
-
-    @classmethod
-    @guidance(stateless=True)
-    def integer(cls, lm, minimum: Union[float, int, None] = None, maximum: Union[float, int, None] = None, exclusiveMinimum: bool = False, exclusiveMaximum: bool = False):
-        check_number_bounds(minimum, maximum, exclusiveMinimum, exclusiveMaximum)
-
-        if minimum is not None:
-            if exclusiveMinimum:
-                if minimum != int(minimum):
-                    minimum = math.ceil(minimum)
-                else:
-                    minimum += 1
-            else:
-                minimum = math.ceil(minimum)
-            minimum = int(minimum)
-        if maximum is not None:
-            if exclusiveMaximum:
-                if maximum != int(maximum):
-                    maximum = math.floor(maximum)
-                else:
-                    maximum -= 1
-            else:
-                maximum = math.floor(maximum)
-            maximum = int(maximum)
-
-        return lm + lexeme(rx_int_range(minimum, maximum), contextual=True)
-
-
-    @classmethod
-    @guidance(stateless=True)
-    def number(cls, lm, minimum: Optional[float] = None, maximum: Optional[float] = None, exclusiveMinimum: bool = False, exclusiveMaximum: bool = False):
-        check_number_bounds(minimum, maximum, exclusiveMinimum, exclusiveMaximum)
-
-        return lm + lexeme(
-            rx_float_range(
-                minimum, maximum,
-                left_inclusive = not exclusiveMinimum,
-                right_inclusive = not exclusiveMaximum
-            ),
-            contextual=True
-        )
-
-
-    @classmethod
-    @guidance(stateless=True)
-    def string(
-        cls,
-        lm,
-        *,
-        min_length: int = 0,
-        max_length: Union[int, None] = None,
-        regex: Union[str, None] = None,
-        format: Union[str, None] = None,
-    ):
-        if min_length is not None and max_length is not None and min_length > max_length:
-            raise UnsatisfiableSchemaError(f"String minLength ({min_length}) is greater than maxLength ({max_length})")
-
-        if (regex is not None or format is not None) and (min_length > 0 or max_length is not None):
-            raise ValueError(
-                "If a pattern or format is specified for a JSON string, minLength and maxLength must be left unspecified."
-            )
-
-        if regex is not None and format is not None:
-            raise ValueError("Cannot specify both a regex and a format for a JSON string")
-
-        if format is not None:
-            regex = _get_format_pattern(format)
-
-        elif regex is not None:
-            # Sanitize the regex, removing unnecessary anchors that may cause problems later
-            # NOTE/TODO: this could potentially be pushed further down into the lexeme function,
-            # but it's not immediately clear whether anchors in other contexts are superfluous.
-            regex = regex.lstrip("^").rstrip("$")
-
-        elif regex is None:
-            range_expr = f"{{{min_length},{max_length}}}" if max_length is not None else f"{{{min_length},}}"
-            regex = f"(?s:.{range_expr})"
-
-        return lm + lexeme(regex, contextual=True, json_string=True)
-
-
-    @guidance(stateless=True)
-    def object(
-        self,
-        lm,
-        *,
-        properties: Mapping[str, JSONSchema],
-        additional_properties: JSONSchema,
-        required: Sequence[str],
-        base_uri: str,
-    ):
-        illegal_keys = set()
-        property_grammars: dict[str, GrammarFunction] = {}
-        for name, schema in properties.items():
-            try:
-                property_grammars[name] = self.json(json_schema=schema, base_uri=base_uri)
-            except UnsatisfiableSchemaError as e:
-                # We get here if the schema is a literal False or is otherwise determined to be unsatisfiable
-                if name in required:
-                    raise UnsatisfiableSchemaError(f"Required property {name!r} is unsatisfiable") from e
-                # If the property is not required, we will just "blacklist" this key (e.g. if the schema was False)
-                # Note that we're just dropping this exception.
-                # Use json_dumps to properly quote / escape the key before adding it to the blacklist
-                key = json_dumps(name)
-                illegal_keys.add(key)
-
-        additional_properties_grammar: Optional[GrammarFunction] = None
-        try:
-            additional_properties_grammar = self.json(json_schema=additional_properties, base_uri=base_uri)
-        except UnsatisfiableSchemaError as e:
-            if any(k not in properties for k in required):
-                # "required" keys will be validated against "properties" if they're present, otherwise against "additionalProperties".
-                # If "additionalProperties" is unsatisfiable, then required keys must be in "properties".
-                raise UnsatisfiableSchemaError(
-                    f"Required properties not in properties but additionalProperties is unsatisfiable."
-                    f" Missing required properties: {list(r for r in required if r not in properties)}"
-                ) from e
-            else:
-                # If "additionalProperties" is unsatisfiable but there are no required properties that need to be validated against it,
-                # then we can safely ignore it. Note that this means that we are just going to drop this exception.
-                pass
-
-        keys: list[str] = []
-        required_items: list[bool] = []
-        item_grammars: list[GrammarFunction] = []
-        # First iterate over the properties in order, then iterate over any missing required keys, using additional_properties as the schema
-        for name in (*property_grammars.keys(), *(r for r in required if r not in properties)):
-            # Use json_dumps to properly quote / escape the key
-            key = json_dumps(name)
-            keys.append(key)
-            # Identify if the key is required
-            required_items.append(name in required)
-            # Build the grammar we'll use for this property
-            item_grammars.append(f'{key}{self.key_separator}' + property_grammars.get(name, cast(GrammarFunction, additional_properties_grammar)))
-
-        if additional_properties is not False:
-            # Key for additionalProperties is a json string, but we need to disallow any properties that are already defined
-            additional_key_grammar: GrammarFunction
-            if len(keys) > 0:
-                additional_key_grammar = as_regular_grammar(
-                    And([
-                        lexeme(r'"([^"\\]|\\["\\/bfnrt]|\\u[0-9a-fA-F]{4})*"'),
-                        Not(lexeme('|'.join(map(quote_regex, (*keys, *illegal_keys))))),
-                    ]),
-                    lexeme = True,
-                )
-            else:
-                additional_key_grammar = self.string()
-
-            if additional_properties_grammar is not None:
-                additional_item_grammar = additional_key_grammar + self.key_separator + additional_properties_grammar
-                additional_items_grammar = sequence(additional_item_grammar + self.item_separator) + additional_item_grammar
-                item_grammars.append(additional_items_grammar)
-                required_items.append(False)
-
-        return lm + "{" + self._join(
-            elements = tuple(item_grammars),
-            required = tuple(required_items),
-        ) + "}"
-
-
-    @guidance(stateless=True, cache=True)
-    def _join(self, lm, *, elements: tuple[GrammarFunction, ...], required: tuple[bool, ...], prefixed: bool = False):
-        if not elements:
-            return lm
-
-        elem, elements = elements[0], elements[1:]
-        is_required, required = required[0], required[1:]
-
-        if prefixed:
-            if is_required:
-                # If we know we have preceeding elements, we can safely just add a (',' + e)
-                return lm + (self.item_separator + elem + self._join(elements=elements, required=required, prefixed=True))
-            # If we know we have preceeding elements, we can safely just add an optional(',' + e)
-            return lm + (optional(self.item_separator + elem) + self._join(elements=elements, required=required, prefixed=True))
-        if is_required:
-            # No preceding elements, and our element is required, so we just add the element
-            return lm + (elem + self._join(elements=elements, required=required, prefixed=True))
-
-        # No preceding elements, and our element is optional, so we add a select between the two options.
-        # The first option is the recursive call with no preceding elements, the second is the recursive call
-        # with the current element as a prefix.
-        return lm + select([
-            self._join(elements=elements, required=required, prefixed=False),
-            elem + self._join(elements=elements, required=required, prefixed=True)
-        ])
-
-
-    @guidance(stateless=True)
-    def array(
-        self,
-        lm,
-        *,
-        prefix_items_schema: Sequence[JSONSchema],
-        item_schema: JSONSchema,
-        min_items: int,
-        max_items: Optional[int],
-        base_uri: str,
-    ):
-        if max_items is not None and min_items > max_items:
-            raise UnsatisfiableSchemaError(f"minItems ({min_items}) is greater than maxItems ({max_items})")
-
-        items_grammar: Optional[GrammarFunction] = None
-        try:
-            items_grammar = self.json(json_schema=item_schema, base_uri=base_uri)
-        except UnsatisfiableSchemaError as e:
-            if len(prefix_items_schema) < min_items:
-                raise UnsatisfiableSchemaError(
-                    f"prefixItems has too few elements ({len(prefix_items_schema)}) to satisfy minItems ({min_items})"
-                    f" but item schema is unsatisfiable"
-                ) from e
-            else:
-                # If we've already satisfied min_items, we can just ignore the unsatisfiable item schema. This just means
-                # that we can't generate any more items after the prefix items.
-                # Note that this means that we are just going to drop this exception.
-                pass
-
-        required_items = []
-        optional_items = []
-
-        # If max_items is None, we can add an infinite tail of items later
-        n_to_add = max(len(prefix_items_schema), min_items) if max_items is None else max_items
-        for i in range(n_to_add):
-            if i < len(prefix_items_schema):
-                try:
-                    item = self.json(json_schema=prefix_items_schema[i], base_uri=base_uri)
-                except UnsatisfiableSchemaError as e:
-                    # i corresponds to the number of items we've already satisfied
-                    if i < min_items:
-                        raise UnsatisfiableSchemaError(f"prefixItems[{i}] is unsatisfiable but min_items is {min_items}") from e
-                    # Having an unsatisfiable prefix item is fine if we've already satisfied min_items, but this effectively sets max_items to i
-                    # Note that this means that we are just going to drop this exception.
-                    max_items = i
-                    break
-
-            elif items_grammar is not None:
-                item = items_grammar
-            else:
-                assert i >= min_items
-                break
-
-            if i < min_items:
-                required_items.append(item)
-            else:
-                optional_items.append(item)
-
-        if max_items is None and items_grammar is not None:
-            # Add an infinite tail of items
-            optional_items.append(items_grammar + sequence(self.item_separator + items_grammar))
-
-        lm += "["
-
-        if required_items:
-            first, *rest = required_items
-            lm += first
-            for item in rest:
-                lm += self.item_separator + item
-
-        if optional_items:
-            # This is a bit subtle and would not be required if not for prefixItems -- the previous
-            # must be present before the next one may be added, meaning we have nested optionals:
-            # (first optional(,second optional(,third (optional(,...)))))
-            first, *rest = optional_items
-            tail: Union[str, GrammarFunction] = ""
-            for item in reversed(rest):
-                tail = optional(self.item_separator + item + tail)
-            tail = first + tail
-
-            if required_items:
-                lm += optional(self.item_separator + tail)
-            else:
-                lm += optional(tail)
-
-        lm += "]"
-        return lm
-
-
-    @guidance(stateless=True)
-    def anyOf(
-        self,
-        lm,
-        *,
-        anyof_list: Sequence[JSONSchema],
-        base_uri: str,
-    ):
-        if not anyof_list:
-            raise UnsatisfiableSchemaError("anyOf has no schemas")
-
-        options: list[GrammarFunction] = []
-        for item in anyof_list:
-            try:
-                options.append(self.json(json_schema=item, base_uri=base_uri))
-            except UnsatisfiableSchemaError:
-                # No need to raise an error if one of the schemas is unsatisfiable. We'll check again at the end and raise if ALL
-                # schemas are unsatisfiable. Note that this means that we are just going to drop this exception.
-                pass
-        if not options:
-            # Can't really point to any one schema that's unsatisfiable, so let's include all the schemas in the error message
-            raise UnsatisfiableSchemaError("all anyOf schemas are unsatisfiable: " + json_dumps(anyof_list))
-        return lm + select(options)
-
-    @guidance(stateless=True)
-    def oneOf(
-        self,
-        lm,
-        *,
-        oneof_list: Sequence[JSONSchema],
-        base_uri: str,
-    ):
-        if not oneof_list:
-            raise UnsatisfiableSchemaError("oneOf has no schemas")
-        if len(oneof_list) == 1:
-            return lm + self.json(json_schema=oneof_list[0], base_uri=base_uri)
-        warnings.warn("oneOf not fully supported, falling back to anyOf. This may cause validation errors in some cases.")
-        return lm + self.anyOf(anyof_list=oneof_list, base_uri=base_uri)
-
-    def push_sibling_keys(self, json_schema: dict[str, Any]) -> dict[str, Any]:
-        """
-        If sibling keys are present next to anyOf, oneOf, or $ref, we push them down into an allOf.
-        """
-        parent_schema = json_schema.copy()
-        anyof_list = parent_schema.pop(Keyword.ANYOF, [])
-        oneof_list = parent_schema.pop(Keyword.ONEOF, [])
-        allof_list = parent_schema.pop(Keyword.ALLOF, [])
-        ref = parent_schema.pop(Keyword.REF, None)
-
-        common = []
-        if VALID_KEYS.intersection(parent_schema) - set(IGNORED_KEYS):
-            # If there are any sibling keys, we need to push them down into an allOf
-            common.append(parent_schema)
-        if allof_list:
-            common.extend(allof_list)
-        if ref:
-            # TODO: $id / base_uri?
-            common.append({Keyword.REF: ref})
-
-        if anyof_list and oneof_list:
-            return {
-                "oneOf": [
-                    {"allOf": common + [one_item, any_item]}
-                    for one_item in oneof_list
-                    for any_item in anyof_list
-                ],
-            }
-
-        if oneof_list:
-            if not common:
-                return {"oneOf": oneof_list}
-            return {
-                "oneOf": [
-                    {"allOf": common + [one_item]}
-                    for one_item in oneof_list
-                ],
-            }
-
-        if anyof_list:
-            if not common:
-                return {"anyOf": anyof_list}
-            return {
-                "anyOf": [
-                    {"allOf": common + [any_item]}
-                    for any_item in anyof_list
-                ],
-            }
-
-        if len(common) == 1:
-            return common[0]
-
-        return {"allOf": common}
-
-    def reduce_schema(self, orig_schema: dict[str, Any], base_uri: str) -> dict[str, Any]:
-        types: list[set[str]] = []
-        properties: defaultdict[str, list[JSONSchema]] = defaultdict(list)
-        required: dict[str, None] = dict() # use a dict for ordered-set behavior
-        additional_properties_list: list[tuple[JSONSchema, set[str]]] = []
-        prefix_items: defaultdict[int, list[JSONSchema]] = defaultdict(list)
-        items_list: list[tuple[JSONSchema, set[int]]] = []
-        other_data: dict[str, Any] = {}
-        enums: list[Sequence[Any]] = []
-        consts: list[Any] = []
-
-        def handle_keyword(key: str, value: Any, parent_schema: dict[str, Any], base_uri: str):
-            if key == Keyword.ANYOF:
-                raise NotImplementedError("anyOf in allOf not yet supported")
-
-            elif key == Keyword.ONEOF:
-                raise NotImplementedError("oneOf in allOf not yet supported")
-
-            elif key == Keyword.ALLOF:
-                value = cast(Sequence[JSONSchema], value)
-                for schema in value:
-                    add_schema(schema, base_uri)
-
-            elif key == Keyword.REF:
-                ref = cast(str, value)
-                abspath = urijoin(base_uri, ref)
-                resolved = self._resolver.lookup(abspath)
-                add_schema(resolved.contents, base_uri=resolved.resolver._base_uri)
-
-            elif key == Keyword.CONST:
-                consts.append(value)
-
-            elif key == Keyword.ENUM:
-                value = cast(list[Any], value)
-                enums.append(value)
-
-            elif key == Keyword.TYPE:
-                value = cast(Union[str, Sequence[str]], value)
-                if isinstance(value, str):
-                    value_set = {value}
-                else:
-                    value_set = set(value)
-                types.append(value_set)
-
-            elif key == ObjectKeywords.PROPERTIES:
-                value = cast(dict[str, JSONSchema], value)
-                for name, schema in value.items():
-                    if isinstance(schema, dict):
-                        this_base_uri = schema.get(Keyword.ID, base_uri)
-                        if Keyword.REF in schema:
-                            # Make the ref absolute so that it can be resolved in the right scope later
-                            schema = schema.copy()
-                            schema[Keyword.REF] = urijoin(this_base_uri, schema[Keyword.REF])
-                    properties[name].append(schema)
-
-            elif key == ObjectKeywords.REQUIRED:
-                value = cast(Sequence[str], value)
-                required.update({name: None for name in value})
-
-            elif key == ObjectKeywords.ADDITIONAL_PROPERTIES:
-                # TODO: unevaluatedProperties?
-                value = cast(JSONSchema, value)
-                # We need to keep track of which properties are exempt from this additionalProperties schema,
-                # i.e. the ones defined in the parent schema
-                exempt_properties: set[str] = set()
-                if ObjectKeywords.PROPERTIES in parent_schema:
-                    exempt_properties = set(parent_schema[ObjectKeywords.PROPERTIES])
-                additional_properties_list.append(
-                    (value, exempt_properties)
-                )
-
-            elif key == ArrayKeywords.PREFIX_ITEMS:
-                value = cast(Sequence[JSONSchema], value)
-                for i, schema in enumerate(value):
-                    prefix_items[i].append(schema)
-
-            elif key == ArrayKeywords.ITEMS:
-                # TODO: unevaluatedItems?
-                value = cast(JSONSchema, value)
-                # We need to keep track of which prefixItems are exempt from this additionalItems schema,
-                # i.e. the ones defined in the parent schema
-                exempt_prefix_items: set[int] = set()
-                if ArrayKeywords.PREFIX_ITEMS in parent_schema:
-                    exempt_prefix_items = set(range(len(parent_schema[ArrayKeywords.PREFIX_ITEMS])))
-                items_list.append(
-                    (value, exempt_prefix_items)
-                )
-
-            elif key in other_data:
-                if key in {
-                    NumberKeywords.MINIMUM, NumberKeywords.EXCLUSIVE_MINIMUM,
-                    StringKeywords.MIN_LENGTH, ArrayKeywords.MIN_ITEMS
-                }:
-                    other_data[key] = max(other_data[key], value)
-                elif key in {
-                    NumberKeywords.MAXIMUM, NumberKeywords.EXCLUSIVE_MAXIMUM,
-                    StringKeywords.MAX_LENGTH, ArrayKeywords.MAX_ITEMS
-                }:
-                    other_data[key] = min(other_data[key], value)
-                else:
-                    raise NotImplementedError(f"Don't yet know how to reduce multiple values of {key!r} in allOf")
-
-            else:
-                other_data[key] = value
-
-        def add_schema(schema: JSONSchema, base_uri: str):
-            if schema is True:
-                return
-            if schema is False:
-                raise UnsatisfiableSchemaError("allOf contains a 'false' schema")
-
-            # Validate the schema's keys (we have only validated the parent schema's keys so far)
-            # TODO: This will make us validate the parent twice... should probably be refactored
-            validate_json_node_keys(schema)
-
-            # Set the base_uri for this schema
-            if Keyword.ID in schema:
-                # TODO: avoid copies if possible..?
-                schema = schema.copy()
-                base_uri = urijoin(base_uri, schema.pop(Keyword.ID))
-
-            for key, value in schema.items():
-                if key in IGNORED_KEYS:
-                    continue
-                handle_keyword(key, value, schema, base_uri)
-
-        add_schema(orig_schema, base_uri)
-
-        combined_schema: dict[str, Any] = {}
-
-        # Post-process additional_properties to make sure we apply the additional properties of one
-        # schema to the properties of another schema
-        for additional_schema, exempt_properties in additional_properties_list:
-            for name in set(properties) - exempt_properties:
-                properties[name].append(additional_schema)
-
-        # Post-process items to make sure we apply the additional items of one schema to the prefix items of another schema
-        for additional_schema, exempt_prefix_items in items_list:
-            for i in set(prefix_items) - exempt_prefix_items:
-                prefix_items[i].append(additional_schema)
-
-        if properties:
-            combined_schema[ObjectKeywords.PROPERTIES] = {}
-            for name, schemas in properties.items():
-                if len(schemas) == 1:
-                    combined_schema[ObjectKeywords.PROPERTIES][name] = schemas[0]
-                else:
-                    combined_schema[ObjectKeywords.PROPERTIES][name] = {"allOf": schemas}
-
-        if required:
-            combined_schema[ObjectKeywords.REQUIRED] = list(required.keys())
-
-        if additional_properties_list:
-            if len(additional_properties_list) == 1:
-                combined_schema[ObjectKeywords.ADDITIONAL_PROPERTIES], _ = additional_properties_list[0]
-            else:
-                combined_schema[ObjectKeywords.ADDITIONAL_PROPERTIES] = {"allOf": [schema for schema, _ in additional_properties_list]}
-
-        if prefix_items:
-            combined_schema[ArrayKeywords.PREFIX_ITEMS] = []
-            for i in range(len(prefix_items)):
-                schemas = prefix_items[i]
-                if len(schemas) == 1:
-                    combined_schema[ArrayKeywords.PREFIX_ITEMS].append(schemas[0])
-                else:
-                    combined_schema[ArrayKeywords.PREFIX_ITEMS].append({"allOf": schemas})
-
-        if items_list:
-            if len(items_list) == 1:
-                combined_schema[ArrayKeywords.ITEMS], _ = items_list[0]
-            else:
-                combined_schema[ArrayKeywords.ITEMS] = {"allOf": [schema for schema, _ in items_list]}
-
-        if enums:
-            if len(enums) == 1:
-                enum = enums[0]
-            else:
-                def reduce_enums(enum_a, enum_b):
-                    try:
-                        enum = list(set(enum_a) & set(enum_b))
-                    except TypeError:
-                        # Check on equality, not on hash
-                        # Yes, this is O(n^2).
-                        # Hope the items were unique.
-                        # ¯\_(ツ)_/¯
-                        enum = [a for a in enum_a for b in enum_b if a == b]
-                    return enum
-                enum = functools.reduce(reduce_enums, enums)
-            if not enum:
-                raise UnsatisfiableSchemaError(f"allOf has enums with no common values: {enums}")
-            combined_schema[Keyword.ENUM] = enum
-
-        if consts:
-            const, *rest = consts
-            for c in rest:
-                if c != const:
-                    raise UnsatisfiableSchemaError(f"allOf has consts with different values: {consts}")
-            combined_schema[Keyword.CONST] = const
-
-        if types:
-            if len(types) == 1:
-                type = list(types[0])
-            else:
-                def reduce_types(type_a: set[str], type_b: set[str]) -> set[str]:
-                    common_types = type_a & type_b
-                    # Integer is a "subtype" of number, so ensure we keep integer if we have "number" in one and "integer" in the other
-                    if JSONType.INTEGER not in common_types and (
-                        (JSONType.NUMBER in type_a and JSONType.INTEGER in type_b) or
-                        (JSONType.INTEGER in type_a and JSONType.NUMBER in type_b)
-                    ):
-                        common_types.add(JSONType.INTEGER)
-                    return common_types
-                type = list(functools.reduce(reduce_types, types)) # type: ignore[arg-type]
-                if not type:
-                    raise UnsatisfiableSchemaError(f"allOf has conflicting types: {types}")
-            combined_schema[Keyword.TYPE] = type
-
-        assert not set(combined_schema) & set(other_data)
-        combined_schema.update(other_data)
-        return combined_schema
-
-
-    @guidance(stateless=True)
-    def allOf(
-        self,
-        lm,
-        *,
-        parent_schema: dict[str, Any],
-        base_uri: str,
-    ):
-        reduced_schema = self.reduce_schema(parent_schema, base_uri)
-        return lm + self.json(json_schema=reduced_schema, base_uri=base_uri)
-
-
-    @guidance(stateless=True)
-    def const(
-        self,
-        lm,
-        *,
-        value: Union[None, bool, int, float, str, Mapping, Sequence],
-        parent_schema: JSONSchema,
-    ):
-        try:
-            jsonschema.validate(
-                instance=value,
-                schema=parent_schema,
-            )
-        except jsonschema.ValidationError as e:
-            raise UnsatisfiableSchemaError(f"const {value!r} is inconsistent with parent schema: {parent_schema}") from e
-        # Base case
-        if isinstance(value, (type(None), bool, int, float, str)):
-            return lm + json_dumps(value)
-        # Recursive cases
-        # NOTE: we could potentially just use json_dumps in all cases, but this will ensure that we're
-        # properly treating all parts as individual lexemes, which makes whitespace flexibility possible
-        if isinstance(value, Mapping):
-            return lm + self.json(
-                json_schema={
-                    "type": "object",
-                    "properties": {k: {"const": v} for k, v in dict(value).items()},
-                    "required": list(value.keys()),
-                    "additionalProperties": False,
-                },
-                base_uri="", # dummy value -- we don't need to resolve anything
-            )
-        if isinstance(value, Sequence):
-            return lm + self.json(
-                json_schema={
-                    "type": "array",
-                    "prefixItems": [{"const": v} for v in list(value)],
-                    "minItems": len(value),
-                    "maxItems": len(value),
-                    "items": False,
-                },
-                base_uri="", # dummy value -- we don't need to resolve anything
-            )
-        raise TypeError(f"Unsupported value type: {type(value)} for value: {value!r}")
-
-    @guidance(stateless=True)
-    def enum(
-        self,
-        lm,
-        *,
-        options: Sequence[Union[None, bool, int, float, str, Mapping, Sequence]],
-        parent_schema: JSONSchema,
-    ):
-        if not options:
-            raise UnsatisfiableSchemaError("enum has no options")
-        all_opts: list[GrammarFunction] = []
-        for instance in options:
-            try:
-                grm = self.const(value=instance, parent_schema=parent_schema)
-            except UnsatisfiableSchemaError:
-                # Like anyOf, we don't want to raise an error if one of the options is unsatisfiable. We'll check again at the end
-                # and raise if ALL options are unsatisfiable. Note that this means that we are just going to drop this exception.
-                continue
-            all_opts.append(grm)
-        if not all_opts:
-            raise UnsatisfiableSchemaError(f"All enum options {options} are inconsistent with parent schema: {parent_schema}")
-        return lm + select(options=all_opts)
-
-
-    @guidance(stateless=True)
-    def any(self, lm):
-        return lm + select(
-            [
-                # Dummy base uris ok since we're not resolving anything
-                self.json(json_schema={"type": "null"}, base_uri=""),
-                self.json(json_schema={"type": "boolean"}, base_uri=""),
-                self.json(json_schema={"type": "integer"}, base_uri=""),
-                self.json(json_schema={"type": "number"}, base_uri=""),
-                self.json(json_schema={"type": "string"}, base_uri=""),
-                # Recursive cases
-                self.json(
-                    json_schema={
-                        "type": "array",
-                        "items": True,
-                    },
-                    base_uri="",
-                ),
-                self.json(
-                    json_schema={
-                        "type": "object",
-                        "additionalProperties": True,
-                    },
-                    base_uri="",
-                ),
-            ]
-        )
-
-
-    @guidance(stateless=True)
-    def json(
-        self,
-        lm,
-        *,
-        json_schema: JSONSchema,
-        base_uri: str,
-    ):
-        if json_schema is True:
-            json_schema = {}
-        elif json_schema is False:
-            raise UnsatisfiableSchemaError("No valid JSON can be generated from a schema of `false`")
-
-        if json_schema == {}:
-            return lm + self.any()
-
-        # Early exit for simple cases
-        if Keyword.CONST in json_schema:
-            return lm + self.const(value=json_schema[Keyword.CONST], parent_schema=json_schema)
-
-        if Keyword.ENUM in json_schema:
-            return lm + self.enum(options=json_schema[Keyword.ENUM], parent_schema=json_schema)
-
-        # More complex cases; validation needed
-        validate_json_node_keys(json_schema)
-        json_schema = self.push_sibling_keys(json_schema)
-
-        if Keyword.ALLOF in json_schema:
-            sibling_keys = get_sibling_keys(json_schema, Keyword.ALLOF)
-            assert not sibling_keys
-            return lm + self.allOf(parent_schema=json_schema, base_uri=base_uri)
-
-        if Keyword.ANYOF in json_schema:
-            sibling_keys = get_sibling_keys(json_schema, Keyword.ANYOF)
-            assert not sibling_keys
-            return lm + self.anyOf(anyof_list=json_schema[Keyword.ANYOF], base_uri=base_uri)
-
-        if Keyword.ONEOF in json_schema:
-            sibling_keys = get_sibling_keys(json_schema, Keyword.ONEOF)
-            assert not sibling_keys
-            return lm + self.oneOf(oneof_list=json_schema[Keyword.ONEOF], base_uri=base_uri)
-
-        if Keyword.REF in json_schema:
-            sibling_keys = get_sibling_keys(json_schema, Keyword.REF)
-            assert not sibling_keys
-            return lm + self.ref(reference=json_schema[Keyword.REF], base_uri=base_uri)
-
-        if Keyword.TYPE in json_schema and isinstance(json_schema[Keyword.TYPE], str):
-            target_type = json_schema[Keyword.TYPE]
-            if target_type == JSONType.NULL:
-                return  lm + "null"
-            elif target_type == JSONType.BOOLEAN:
-                return lm + select(["true", "false"])
-            elif target_type in {JSONType.INTEGER, JSONType.NUMBER}:
-                minimum = cast(Union[int, float, None], json_schema.get(NumberKeywords.MINIMUM, None))
-                maximum = cast(Union[int, float, None], json_schema.get(NumberKeywords.MAXIMUM, None))
-                # Older schemas (Draft4) may have exclusiveMinimum and exclusiveMaximum as booleans, but Draft202012+ should have them as numbers
-                exclusive_minimum = cast(Union[int, float, None], json_schema.get(NumberKeywords.EXCLUSIVE_MINIMUM, None))
-                exclusive_maximum = cast(Union[int, float, None], json_schema.get(NumberKeywords.EXCLUSIVE_MAXIMUM, None))
-                # Internally, we'll use Draft4 style booleans
-                exclusive_minimum_flag: bool = False
-                exclusive_maximum_flag: bool = False
-
-                if exclusive_minimum is not None:
-                    if minimum is None or exclusive_minimum >= minimum:
-                        minimum = exclusive_minimum
-                        exclusive_minimum_flag = True
-
-                if exclusive_maximum is not None:
-                    if maximum is None or exclusive_maximum <= maximum:
-                        maximum = exclusive_maximum
-                        exclusive_maximum_flag = True
-
-                if target_type == JSONType.INTEGER:
-                    return lm + self.integer(
-                        minimum=minimum,
-                        maximum=maximum,
-                        exclusiveMinimum=exclusive_minimum_flag,
-                        exclusiveMaximum=exclusive_maximum_flag,
-                    )
-                else:
-                    return lm + self.number(
-                        minimum=minimum,
-                        maximum=maximum,
-                        exclusiveMinimum=exclusive_minimum_flag,
-                        exclusiveMaximum=exclusive_maximum_flag,
-                    )
-            elif target_type == JSONType.STRING:
-                return lm + self.string(
-                    regex=json_schema.get(StringKeywords.PATTERN, None),
-                    format=json_schema.get(StringKeywords.FORMAT, None),
-                    min_length=json_schema.get(StringKeywords.MIN_LENGTH, 0),
-                    max_length=json_schema.get(StringKeywords.MAX_LENGTH, None),
-                )
-            elif target_type == JSONType.ARRAY:
-                return lm + self.array(
-                    prefix_items_schema=json_schema.get(ArrayKeywords.PREFIX_ITEMS, []),
-                    item_schema=json_schema.get(ArrayKeywords.ITEMS, True),
-                    min_items=json_schema.get(ArrayKeywords.MIN_ITEMS, 0),
-                    max_items=json_schema.get(ArrayKeywords.MAX_ITEMS, None),
-                    base_uri=base_uri,
-                )
-            elif target_type == JSONType.OBJECT:
-                return lm + self.object(
-                    properties=json_schema.get(ObjectKeywords.PROPERTIES, {}),
-                    additional_properties=json_schema.get(ObjectKeywords.ADDITIONAL_PROPERTIES, True),
-                    required=json_schema.get(ObjectKeywords.REQUIRED, set()),
-                    base_uri=base_uri,
-                )
-            else:
-                raise ValueError(f"Unsupported type in schema: {target_type}")
-
-        if Keyword.TYPE in json_schema:
-            json_schema = json_schema.copy()
-            target_types = cast(Sequence[JSONType], json_schema.pop(Keyword.TYPE))
-        else:
-            target_types = list(JSONType)
-
-        assert Keyword.TYPE not in json_schema
-        # Punt to anyOf if we have multiple types so that it can ignore an unsatisfiable subset
-        return lm + self.anyOf(
-            anyof_list = [
-                {"type": target_type, **json_schema} for target_type in target_types
-            ],
-            base_uri=base_uri,
-        )
-
-
-@guidance(stateless=True)
 def json(
-    lm,
     name: Optional[str] = None,
     *,
     schema: Union[
         None,
         str,
         JSONSchema,
-        Type["pydantic.BaseModel"],
-        "pydantic.TypeAdapter",
+        Type[pydantic.BaseModel],
+        pydantic.TypeAdapter,
     ] = None,
     temperature: float = 0.0,
-    max_tokens: int = 100000000,
+    max_tokens: Optional[int] = None,
     separators: Optional[tuple[str, str]] = None,
     whitespace_flexible: bool = False,
     **kwargs,
@@ -1379,28 +89,35 @@ def json(
     elif isinstance(schema, (Mapping, bool, str)):
         if isinstance(schema, str):
             schema = cast(JSONSchema, json_loads(schema))
-        # Raises jsonschema.exceptions.SchemaError or ValueError
-        # if schema is not valid
-        jsonschema.validators.Draft202012Validator.check_schema(schema)
     elif isinstance(schema, pydantic.TypeAdapter) or (isinstance(schema, type) and issubclass(schema, pydantic.BaseModel)):
         schema = pydantic_to_json_schema(schema)
     else:
         raise TypeError(f"Unsupported schema type: {type(schema)}")
 
-    if whitespace_flexible:
-        if separators is None:
-            separators = (",", ":")
-        skip_regex = r"[\x20\x0A\x0D\x09]+"
-    else:
-        skip_regex = None
+    compiler = JsonCompiler(
+        separators=separators,
+        whitespace_flexible=whitespace_flexible,
+        coerce_one_of=False,
+    )
+
+    schema_string = json_dumps(schema)
+    try:
+        llg = compiler.compile(schema_string)
+    except ValueError as e:
+        if e.args[0] == "oneOf constraints are not supported. Enable 'coerce_one_of' option to approximate oneOf with anyOf":
+            warnings.warn("oneOf not fully supported, falling back to anyOf. This may cause validation errors in some cases.")
+            compiler = JsonCompiler(
+                separators=separators,
+                whitespace_flexible=whitespace_flexible,
+                coerce_one_of=True,
+            )
+            llg = compiler.compile(schema_string)
+        else:
+            raise
 
-    return lm + with_temperature(
-        subgrammar(
-            name,
-            body=GenJson(schema=schema, separators=separators).root(),
-            skip_regex=skip_regex,
-            no_initial_skip=True,
-            max_tokens=max_tokens,
-        ),
+    return LLGrammar(
+        json_loads(llg)["grammars"][0],
+        capture_name=name,
+        max_tokens=max_tokens,
         temperature=temperature,
     )
diff --git a/guidance/library/_regex_utils.py b/guidance/library/_regex_utils.py
deleted file mode 100644
index 58ced96d3..000000000
--- a/guidance/library/_regex_utils.py
+++ /dev/null
@@ -1,272 +0,0 @@
-import math
-from typing import Optional, cast
-
-
-# assumes parts are in parentheses
-# ensures that the resulting regex is in parentheses
-def mk_or(parts: list[str]) -> str:
-    if len(parts) == 1:
-        return parts[0]
-    return "(" + "|".join(parts) + ")"
-
-
-def num_digits(n: int) -> int:
-    return len(str(n))
-
-
-def rx_int_range(left: Optional[int] = None, right: Optional[int] = None) -> str:
-    if left is None and right is None:
-        return "-?(0|[1-9][0-9]*)"
-    if right is None:
-        left = cast(int, left)
-        if left < 0:
-            return mk_or([rx_int_range(left, -1), rx_int_range(0, None)])
-        return mk_or(
-            [
-                rx_int_range(left, int("9" * num_digits(left))),
-                f"[1-9][0-9]{{{num_digits(left)},}}",
-            ]
-        )
-    if left is None:
-        right = cast(int, right)
-        if right >= 0:
-            return mk_or([rx_int_range(0, right), rx_int_range(None, -1)])
-        return "-" + rx_int_range(-right, None)
-
-    assert left <= right
-    if left < 0:
-        if right < 0:
-            return "(-" + rx_int_range(-right, -left) + ")"
-        else:
-            return "(-" + rx_int_range(0, -left) + "|" + rx_int_range(0, right) + ")"
-    else:
-        if num_digits(left) == num_digits(right):
-            l = str(left)
-            r = str(right)
-            if left == right:
-                return f"({l})"
-
-            lpref = l[:-1]
-            lx = l[-1]
-            rpref = r[:-1]
-            rx = r[-1]
-
-            # 1723-1728 => 172[3-8]
-            if lpref == rpref:
-                return f"({lpref}[{lx}-{rx}])"
-
-            # general case 723-915 => 72[3-9]|(73-90)[0-9]|91[0-5]
-            left_rec = int(lpref)
-            right_rec = int(rpref)
-            assert left_rec < right_rec
-            parts = []
-
-            # optimizations:
-            # for 0, we have 720-915 => (72-90)[0-9]|91[0-5]
-            if lx != "0":
-                left_rec += 1
-                parts.append(f"{lpref}[{lx}-9]")
-            # for 9 we have 723-919 => 72[3-9]|(73-91)[0-9]
-            if rx != "9":
-                right_rec -= 1
-                parts.append(f"{rpref}[0-{rx}]")
-
-            # the middle can be empty 723-734 => 72[3-9]|73[0-4]
-            if left_rec <= right_rec:
-                inner = rx_int_range(left_rec, right_rec)
-                parts.append(f"{inner}[0-9]")
-
-            return mk_or(parts)
-        else:
-            break_point = 10 ** num_digits(left) - 1
-            return mk_or(
-                [rx_int_range(left, break_point), rx_int_range(break_point + 1, right)]
-            )
-
-
-def lexi_x_to_9(x: str, incl: bool) -> str:
-    if incl:
-        if x == "":
-            return "[0-9]*"
-        if len(x) == 1:
-            return f"[{x}-9][0-9]*"
-    else:
-        if x == "":
-            return "[0-9]*[1-9]"
-    x0 = int(x[0])
-    parts = [x[0] + lexi_x_to_9(x[1:], incl)]
-    if x0 < 9:
-        parts.append(f"[{x0 + 1}-9][0-9]*")
-    return mk_or(parts)
-
-
-def lexi_0_to_x(x: str, incl: bool) -> str:
-    if x == "":
-        assert incl
-        return ""  # don't allow trailing zeros
-
-    x0 = int(x[0])
-
-    if not incl and len(x) == 1:
-        # there should be rstrip(0) of input
-        assert x0 > 0
-        return f"[0-{x0 - 1}][0-9]*"
-
-    parts = [x[0] + lexi_0_to_x(x[1:], incl)]
-    if x0 > 0:
-        parts.append(f"[0-{x0 - 1}][0-9]*")
-    return mk_or(parts)
-
-
-def lexi_range(ld: str, rd: str, ld_incl: bool, rd_incl: bool) -> str:
-    assert len(ld) == len(rd)
-    if ld == rd:
-        assert ld_incl and rd_incl
-        return ld
-    l0 = int(ld[0])
-    r0 = int(rd[0])
-    # common prefix: 137-144 => 1(37-44)
-    if r0 == l0:
-        return ld[0] + lexi_range(ld[1:], rd[1:], ld_incl, rd_incl)
-    assert l0 < r0
-    # 23470-82142 => 2(347-999)|[3-7][0-9]*|8(0000-2142)
-    parts = [ld[0] + lexi_x_to_9(ld[1:].rstrip("0"), ld_incl)]
-    # is the [3-7][0-9]* part empty?
-    if l0 + 1 < r0:
-        parts.append(f"[{l0 + 1}-{r0 - 1}][0-9]*")
-    rd2 = rd[1:].rstrip("0")
-    if rd2 or rd_incl:
-        parts.append(rd[0] + lexi_0_to_x(rd2, rd_incl))
-    return mk_or(parts)
-
-
-def float_to_str(f: float) -> str:
-    s = f"{f:f}"
-    return s.rstrip("0").rstrip(".")
-
-
-def rx_float_range(
-    left: Optional[float], right: Optional[float], left_inclusive: bool = True, right_inclusive: bool = True
-) -> str:
-    if left is None and right is None:
-        return r"-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?"
-    if right is None:
-        left = cast(float, left)
-        if left < 0:
-            return mk_or([
-                # {left, 0) ∪ [0, ∞)
-                rx_float_range(left, 0., left_inclusive=left_inclusive, right_inclusive=False),
-                rx_float_range(0., None, left_inclusive=True)
-            ])
-        left_int_part = int(left)
-        return mk_or(
-            [
-                # {3.14, 10) ∪ [10, ∞)
-                rx_float_range(left, float("1" + "0"* num_digits(left_int_part)), left_inclusive=left_inclusive, right_inclusive=False),
-                fr"[1-9][0-9]{{{num_digits(left_int_part)},}}(\.[0-9]+)?"
-            ]
-        )
-    if left is None:
-        right = cast(float, right)
-        if right == 0:
-            # {0} ∪ (-∞, 0)
-            r = "-" + rx_float_range(0, None, left_inclusive=False)
-            if right_inclusive:
-                return mk_or([r, "0"])
-            return r
-        if right > 0:
-            # (-∞, 0) ∪ [0, right)
-            return mk_or([
-                "-" + rx_float_range(0, None, left_inclusive=False),
-                rx_float_range(0, right, left_inclusive=True, right_inclusive=right_inclusive)
-            ])
-        return "-" + rx_float_range(-right, None, left_inclusive=right_inclusive)
-
-
-    assert left <= right
-
-    if left == right:
-        if left_inclusive and right_inclusive:
-            return f"({float_to_str(left)})"
-        else:
-            raise ValueError("Empty range")
-
-    if left < 0:
-        if right < 0:
-            return (
-                "(-"
-                + rx_float_range(-right, -left, right_inclusive, left_inclusive)
-                + ")"
-            )
-        else:
-            # right >= 0
-            parts = []
-
-            # Negative part
-            neg_part = rx_float_range(
-                0.0,
-                -left,
-                False,  # we don't allow -0
-                left_inclusive,
-            )
-            parts.append("(-" + neg_part + ")")
-
-            # Positive part
-            if right > 0 or right_inclusive:
-                pos_part = rx_float_range(
-                    0.0,
-                    right,
-                    True,  # always include 0
-                    right_inclusive,
-                )
-                parts.append(pos_part)
-
-            return mk_or(parts)
-    else:
-        l = float_to_str(left)
-        r = float_to_str(right)
-
-        # guard against floating point errors
-        assert l != r
-
-        # float_to_str() should never return scientific notation
-        assert "e" not in l and "e" not in r
-
-        if not math.isfinite(left) or not math.isfinite(right):
-            raise ValueError("Infinite numbers not supported")
-
-        left_rec = int(l.split(".")[0])
-        right_rec = int(r.split(".")[0])
-
-        ld = (l.split(".") + [""])[1]
-        rd = (r.split(".") + [""])[1]
-
-        # 17.123-17.1448 -> 17.((1230-1447)[0-9]*|1448)
-        if left_rec == right_rec:
-            while len(ld) < len(rd):
-                ld += "0"
-            while len(rd) < len(ld):
-                rd += "0"
-            suff = "\\." + lexi_range(ld, rd, left_inclusive, right_inclusive)
-            if int(ld) == 0:
-                return f"({left_rec}({suff})?)"
-            else:
-                return f"({left_rec}{suff})"
-
-        parts = []
-
-        # 7.321-22.123 -> 7.(321-999)|8-21(.[0-9]+)?|22.(000-123)
-        if ld or not left_inclusive:
-            parts.append(f"({left_rec}\\.{lexi_x_to_9(ld, left_inclusive)})")
-            left_rec += 1
-
-        if right_rec - 1 >= left_rec:
-            inner = rx_int_range(left_rec, right_rec - 1)
-            parts.append(f"({inner}(\\.[0-9]+)?)")
-
-        if rd:
-            parts.append(f"({right_rec}(\\.{lexi_0_to_x(rd, right_inclusive)})?)")
-        elif right_inclusive:
-            parts.append(f"{right_rec}(\\.0+)?")
-
-        return mk_or(parts)
diff --git a/guidance/library/_subgrammar.py b/guidance/library/_subgrammar.py
index b0500a2ad..78cf7dbfe 100644
--- a/guidance/library/_subgrammar.py
+++ b/guidance/library/_subgrammar.py
@@ -21,7 +21,7 @@ def lexeme(
         For example, /[a-z"]+/ will be quoted as /([a-z]|\\")+/.
         Defaults to False.
     """
-    return Lexeme(body_regex=body_regex, contextual=contextual, json_string=json_string)
+    return Lexeme(rx=body_regex, contextual=contextual, json_string=json_string)
 
 
 def subgrammar(
diff --git a/setup.py b/setup.py
index 7bab97840..ffd0cca12 100644
--- a/setup.py
+++ b/setup.py
@@ -36,7 +36,6 @@
 extras_requires = {
     "azureai": ["openai>=1.0"],
     "openai": ["openai>=1.0"],
-    "schemas": ["jsonschema"],
     "server": ["fastapi-slim", "uvicorn"],
 }
 
diff --git a/tests/unit/library/json/test_allOf.py b/tests/unit/library/json/test_allOf.py
index e27d93940..0f8d3269d 100644
--- a/tests/unit/library/json/test_allOf.py
+++ b/tests/unit/library/json/test_allOf.py
@@ -182,7 +182,8 @@ def test_allOf_with_boolean_schemas_some_false(self, test_object, valid):
                 validate(instance=test_object, schema=schema)
             with pytest.raises(ValueError) as ve:
                 _ = gen_json(schema=schema)
-            assert ve.value.args[0] == "allOf contains a 'false' schema"
+            assert ve.value.args[0] == "Unsatisfiable schema: schema is false"
+            # TODO: more informative error message, e.g. "allOf contains a 'false' schema"
 
     @pytest.mark.parametrize(
         ["test_object", "valid"],
@@ -204,7 +205,8 @@ def test_allOf_with_boolean_schemas_all_false(self, test_object, valid):
                 validate(instance=test_object, schema=schema)
             with pytest.raises(ValueError) as ve:
                 _ = gen_json(schema=schema)
-            assert ve.value.args[0] == "allOf contains a 'false' schema"
+            assert ve.value.args[0] == "Unsatisfiable schema: schema is false"
+            # TODO: more informative error message, e.g. "allOf contains a 'false' schema"
 
     @pytest.mark.parametrize(
         ["test_object", "valid"],
diff --git a/tests/unit/library/json/test_json.py b/tests/unit/library/json/test_json.py
index c276d7dfc..08ad38110 100644
--- a/tests/unit/library/json/test_json.py
+++ b/tests/unit/library/json/test_json.py
@@ -7,7 +7,6 @@
 
 from guidance import json as gen_json
 from guidance import models
-from guidance.library._json import IGNORED_KEYS
 
 from .utils import check_match_failure, generate_and_check
 
@@ -89,7 +88,7 @@ def test_unsatisfiable_min_max(self, schema):
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
         assert re.fullmatch(
-            r"(exclusiveMinimum|minimum) \(5\) is (greater than|equal to) (exclusiveMaximum|maximum) \((4|5)\)",
+            r"Unsatisfiable schema: (exclusiveMinimum|minimum) \(5\) is (greater than|equal to) (exclusiveMaximum|maximum) \((4|5)\)",
             ve.value.args[0],
         )
 
@@ -158,12 +157,12 @@ def test_bad_number(self, bad_string, good_bytes, failure_byte, allowed_bytes):
     def test_unsatisfiable_min_max(self, schema):
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
+        assert ve.value.args[0].startswith("Unsatisfiable schema")
         assert re.fullmatch(
-            r"(exclusiveMinimum|minimum) \(5\) is (greater than|equal to) (exclusiveMaximum|maximum) \((4|5)\)",
-            ve.value.args[0],
+            r"Unsatisfiable schema: (exclusiveMinimum|minimum) \(5\) is (greater than|equal to) (exclusiveMaximum|maximum) \((4|5)\)",
+            ve.value.args[0]
         )
 
-
 class TestBoundedNumeric:
     @pytest.mark.parametrize(
         "instance, schema, should_pass",
@@ -352,13 +351,9 @@ def test_regex_no_min_max_length(self):
 
         lm = models.Mock("".encode())
 
-        expected = (
-            "If a pattern or format is specified for a JSON string,"
-            " minLength and maxLength must be left unspecified."
-        )
         with pytest.raises(ValueError) as ve:
             lm += gen_json(schema=schema_obj)
-        assert ve.value.args[0] == expected
+        assert ve.value.args[0] == "If a pattern is specified, minLength and maxLength must be unspecified."
 
     @pytest.mark.parametrize(
         ["bad_string", "good_bytes", "failure_byte", "allowed_bytes"],
@@ -370,7 +365,7 @@ def test_regex_no_min_max_length(self):
     def test_regex_bad(self, bad_string: str, good_bytes, failure_byte, allowed_bytes):
         # Note that the strings being fed in include the double quotes required
         # to make them JSON strings
-        schema = """{ "type": "string", "pattern": "a[A-Z]"}"""
+        schema = """{ "type": "string", "pattern": "^a[A-Z]$"}"""
         schema_obj = json.loads(schema)
         check_match_failure(
             bad_string=bad_string,
@@ -382,7 +377,7 @@ def test_regex_bad(self, bad_string: str, good_bytes, failure_byte, allowed_byte
 
     @pytest.mark.parametrize("string", ["aA\u001f", '"""'])
     def test_regex_properly_escaped_good(self, string):
-        schema_obj = {"type": "string", "pattern": r".{3}"}
+        schema_obj = {"type": "string", "pattern": r"^.{3}$"}
         # First sanity check what we're setting up
         validate(instance=string, schema=schema_obj)
         # The actual check
@@ -577,7 +572,7 @@ def test_unsatisfiable_length(self):
         schema = {"type": "string", "minLength": 10, "maxLength": 5}
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
-        assert ve.value.args[0] == "String minLength (10) is greater than maxLength (5)"
+        assert ve.value.args[0] == "Unsatisfiable schema: minLength (10) is greater than maxLength (5)"
 
 
 class TestSimpleObject:
@@ -734,10 +729,11 @@ def test_unsatisfiable_properties_raises(self):
         }
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
-        assert ve.value.args[0] == "Required property 'b' is unsatisfiable"
-        assert (
-            ve.value.__cause__.args[0] == "No valid JSON can be generated from a schema of `false`"
-        )
+        assert ve.value.args[0] == "Unsatisfiable schema: required property 'b' is unsatisfiable"
+        # TODO: deeper traceback, e.g.
+        # assert (
+        #     ve.value.__cause__.args[0] == "Unsatisfiable schema: schema is false"
+        # )
 
     def test_unsatisfiable_additional_properties_raises(self):
         schema = {
@@ -748,13 +744,13 @@ def test_unsatisfiable_additional_properties_raises(self):
         }
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
-        assert (
-            ve.value.args[0]
-            == "Required properties not in properties but additionalProperties is unsatisfiable. Missing required properties: ['b']"
-        )
-        assert (
-            ve.value.__cause__.args[0] == "No valid JSON can be generated from a schema of `false`"
-        )
+        assert ve.value.args[0].startswith("Unsatisfiable schema")
+        # TODO: more informative error message, e.g.
+        # "Required properties not in properties but additionalProperties is unsatisfiable. Missing required properties: ['b']"
+        # TODO: deeper traceback, e.g.
+        # assert (
+        #     ve.value.__cause__.args[0] == "Unsatisfiable schema: schema is false"
+        # )
 
 
 class TestObjectWithMissingRequired:
@@ -790,13 +786,13 @@ def test_false_additionalProperties_fails(self):
         }
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
-        assert (
-            ve.value.args[0]
-            == "Required properties not in properties but additionalProperties is unsatisfiable. Missing required properties: ['b', 'c']"
-        )
-        assert (
-            ve.value.__cause__.args[0] == "No valid JSON can be generated from a schema of `false`"
-        )
+        assert ve.value.args[0].startswith("Unsatisfiable schema")
+        # TODO: more informative error message, e.g.
+        # "Required properties not in properties but additionalProperties is unsatisfiable. Missing required properties: ['b', 'c']"
+        # TODO: deeper traceback, e.g.
+        # assert (
+        #     ve.value.__cause__.args[0] == "Unsatisfiable schema: schema is false"
+        # )
 
 
 class TestSimpleArray:
@@ -905,10 +901,9 @@ def test_unsatisfiable_prefixItem_raises(self):
         }
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
-        assert ve.value.args[0] == "prefixItems[1] is unsatisfiable but min_items is 2"
-        assert (
-            ve.value.__cause__.args[0] == "No valid JSON can be generated from a schema of `false`"
-        )
+        assert ve.value.args[0] == "Unsatisfiable schema: prefixItems[1] is unsatisfiable but minItems is 2"
+        # TODO: deeper traceback, e.g.
+        # assert ve.value.args[0].__cause__.args[0] == "Unsatisfiable schema: schema is false"
 
     def test_unsatisfiable_items_ok(self):
         schema = {
@@ -934,11 +929,9 @@ def test_unsatisfiable_items_raises(self):
         }
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
-        assert (
-            ve.value.args[0]
-            == "prefixItems has too few elements (1) to satisfy minItems (2) but item schema is unsatisfiable"
-        )
-        assert ve.value.__cause__.args[0] == "allOf contains a 'false' schema"
+        assert ve.value.args[0].startswith("Unsatisfiable schema: required item is unsatisfiable")
+        # TODO: more detailed error message, e.g.
+        # "prefixItems has too few elements (1) to satisfy minItems (2) but item schema is unsatisfiable"
 
 
 class TestArrayWithLengthConstraints:
@@ -1228,7 +1221,7 @@ def test_unsatisfiable_length(self):
         schema = {"type": "array", "minItems": 10, "maxItems": 5}
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
-        assert ve.value.args[0] == "minItems (10) is greater than maxItems (5)"
+        assert ve.value.args[0] == "Unsatisfiable schema: minItems (10) is greater than maxItems (5)"
 
 
 class TestAnyOf:
@@ -1326,7 +1319,7 @@ def test_anyOf_unsatisfiable_raises(self):
             _ = gen_json(schema=schema)
         assert (
             ve.value.args[0]
-            == 'all anyOf schemas are unsatisfiable: [{"type": "integer", "minimum": 10, "maximum": 0}, false]'
+            == 'Unsatisfiable schema: minimum (10) is greater than maximum (0)'
         )
 
 
@@ -1390,7 +1383,9 @@ def test_allOf_bad_schema(self):
         schema = {"allOf": [{"type": "integer"}, {"type": "string"}]}
         with pytest.raises(ValueError) as ve:
             _ = gen_json(schema=schema)
-        assert ve.value.args[0] == "allOf has conflicting types: [{'integer'}, {'string'}]"
+        assert ve.value.args[0].startswith("Unsatisfiable schema")
+        # TODO: would be nice to have a more specific error message here, e.g.
+        # f"Unsatisfiable schema: allOf has conflicting types: [{'integer'}, {'string'}]"
 
 
 
@@ -1527,7 +1522,9 @@ def test_invalid_typed_enum(self):
         schema_obj = {"enum": [1, "2"], "type": "boolean"}
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
-        assert ve.value.args[0] == f"All enum options {[1, '2']} are inconsistent with parent schema: {schema_obj}"
+        assert ve.value.args[0].startswith("Unsatisfiable schema")
+        # TODO: would be nice to have a more specific error message here, e.g.
+        # f"Unsatisfiable schema: all enum options {[1, '2']} are inconsistent with parent schema: {schema_obj}"
 
 
 class TestConst:
@@ -1598,7 +1595,9 @@ def test_invalid_typed_const(self):
         schema_obj = {"const": 1, "type": "boolean"}
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
-        assert ve.value.args[0] == f"const {1!r} is inconsistent with parent schema: {schema_obj}"
+        assert ve.value.args[0].startswith("Unsatisfiable schema")
+        # TODO: would be nice to have a more specific error message here, e.g.
+        # f"Unsatisfiable schema: const {1!r} is inconsistent with parent schema: {schema_obj}"
 
     def test_valid_enum_const(self):
         schema_obj = {"const": 1, "enum": [1, 2, 3]}
@@ -1610,7 +1609,8 @@ def test_invalid_enum_const(self):
         schema_obj = {"const": 1, "enum": [2, 3]}
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
-        assert ve.value.args[0] == f"const {1!r} is inconsistent with parent schema: {schema_obj}"
+        assert ve.value.args[0].startswith("Unsatisfiable schema")
+        # TODO: would be nice to have a more specific error message here, e.g.
 
     def test_valid_typed_enum_const(self):
         schema_obj = {"const": 1, "enum": [1, "2", 3], "type": "integer"}
@@ -1630,11 +1630,9 @@ def test_invalid_typed_enum_const(self, const):
         schema_obj = {"const": const, "enum": [1, "2", 3], "type": "integer"}
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
-        assert (
-            ve.value.args[0]
-            == f"const {const!r} is inconsistent with parent schema: {schema_obj}"
-        )
-
+        assert ve.value.args[0].startswith("Unsatisfiable schema")
+        # TODO: would be nice to have a more specific error message here, e.g.
+        # f"Unsatisfiable schema: const {const!r} is inconsistent with parent schema: {schema_obj}"
 
 class TestAdditionalProperties:
 
@@ -2111,16 +2109,6 @@ def test_no_additionalProperties(self):
         )
 
 
-def test_ignored_keys_allowed_as_properties():
-    schema_obj = {
-        "type": "object",
-        "properties": {key: {"type": "string"} for key in IGNORED_KEYS},
-        "required": list(IGNORED_KEYS),
-    }
-    target_obj = {key: "value" for key in IGNORED_KEYS}
-    generate_and_check(target_obj, schema_obj)
-
-
 class TestRequiredProperties:
     schema_obj = {
         "type": "object",
@@ -2243,55 +2231,6 @@ def test_none_required(self, target_obj, extra_items):
         generate_and_check({**target_obj, **extra_items}, schema_obj)
 
 
-class TestRequiredPropertiesScaling:
-    @pytest.mark.parametrize("num_properties", [1, 2, 3, 4, 5, 10, 20, 50, 100])
-    def test_many_optional_properties_doesnt_blow_up(self, num_properties):
-        schema_obj = {
-            "type": "object",
-            "properties": {f"prop_{i}": {"type": "string"} for i in range(num_properties)},
-            "required": [],  # Empty should be worst-case scenario
-        }
-        from guidance.library._json import GenJson
-
-        genjson = GenJson(schema=schema_obj)
-        genjson._join.__wrapped__.cache_clear()
-        _ = genjson.root()
-        cache_info = genjson._join.__wrapped__.cache_info()
-
-        # Theoretical number of cache misses under the current implementation
-        expected_misses = 2 * num_properties - 1
-        MISSES_MAGIC_NUMBER = 5  # Where in the world is this coming from?
-        assert 0 < cache_info.misses <= expected_misses + MISSES_MAGIC_NUMBER
-        # NOTE: that if the cache maxsize is hit, the number of misses will be more than expected
-
-        # Theoretical number of total calls under the current implementation
-        expected_calls = num_properties * (num_properties - 1) // 2
-        CALLS_MAGIC_NUMBER = 12  # Where in the world is this coming from?
-        assert 0 < cache_info.hits + cache_info.misses <= expected_calls + CALLS_MAGIC_NUMBER
-
-    @pytest.mark.parametrize("num_properties", [1, 2, 3, 4, 5, 10, 20, 50, 100])
-    def test_all_required_properties_doesnt_blow_up(self, num_properties):
-        schema_obj = {
-            "type": "object",
-            "properties": {f"prop_{i}": {"type": "string"} for i in range(num_properties)},
-            "required": [f"prop_{i}" for i in range(num_properties)],
-        }
-        from guidance.library._json import GenJson
-
-        genjson = GenJson(schema=schema_obj)
-        genjson._join.__wrapped__.cache_clear()
-        _ = genjson.root()
-        cache_info = genjson._join.__wrapped__.cache_info()
-
-        # Theoretical number of cache misses under the current implementation
-        expected_misses = num_properties
-        MISSES_MAGIC_NUMBER = 4
-        assert 0 < cache_info.misses <= expected_misses + MISSES_MAGIC_NUMBER
-        HITS_MAGIC_NUMBER = 1
-        expected_hits = 0
-        assert cache_info.hits <= expected_hits + HITS_MAGIC_NUMBER
-
-
 class TestBooleanSchema:
     @pytest.mark.parametrize(
         "target_obj",
@@ -2317,16 +2256,13 @@ def test_false_schema(self):
         schema_obj = False
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
-        assert ve.value.args[0] == "No valid JSON can be generated from a schema of `false`"
+        assert ve.value.args[0] == "Unsatisfiable schema: schema is false"
 
     def test_false_required_property(self):
         schema_obj = {"type": "object", "properties": {"a": False}, "required": ["a"]}
         with pytest.raises(ValueError) as ve:
             gen_json(schema=schema_obj)
-        assert ve.value.args[0] == "Required property 'a' is unsatisfiable"
-        assert (
-            ve.value.__cause__.args[0] == "No valid JSON can be generated from a schema of `false`"
-        )
+        assert ve.value.args[0] == "Unsatisfiable schema: required property 'a' is unsatisfiable"
 
 
 
diff --git a/tests/unit/library/test_regex_utils.py b/tests/unit/library/test_regex_utils.py
deleted file mode 100644
index 14b5574a7..000000000
--- a/tests/unit/library/test_regex_utils.py
+++ /dev/null
@@ -1,163 +0,0 @@
-import pytest
-import re
-import math
-from typing import Optional
-
-from guidance.library._regex_utils import rx_int_range, rx_float_range, float_to_str
-
-
-def do_test_int_range(rx: str, left: int, right: int, left_none: bool = False, right_none: bool = False) -> None:
-    for n in range(left - 1000, right + 1000):
-        m = re.fullmatch(rx, str(n)) is not None
-        f = (left_none or left <= n) and (right_none or n <= right)
-        assert m == f
-
-@pytest.mark.parametrize(
-    ["left", "right"],
-    [
-        (0, 9),
-        (1, 7),
-        (0, 99),
-        (13, 170),
-        (13, 17),
-        (13, 27),
-        (13, 57),
-        (72, 91),
-        (723, 915),
-        (23, 915),
-        (-1, 915),
-        (-9, 9),
-        (-3, 3),
-        (-3, 0),
-        (-72, 13),
-        (None, 0),
-        (None, 7),
-        (None, 23),
-        (None, 725),
-        (None, -1),
-        (None, -17),
-        (None, -283),
-        (0, None),
-        (2, None),
-        (33, None),
-        (234, None),
-        (-1, None),
-        (-87, None),
-        (-329, None),
-        (None, None),
-        (-13, -13),
-        (-1, -1),
-        (0, 0),
-        (1, 1),
-        (13, 13),
-    ],
-)
-def test_int_range(left: Optional[int], right: Optional[int]) -> None:
-    rx = rx_int_range(left, right)
-    do_test_int_range(
-        rx,
-        (left or 0),
-        (right or 0),
-        left_none=(left is None),
-        right_none=(right is None),
-    )
-
-
-@pytest.mark.parametrize(
-    "left_inclusive",
-    [True, False],
-)
-@pytest.mark.parametrize(
-    "right_inclusive",
-    [True, False],
-)
-@pytest.mark.parametrize(
-    ["left", "right"],
-    [
-        (0, 10),
-        (-10, 0),
-        (0.5, 0.72),
-        (0.5, 1.72),
-        (0.5, 1.32),
-        (0.45, 0.5),
-        (0.3245, 0.325),
-        (0.443245, 0.44325),
-        (1, 2.34),
-        (1.33, 2),
-        (1, 10.34),
-        (1.33, 10),
-        (-1.33, 10),
-        (-17.23, -1.33),
-        (-1.23, -1.221),
-        (-10.2, 45293.9),
-        (None, 0),
-        (None, 1),
-        (None, 1.5),
-        (None, 1.55),
-        (None, -17.23),
-        (None, -1.33),
-        (None, -1.23),
-        (None, 103.74),
-        (None, 100),
-        (0, None),
-        (1, None),
-        (1.5, None),
-        (1.55, None),
-        (-17.23, None),
-        (-1.33, None),
-        (-1.23, None),
-        (103.74, None),
-        (100, None),
-        (None, None),
-        (-103.4, -103.4),
-        (-27, -27),
-        (-1.5, -1.5),
-        (-1, -1),
-        (0, 0),
-        (1, 1),
-        (1.5, 1.5),
-        (27, 27),
-        (103.4, 103.4),
-    ],
-)
-def test_float_range(
-    left: Optional[float], right: Optional[float], left_inclusive: bool, right_inclusive: bool
-) -> None:
-    l = "[" if left_inclusive else "("
-    r = "]" if right_inclusive else ")"
-    print(f"Testing range {l}{left}-{right}{r}")
-
-    if (left is not None) and (left == right) and not (left_inclusive and right_inclusive):
-        with pytest.raises(ValueError):
-            rx_float_range(left, right, left_inclusive, right_inclusive)
-    else:
-        rx = rx_float_range(left, right, left_inclusive, right_inclusive)
-        do_test_float_range(rx, (left or 0), (right or 0), left_inclusive, right_inclusive, left is None, right is None)
-
-def do_test_float_range(rx, left: float, right: float, left_inclusive: bool = True, right_inclusive: bool = True, left_none: bool = False, right_none: bool = False):
-    left_int = math.ceil(left)
-    right_int = math.floor(right)
-    if left_int < right_int:
-        if not left_inclusive and left_int == left:
-            left_int += 1
-        if not right_inclusive and right_int == right:
-            right_int -= 1
-        do_test_int_range(rx, left_int, right_int, left_none, right_none)
-    eps = 0.000001
-    eps2 = 0.01
-    test_cases = [left, right, 0, int(left), int(right)]
-    if left_none:
-        test_cases.append(left - 1000)
-    if right_none:
-        test_cases.append(right + 1000)
-    for x in test_cases:
-        for off in [0, -eps, eps, -eps2, eps2, 1, -1]:
-            n = x + off
-            ns = float_to_str(n)
-            m = re.fullmatch(rx, ns) is not None
-            lcond = left_none or left < n or (left == n and left_inclusive)
-            rcond = right_none or right > n or (right == n and right_inclusive)
-            f = lcond and rcond
-            if m != f:
-                print(f"Failed float for {ns} match={m} expected={f}")
-                assert False

From 2fc41514c982f64d1d2dafa43b7c01485b0c7aba Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Mon, 16 Dec 2024 20:46:05 -0800
Subject: [PATCH 26/30] Upgrade llguidance to `0.5.1rc0` (#1090)

- Allow intersection of `pattern`, `format`, and `minLength`/`maxLength`
on strings
- Support for pre-Draft2019-09 `additionalItems`
- Reduce cases where we give a warning for `oneOf` (we can infer cases
where coercion is guaranteed to be safe)
- Correction to JSON `pattern`'s regex anchoring semantics (patterns not
assumed to be anchored by default)
- Minor changes to JSON string generation with `minLength`/`maxLength`:
UTF-16 surrogate pairs are no longer allowed
---
 setup.py                             |   2 +-
 tests/unit/library/json/test_json.py | 100 ++++++++++++++++++++-------
 2 files changed, 77 insertions(+), 25 deletions(-)

diff --git a/setup.py b/setup.py
index ffd0cca12..691e975d3 100644
--- a/setup.py
+++ b/setup.py
@@ -29,7 +29,7 @@
     "referencing",
     "requests",
     "tiktoken>=0.3",
-    "llguidance==0.5.0",
+    "llguidance==0.5.1rc0",
 ]
 
 # Our basic list of 'extras'
diff --git a/tests/unit/library/json/test_json.py b/tests/unit/library/json/test_json.py
index 08ad38110..3259fd602 100644
--- a/tests/unit/library/json/test_json.py
+++ b/tests/unit/library/json/test_json.py
@@ -1,6 +1,7 @@
 import json
 import re
 from json import dumps as json_dumps
+import warnings
 
 import pytest
 from jsonschema import ValidationError, validate
@@ -345,16 +346,6 @@ def test_regex(self, my_string: str):
         # The actual check
         generate_and_check(my_string, schema_obj)
 
-    def test_regex_no_min_max_length(self):
-        schema = """{ "type": "string", "pattern": "a[A-Z]", "minLength": 1 }"""
-        schema_obj = json.loads(schema)
-
-        lm = models.Mock("".encode())
-
-        with pytest.raises(ValueError) as ve:
-            lm += gen_json(schema=schema_obj)
-        assert ve.value.args[0] == "If a pattern is specified, minLength and maxLength must be unspecified."
-
     @pytest.mark.parametrize(
         ["bad_string", "good_bytes", "failure_byte", "allowed_bytes"],
         [
@@ -574,6 +565,20 @@ def test_unsatisfiable_length(self):
             _ = gen_json(schema=schema)
         assert ve.value.args[0] == "Unsatisfiable schema: minLength (10) is greater than maxLength (5)"
 
+    @pytest.mark.parametrize("length", range(2, 7))
+    @pytest.mark.parametrize("character", ["a", "b"])
+    def test_pattern_length_intersection(self, length, character):
+        schema = {"type": "string", "minLength": 3, "maxLength": 5, "pattern": "^a+$"}
+        string = character * length
+        if length < 3 or length > 5 or character != "a":
+            with pytest.raises(ValidationError):
+                # Sanity check
+                validate(instance=string, schema=schema)
+            check_match_failure(bad_string=json_dumps(string), schema_obj=schema)
+        else:
+            # Sanity check
+            validate(instance=string, schema=schema)
+            generate_and_check(string, schema)
 
 class TestSimpleObject:
     # These are objects without cross references
@@ -1403,22 +1408,69 @@ def test_oneOf_simple(self, target_obj):
         # The actual check
         generate_and_check(target_obj, schema_obj)
 
-    @pytest.mark.parametrize("target_obj", [123, True])
-    def test_oneOf_compound(self, target_obj):
-        schema = """{
-        "oneOf" : [{ "type": "integer" }, { "type": "boolean" }]
-        }
-        """
-        # First sanity check what we're setting up
-        schema_obj = json.loads(schema)
-        validate(instance=target_obj, schema=schema_obj)
+    @pytest.mark.parametrize(
+        "schema, instances",
+        [
+            # Simple case, disjoint types
+            ({"oneOf": [{"type": "integer"}, {"type": "boolean"}]}, [123, True]),
+            # Simple case, disjoint enums
+            ({"oneOf": [{"enum": ["a", "b", "c"]}, {"enum": [1,2,3]}]}, ["a", "b", "c", 1, 2, 3]),
+            # More complex case, discriminated union
+            (
+                {
+                    "oneOf": [
+                        # Only one of them needs the prop key to be required
+                        {"type": "object", "properties": {"prop": {"const": "foo"}}, "required": ["prop"]},
+                        {"type": "object", "properties": {"prop": {"const": "bar"}}}
+                    ]
+                },
+                [{"prop": "foo"}, {"prop": "bar"}]
+            ),
+            # Enums made disjoint by type
+            (
+                {"oneOf": [{"enum": [1,2,"foo"]}, {"enum": [2,3,"bar"]}], "type": "string"},
+                ["foo", "bar"]
+            ),
+        ]
+    )
+    def test_oneOf_disjoint(self, schema, instances):
+        for instance in instances:
+            # First sanity check what we're setting up
+            validate(instance=instance, schema=schema)
 
-        # The actual check; we expect a warning here because oneOf is not fully supported
-        with pytest.warns() as record:
-            generate_and_check(target_obj, schema_obj)
-        assert len(record) == 1
-        assert record[0].message.args[0].startswith("oneOf not fully supported")
+            # The actual check; we assert NO warning here because oneOf is disjoint
+            with warnings.catch_warnings():
+                warnings.simplefilter("error")
+                generate_and_check(instance, schema)
 
+    @pytest.mark.parametrize(
+        "schema, instances",
+        [
+            # Overlapping enums
+            ({"oneOf": [{"enum": ["a", "b", "c"]}, {"enum": ["c", 2, 3]}]}, ["a", "b", 2, 3]),
+            # More complex case, object without proper discriminator
+            (
+                {
+                    "oneOf": [
+                        # Only one of them needs the prop key to be required
+                        {"type": "object", "properties": {"prop": {"const": "foo"}}},
+                        {"type": "object", "properties": {"prop": {"const": "bar"}}}
+                    ]
+                },
+                [{"prop": "foo"}, {"prop": "bar"}]
+            )
+        ]
+    )
+    def test_oneOf_overlap(self, schema, instances):
+        for instance in instances:
+            # First sanity check what we're setting up
+            validate(instance=instance, schema=schema)
+
+            # The actual check; assert a warning here because oneOf is not disjoint and we can't guarantee correctness
+            with pytest.warns() as record:
+                generate_and_check(instance, schema)
+            assert len(record) == 1
+            assert record[0].message.args[0] == "oneOf not fully supported, falling back to anyOf. This may cause validation errors in some cases."
 
 class TestEnum:
     simple_schema = """{

From 326bc1c13f0f9cc67a2d6838b47387376f9c92e5 Mon Sep 17 00:00:00 2001
From: Hudson Cooper <hncooper96@gmail.com>
Date: Mon, 16 Dec 2024 21:55:54 -0800
Subject: [PATCH 27/30] Bump llguidance to 0.5.1

Identical to 0.5.1rc0
---
 setup.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/setup.py b/setup.py
index 691e975d3..43d49fac0 100644
--- a/setup.py
+++ b/setup.py
@@ -29,7 +29,7 @@
     "referencing",
     "requests",
     "tiktoken>=0.3",
-    "llguidance==0.5.1rc0",
+    "llguidance==0.5.1",
 ]
 
 # Our basic list of 'extras'

From 727e8320062746b019d29a4cf393c88641fd7e4c Mon Sep 17 00:00:00 2001
From: S Jenkins <69673492+nopdive@users.noreply.github.com>
Date: Sat, 21 Dec 2024 02:18:39 -0800
Subject: [PATCH 28/30] Interactivity Overhaul (User Interface & Model
 Instrumentation & Network Comms) (#1054)

# Interactivity Overhaul
> What you want, when you want.
>
> -- <cite>some guidance developer (circa 2024)</cite>

![Screenshare of updated UI in Jupyter
notebook](https://github.com/user-attachments/assets/d65bafd4-5c9e-41c2-b5a2-4043e7cbfaae)

## Overview

This PR is the first of many focusing on interactivity. It introduces an
updated user interface for notebooks, new instrumentation for models,
and a respective network layer to handle bidirectional communication
between the IPython kernel and JavaScript client. To further support
this, models have reworked rendering, added tracing logic to better
support replays where required.

This PR also functions as a foundational step towards near future work
including rendering across various environments (i.e. terminal support
as TUI and append-only outputs), upgraded benchmarking and model
inspection.

### TL;DR

We added a lot of code to support better model metrics and
visualization. We are getting ready for multimedia streaming, and want
to have users deep inspect all the models, without overheating the
computer.

### Acknowledgements

Big shoutouts to:
- Loc (co-developed this PR): model instrumentation & metrics.
- Jingya: consult & sketches on enhanced UI design.
- Harsha: overall feedback & collab on prototypes.

### Running this PR
- `cd packages/python/stitch && pip install -e .`
- Go run a notebook.

## User Interface

Design principle: **All visibility. No magic.**

Overall we're trying to show as much as we can on model outputs. When
debugging outputs, there can be real ugliness that is often hidden away
including tokenization concerns and critical points that may dictate the
rest of the output. This need for inspection increases as users begin to
define their own structured decoding grammars, unexpected
overconstraints can occur in development.

The old user interface that displays HTML as a side-effect in notebooks
when models compute, have been replaced with a custom Jupyter Widget
(see Network Communications for more detail), of which hosts an
interactive sandboxed iframe. We still support a legacy mode, if users
desire the previous UI.

**Before**
<img width="651" alt="image"
src="https://github.com/user-attachments/assets/89b91c60-e428-43bb-ab41-d7ab34c65483">

**After**
<img width="353" alt="image"
src="https://github.com/user-attachments/assets/49964f2f-aef2-4faf-b631-5b1898677dd3">

We're getting more information to the output at the expense of less text
density. There is simply more going on, and in order to keep some
legibility we've increased text size and spacing, compensating for two
visual elements (highlighting and underlines) that are used to convey
token info for scanning. A general metrics bar is also displayed for
discoverability on token reduction and other efficiency metrics relevant
when prompt engineering for reduced costs.

When users want further detail on tokens, we support a tool tip that
contains top 5 alternate token candidates alongside exact values for
visual elements. Highlighting has been applied to candidates,
accentuating tokens that include spaces.

We use a mono-space typeface such that data format outputs can be
inspected quicker (i.e. verticality can matter for balancing braces and
indentation).

As users learn a system: a UI with easier discoverability can come at
the cost of productivity. We've made all visual components optional to
keep our power users in the flow, and in the future we intend to allow
users to define defaults to fully support this.

For legacy mode (modeled after previous UI). Users can execute
`guidance.legacy_mode(True)` at the start of their notebook.

![image](https://github.com/user-attachments/assets/df48d9cf-8f2f-4aac-9791-fc9d407359f1)
*Old school cool*.

### The Code

- Added
- `guidance.visual` module. Handles renderer creation (stitch or HTML
display) and all required messaging. This also handles Jupyter cell
change detection for deciding when widgets need to be instantiated or
reset.
- `guidance.trace` module. Tracks model inputs & outputs of an engine.
Important for replaying for clients.
- `graphpaper-inline` NPM package has been added. This handles all
client-side rendering and messaging. Written with
Svelte/TypeScript/Tailwind/D3.

- Changed
- Rendering logic has been stripped from `Model` class and has been
delegated to `Renderer` member where possible.
- Relevant state logic has been augmented for inputs & outputs, and
stored within engine for tracing across models.
- Role processing across guidance has been thinned. `Model` class now
generates role openers and closer text directly from its respective chat
template.

## Instrumentation

Instrumentation is key for model inspection, debugging and
cost-sensitive prompt engineering. This includes backing the new UI.
Metrics are now collected for both general compute resources
(CPU/GPU/RAM) and model tokens (including token counts/reduction,
latency, type, backtracking).

### The Code

* Added (metric collection feature)
* Add Monitor class in _model.py to collect common metrics (CPU, RAM,
GPU utilization, etc.)
* Monitor runs in a separated process to prevent competing resources
with model/engine process
    * Model now keeps stats of current input/output/backtrack tokens
* At the end of notebook cell's execution, we'll collect probability of
each token in the final model state, and collect associated stats per
token such as
      * Latency
      * If token was generated, force-forwarded or from user input

* Changed:
* Replaced get_next_token with get_next_token_with_top_k to keep track
issued token along with its associated top_k tokens (both constrained
and unconstrained). Data will be stored in EngineOutput class
* Model now has VisBytesChunk object to keep track of which part of the
chunk is from user input, generated by engine or force-forwarded by
parser.
VisBytesChunk also stores the list of EngineOutput objects generated by
the engine during chunk generation.
This facilitates the process of checking tokens from the final state are
generated, force-forwarded or from user input.
* Add get_per_token_topk_probs function in Engine class to calculate
probability of each token in the token list.
This function is used at the end of the cell execution to calculate the
probabilities of model state in unconstrained mode.
* Add get_per_token_stats function in Model class to report stats for
each token in model state in unconstrained mode.
Stats include issued token, probability, latency, top-k, masked-top-k if
available.
Data from get_per_token_stats will be reported to the UI for new
visualization.

## Network Communications

We have two emerging requirements that will impact future guidance
development. One, the emergence of streaming multimedia around language
models (audio/video). Two, user interactivity within the UI, requesting
more data or computation that may not be feasible to
r`pre-(?:fetch|calculate)` to a static client.

For user interactivity from UI to Python, it's also important that we
cover as many notebook environments as possible. Each cloud notebook
provider has their own quirks of which complicates client development.
Some providers love resizing cell outputs indefinitely, others refuse to
display HTML unless it's secured away in an isolated iframe.

All in all, we need a solution that is isolated, somewhat available
across providers and can allow streams of messages between server
(Jupyter Python kernel) and client (cell output with a touch of JS).

### Stitch
> It's 3:15AM, bi-directional comms was a mistake.
>
> -- <cite>some guidance developer, minutes prior to passing out (circa
2024)</cite>

`stitch` is an auxiliary package we've created, that handles
bi-directional communication between a web client and a Jupyter python
kernel. It does this by creating a thin custom Jupyter widget that
handles messages between the kernel and a sandboxed iframe hosting the
web client. It looks something like this:

`python code` -> `kernel-side jupyter widget` -> `kernel comms (ZMQ)` ->
`client-side jupyter widget` -> `window event message` -> `sandboxed
iframe` -> `web client (graphpaper-inline)`

This package drives messages between `guidance.visual` module and
`graphpaper-inline` client. All messages are streamed to allow
near-real-time rendering within a notebook. Bi-directional comms is used
to repair the display if initial messages have been missed (client will
request a full replay when it notices the first message it receives has
a non-zero identifier).

### The Code

- Added
  - `stitch` Python package. Can be found at `packages/python/stitch`.

## Future work

We wanted to shoot for the stars, and ended up in the ocean. The
following will occur after this PR.

Near future tasks:
- User defaults for UI
- Terminal support (non-interactive & shell)
- Restyle
- Richer visualizations
- Memory re-architecture (broader than this PR)
- Interactive support for multimedia
- Guidance quality-of-life (visual diff testing)

---------

Signed-off-by: Loc Huynh <lohuynh@microsoft.com>
Signed-off-by: JC1DA <jc1da.3011@gmail.com>
Co-authored-by: Loc Huynh <lohuynh@microsoft.com>
Co-authored-by: Loc Huynh <jc1da.3011@gmail.com>
Co-authored-by: Hudson Cooper <hncooper96@gmail.com>
---
 .gitignore                                    |    2 +-
 MANIFEST.in                                   |    1 +
 client/graphpaper-inline/.gitignore           |    3 +
 client/graphpaper-inline/TODO.txt             |    3 +
 client/graphpaper-inline/build-to-guidance.sh |    5 +
 client/graphpaper-inline/dist/.gitignore      |    2 +
 client/graphpaper-inline/package.json         |   40 +
 client/graphpaper-inline/pnpm-lock.yaml       | 3324 ++++++
 client/graphpaper-inline/postcss.config.js    |    7 +
 client/graphpaper-inline/rollup.config.mjs    |   58 +
 client/graphpaper-inline/src/App.svelte       |  251 +
 .../graphpaper-inline/src/MetricCard.svelte   |   28 +
 client/graphpaper-inline/src/Minibar.svelte   |   40 +
 .../src/ResizeListener.svelte                 |   33 +
 client/graphpaper-inline/src/Select.svelte    |   46 +
 .../src/StitchHandler.svelte                  |   31 +
 client/graphpaper-inline/src/TokenGrid.svelte |  519 +
 .../src/TokenGridItem.svelte                  |   50 +
 client/graphpaper-inline/src/clickoutside.ts  |   18 +
 client/graphpaper-inline/src/interfaces.ts    |   26 +
 client/graphpaper-inline/src/longhover.ts     |   28 +
 client/graphpaper-inline/src/main.css         |    4 +
 client/graphpaper-inline/src/main.js          |    9 +
 client/graphpaper-inline/src/mocks.ts         | 2852 ++++++
 client/graphpaper-inline/src/stitch.ts        |  160 +
 client/graphpaper-inline/src/template.html    |   12 +
 client/graphpaper-inline/tailwind.config.js   |   21 +
 client/graphpaper-inline/tsconfig.json        |   15 +
 guidance/__init__.py                          |    3 +
 guidance/_parser.py                           |  116 +-
 guidance/_schema.py                           |   49 +-
 guidance/_utils.py                            |   75 +-
 guidance/library/_block.py                    |    4 +-
 guidance/library/_role.py                     |   62 +-
 guidance/models/_mock.py                      |  107 +-
 guidance/models/_model.py                     | 1674 ++-
 guidance/models/_remote.py                    |    2 +-
 guidance/models/llama_cpp/_llama_cpp.py       |  123 +-
 guidance/models/transformers/_transformers.py |  105 +-
 guidance/resources/graphpaper-inline.html     |   16 +
 guidance/trace/__init__.py                    |   11 +
 guidance/trace/_trace.py                      |  339 +
 guidance/visual/__init__.py                   |    7 +-
 guidance/visual/_async.py                     |   84 +
 guidance/visual/_jupyter.py                   |   30 +
 guidance/visual/_message.py                   |  129 +
 guidance/visual/_renderer.py                  |  497 +
 guidance/visual/_trace.py                     |  208 +
 notebooks/unstable/.gitignore                 |    2 +
 notebooks/unstable/State Debugging.ipynb      |  196 +
 packages/python/stitch/.coveragerc            |    2 +
 packages/python/stitch/.eslintignore          |    5 +
 packages/python/stitch/.eslintrc.js           |   28 +
 .../python/stitch/.github/workflows/build.yml |   44 +
 packages/python/stitch/.gitignore             |  156 +
 packages/python/stitch/.npmignore             |    7 +
 packages/python/stitch/.prettierignore        |    4 +
 packages/python/stitch/.prettierrc            |    3 +
 packages/python/stitch/.yarnrc.yml            |    1 +
 packages/python/stitch/LICENSE.txt            |   27 +
 packages/python/stitch/MANIFEST.in            |   41 +
 packages/python/stitch/README.md              |   83 +
 packages/python/stitch/babel.config.js        |   13 +
 packages/python/stitch/codecov.yml            |   12 +
 packages/python/stitch/css/widget.css         |    4 +
 packages/python/stitch/docs/Makefile          |   20 +
 packages/python/stitch/docs/environment.yml   |   12 +
 packages/python/stitch/docs/make.bat          |   36 +
 .../stitch/docs/source/_static/helper.js      |    5 +
 packages/python/stitch/docs/source/conf.py    |  213 +
 .../stitch/docs/source/develop-install.rst    |   31 +
 .../stitch/docs/source/examples/index.rst     |   18 +
 .../docs/source/examples/introduction.nblink  |    3 +
 packages/python/stitch/docs/source/index.rst  |   49 +
 .../python/stitch/docs/source/installing.rst  |   37 +
 .../stitch/docs/source/introduction.rst       |    7 +
 .../python/stitch/examples/introduction.ipynb |  123 +
 packages/python/stitch/install.json           |    5 +
 packages/python/stitch/jest.config.js         |   16 +
 packages/python/stitch/package.json           |  101 +
 packages/python/stitch/pyproject.toml         |  122 +
 packages/python/stitch/pytest.ini             |    4 +
 packages/python/stitch/readthedocs.yml        |    9 +
 packages/python/stitch/setup.py               |    2 +
 .../python/stitch/src/__tests__/index.spec.ts |   33 +
 packages/python/stitch/src/__tests__/utils.ts |  119 +
 packages/python/stitch/src/extension.ts       |   16 +
 packages/python/stitch/src/index.ts           |    5 +
 packages/python/stitch/src/plugin.ts          |   42 +
 packages/python/stitch/src/version.ts         |   20 +
 packages/python/stitch/src/widget.ts          |  114 +
 packages/python/stitch/stitch.json            |    5 +
 packages/python/stitch/stitch/__init__.py     |   49 +
 packages/python/stitch/stitch/_frontend.py    |   12 +
 packages/python/stitch/stitch/_version.py     |    8 +
 .../stitch/stitch/nbextension/extension.js    |   17 +
 packages/python/stitch/stitch/stitch.py       |   31 +
 .../python/stitch/stitch/tests/__init__.py    |    0
 .../python/stitch/stitch/tests/conftest.py    |   54 +
 .../stitch/stitch/tests/test_example.py       |   16 +
 .../stitch/tests/test_nbextension_path.py     |   15 +
 packages/python/stitch/tsconfig.eslint.json   |    5 +
 packages/python/stitch/tsconfig.json          |   25 +
 packages/python/stitch/webpack.config.js      |   91 +
 packages/python/stitch/yarn.lock              | 8955 +++++++++++++++++
 setup.py                                      |    3 +
 tests/model_specific/test_visual.py           |   32 +
 tests/unit/library/test_block.py              |    8 +-
 tests/unit/test_model.py                      |   17 +-
 tests/unit/test_trace.py                      |   87 +
 tests/unit/test_visual.py                     |   64 +
 111 files changed, 22140 insertions(+), 373 deletions(-)
 create mode 100644 MANIFEST.in
 create mode 100644 client/graphpaper-inline/.gitignore
 create mode 100644 client/graphpaper-inline/TODO.txt
 create mode 100644 client/graphpaper-inline/build-to-guidance.sh
 create mode 100644 client/graphpaper-inline/dist/.gitignore
 create mode 100644 client/graphpaper-inline/package.json
 create mode 100644 client/graphpaper-inline/pnpm-lock.yaml
 create mode 100644 client/graphpaper-inline/postcss.config.js
 create mode 100644 client/graphpaper-inline/rollup.config.mjs
 create mode 100644 client/graphpaper-inline/src/App.svelte
 create mode 100644 client/graphpaper-inline/src/MetricCard.svelte
 create mode 100644 client/graphpaper-inline/src/Minibar.svelte
 create mode 100644 client/graphpaper-inline/src/ResizeListener.svelte
 create mode 100644 client/graphpaper-inline/src/Select.svelte
 create mode 100644 client/graphpaper-inline/src/StitchHandler.svelte
 create mode 100644 client/graphpaper-inline/src/TokenGrid.svelte
 create mode 100644 client/graphpaper-inline/src/TokenGridItem.svelte
 create mode 100644 client/graphpaper-inline/src/clickoutside.ts
 create mode 100644 client/graphpaper-inline/src/interfaces.ts
 create mode 100644 client/graphpaper-inline/src/longhover.ts
 create mode 100644 client/graphpaper-inline/src/main.css
 create mode 100644 client/graphpaper-inline/src/main.js
 create mode 100644 client/graphpaper-inline/src/mocks.ts
 create mode 100644 client/graphpaper-inline/src/stitch.ts
 create mode 100644 client/graphpaper-inline/src/template.html
 create mode 100644 client/graphpaper-inline/tailwind.config.js
 create mode 100644 client/graphpaper-inline/tsconfig.json
 create mode 100644 guidance/resources/graphpaper-inline.html
 create mode 100644 guidance/trace/__init__.py
 create mode 100644 guidance/trace/_trace.py
 create mode 100644 guidance/visual/_async.py
 create mode 100644 guidance/visual/_jupyter.py
 create mode 100644 guidance/visual/_message.py
 create mode 100644 guidance/visual/_renderer.py
 create mode 100644 guidance/visual/_trace.py
 create mode 100644 notebooks/unstable/.gitignore
 create mode 100644 notebooks/unstable/State Debugging.ipynb
 create mode 100644 packages/python/stitch/.coveragerc
 create mode 100644 packages/python/stitch/.eslintignore
 create mode 100644 packages/python/stitch/.eslintrc.js
 create mode 100644 packages/python/stitch/.github/workflows/build.yml
 create mode 100644 packages/python/stitch/.gitignore
 create mode 100644 packages/python/stitch/.npmignore
 create mode 100644 packages/python/stitch/.prettierignore
 create mode 100644 packages/python/stitch/.prettierrc
 create mode 100644 packages/python/stitch/.yarnrc.yml
 create mode 100644 packages/python/stitch/LICENSE.txt
 create mode 100644 packages/python/stitch/MANIFEST.in
 create mode 100644 packages/python/stitch/README.md
 create mode 100644 packages/python/stitch/babel.config.js
 create mode 100644 packages/python/stitch/codecov.yml
 create mode 100644 packages/python/stitch/css/widget.css
 create mode 100644 packages/python/stitch/docs/Makefile
 create mode 100644 packages/python/stitch/docs/environment.yml
 create mode 100644 packages/python/stitch/docs/make.bat
 create mode 100644 packages/python/stitch/docs/source/_static/helper.js
 create mode 100644 packages/python/stitch/docs/source/conf.py
 create mode 100644 packages/python/stitch/docs/source/develop-install.rst
 create mode 100644 packages/python/stitch/docs/source/examples/index.rst
 create mode 100644 packages/python/stitch/docs/source/examples/introduction.nblink
 create mode 100644 packages/python/stitch/docs/source/index.rst
 create mode 100644 packages/python/stitch/docs/source/installing.rst
 create mode 100644 packages/python/stitch/docs/source/introduction.rst
 create mode 100644 packages/python/stitch/examples/introduction.ipynb
 create mode 100644 packages/python/stitch/install.json
 create mode 100644 packages/python/stitch/jest.config.js
 create mode 100644 packages/python/stitch/package.json
 create mode 100644 packages/python/stitch/pyproject.toml
 create mode 100644 packages/python/stitch/pytest.ini
 create mode 100644 packages/python/stitch/readthedocs.yml
 create mode 100644 packages/python/stitch/setup.py
 create mode 100644 packages/python/stitch/src/__tests__/index.spec.ts
 create mode 100644 packages/python/stitch/src/__tests__/utils.ts
 create mode 100644 packages/python/stitch/src/extension.ts
 create mode 100644 packages/python/stitch/src/index.ts
 create mode 100644 packages/python/stitch/src/plugin.ts
 create mode 100644 packages/python/stitch/src/version.ts
 create mode 100644 packages/python/stitch/src/widget.ts
 create mode 100644 packages/python/stitch/stitch.json
 create mode 100644 packages/python/stitch/stitch/__init__.py
 create mode 100644 packages/python/stitch/stitch/_frontend.py
 create mode 100644 packages/python/stitch/stitch/_version.py
 create mode 100644 packages/python/stitch/stitch/nbextension/extension.js
 create mode 100644 packages/python/stitch/stitch/stitch.py
 create mode 100644 packages/python/stitch/stitch/tests/__init__.py
 create mode 100644 packages/python/stitch/stitch/tests/conftest.py
 create mode 100644 packages/python/stitch/stitch/tests/test_example.py
 create mode 100644 packages/python/stitch/stitch/tests/test_nbextension_path.py
 create mode 100644 packages/python/stitch/tsconfig.eslint.json
 create mode 100644 packages/python/stitch/tsconfig.json
 create mode 100644 packages/python/stitch/webpack.config.js
 create mode 100644 packages/python/stitch/yarn.lock
 create mode 100644 tests/model_specific/test_visual.py
 create mode 100644 tests/unit/test_trace.py
 create mode 100644 tests/unit/test_visual.py

diff --git a/.gitignore b/.gitignore
index c590bc397..2e6406a1f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,13 +2,13 @@ notebooks/local_scratch
 __pycache__/
 .vscode
 .vs
+.idea/
 /build
 /dist
 *.egg-info
 *.diskcache
 .ipynb_checkpoints
 node_modules
-/client
 .eggs/
 .env
 .DS_Store
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 000000000..176d59d7b
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1 @@
+include resources/graphpaper-inline.html
\ No newline at end of file
diff --git a/client/graphpaper-inline/.gitignore b/client/graphpaper-inline/.gitignore
new file mode 100644
index 000000000..7fd339b0f
--- /dev/null
+++ b/client/graphpaper-inline/.gitignore
@@ -0,0 +1,3 @@
+node_modules/
+build/
+.DS_Store
diff --git a/client/graphpaper-inline/TODO.txt b/client/graphpaper-inline/TODO.txt
new file mode 100644
index 000000000..4d5ef6b89
--- /dev/null
+++ b/client/graphpaper-inline/TODO.txt
@@ -0,0 +1,3 @@
+- Remove CDN font links (googlefonts)
+- Image integration
+- Testing
\ No newline at end of file
diff --git a/client/graphpaper-inline/build-to-guidance.sh b/client/graphpaper-inline/build-to-guidance.sh
new file mode 100644
index 000000000..4b71d7f04
--- /dev/null
+++ b/client/graphpaper-inline/build-to-guidance.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+set -x
+
+npm run build
+cp dist/index.html ../../guidance/resources/graphpaper-inline.html
\ No newline at end of file
diff --git a/client/graphpaper-inline/dist/.gitignore b/client/graphpaper-inline/dist/.gitignore
new file mode 100644
index 000000000..c96a04f00
--- /dev/null
+++ b/client/graphpaper-inline/dist/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
\ No newline at end of file
diff --git a/client/graphpaper-inline/package.json b/client/graphpaper-inline/package.json
new file mode 100644
index 000000000..e889ffc3c
--- /dev/null
+++ b/client/graphpaper-inline/package.json
@@ -0,0 +1,40 @@
+{
+    "name": "graphpaper",
+    "version": "0.0.1",
+    "scripts": {
+        "build": "rollup -c",
+        "dev": "rollup -c -w",
+        "start": "sirv dist"
+    },
+    "devDependencies": {
+        "@rollup/plugin-commonjs": "^26.0.1",
+        "@rollup/plugin-node-resolve": "^15.2.3",
+        "@rollup/plugin-terser": "^0.4.4",
+        "@rollup/plugin-typescript": "^11.1.6",
+        "@types/d3-scale": "^4.0.8",
+        "@types/d3-scale-chromatic": "^3.0.3",
+        "@types/dompurify": "^3.0.5",
+        "autoprefixer": "^10.4.20",
+        "cssnano": "^7.0.5",
+        "postcss": "^8.4.41",
+        "rollup": "^4.21.0",
+        "rollup-plugin-copy": "^3.5.0",
+        "rollup-plugin-html-bundle": "^0.0.3",
+        "rollup-plugin-livereload": "^2.0.5",
+        "rollup-plugin-postcss": "^4.0.2",
+        "rollup-plugin-serve": "^1.1.1",
+        "rollup-plugin-svelte": "^7.2.2",
+        "sirv-cli": "^2.0.2",
+        "svelte": "^4.2.18",
+        "svelte-preprocess": "^6.0.2",
+        "tailwindcss": "^3.4.10",
+        "tslib": "^2.6.3",
+        "typescript": "^5.5.4"
+    },
+    "dependencies": {
+        "d3-interpolate": "^3.0.1",
+        "d3-scale": "^4.0.2",
+        "d3-scale-chromatic": "^3.1.0",
+        "dompurify": "^3.1.7"
+    }
+}
\ No newline at end of file
diff --git a/client/graphpaper-inline/pnpm-lock.yaml b/client/graphpaper-inline/pnpm-lock.yaml
new file mode 100644
index 000000000..ecafc68c6
--- /dev/null
+++ b/client/graphpaper-inline/pnpm-lock.yaml
@@ -0,0 +1,3324 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      d3-interpolate:
+        specifier: ^3.0.1
+        version: 3.0.1
+      d3-scale:
+        specifier: ^4.0.2
+        version: 4.0.2
+      d3-scale-chromatic:
+        specifier: ^3.1.0
+        version: 3.1.0
+      dompurify:
+        specifier: ^3.1.7
+        version: 3.1.7
+    devDependencies:
+      '@rollup/plugin-commonjs':
+        specifier: ^26.0.1
+        version: 26.0.1(rollup@4.21.0)
+      '@rollup/plugin-node-resolve':
+        specifier: ^15.2.3
+        version: 15.2.3(rollup@4.21.0)
+      '@rollup/plugin-terser':
+        specifier: ^0.4.4
+        version: 0.4.4(rollup@4.21.0)
+      '@rollup/plugin-typescript':
+        specifier: ^11.1.6
+        version: 11.1.6(rollup@4.21.0)(tslib@2.6.3)(typescript@5.5.4)
+      '@types/d3-scale':
+        specifier: ^4.0.8
+        version: 4.0.8
+      '@types/d3-scale-chromatic':
+        specifier: ^3.0.3
+        version: 3.0.3
+      '@types/dompurify':
+        specifier: ^3.0.5
+        version: 3.0.5
+      autoprefixer:
+        specifier: ^10.4.20
+        version: 10.4.20(postcss@8.4.41)
+      cssnano:
+        specifier: ^7.0.5
+        version: 7.0.5(postcss@8.4.41)
+      postcss:
+        specifier: ^8.4.41
+        version: 8.4.41
+      rollup:
+        specifier: ^4.21.0
+        version: 4.21.0
+      rollup-plugin-copy:
+        specifier: ^3.5.0
+        version: 3.5.0
+      rollup-plugin-html-bundle:
+        specifier: ^0.0.3
+        version: 0.0.3
+      rollup-plugin-livereload:
+        specifier: ^2.0.5
+        version: 2.0.5
+      rollup-plugin-postcss:
+        specifier: ^4.0.2
+        version: 4.0.2(postcss@8.4.41)
+      rollup-plugin-serve:
+        specifier: ^1.1.1
+        version: 1.1.1
+      rollup-plugin-svelte:
+        specifier: ^7.2.2
+        version: 7.2.2(rollup@4.21.0)(svelte@4.2.18)
+      sirv-cli:
+        specifier: ^2.0.2
+        version: 2.0.2
+      svelte:
+        specifier: ^4.2.18
+        version: 4.2.18
+      svelte-preprocess:
+        specifier: ^6.0.2
+        version: 6.0.2(postcss-load-config@4.0.2(postcss@8.4.41))(postcss@8.4.41)(svelte@4.2.18)(typescript@5.5.4)
+      tailwindcss:
+        specifier: ^3.4.10
+        version: 3.4.10
+      tslib:
+        specifier: ^2.6.3
+        version: 2.6.3
+      typescript:
+        specifier: ^5.5.4
+        version: 5.5.4
+
+packages:
+
+  '@alloc/quick-lru@5.2.0':
+    resolution: {integrity: sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==}
+    engines: {node: '>=10'}
+
+  '@ampproject/remapping@2.3.0':
+    resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==}
+    engines: {node: '>=6.0.0'}
+
+  '@isaacs/cliui@8.0.2':
+    resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
+    engines: {node: '>=12'}
+
+  '@jridgewell/gen-mapping@0.3.5':
+    resolution: {integrity: sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/resolve-uri@3.1.2':
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/set-array@1.2.1':
+    resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/source-map@0.3.6':
+    resolution: {integrity: sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==}
+
+  '@jridgewell/sourcemap-codec@1.5.0':
+    resolution: {integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==}
+
+  '@jridgewell/trace-mapping@0.3.25':
+    resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==}
+
+  '@nodelib/fs.scandir@2.1.5':
+    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.stat@2.0.5':
+    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.walk@1.2.8':
+    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
+    engines: {node: '>= 8'}
+
+  '@pkgjs/parseargs@0.11.0':
+    resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
+    engines: {node: '>=14'}
+
+  '@polka/url@1.0.0-next.25':
+    resolution: {integrity: sha512-j7P6Rgr3mmtdkeDGTe0E/aYyWEWVtc5yFXtHCRHs28/jptDEWfaVOc5T7cblqy1XKPPfCxJc/8DwQ5YgLOZOVQ==}
+
+  '@rollup/plugin-commonjs@26.0.1':
+    resolution: {integrity: sha512-UnsKoZK6/aGIH6AdkptXhNvhaqftcjq3zZdT+LY5Ftms6JR06nADcDsYp5hTU9E2lbJUEOhdlY5J4DNTneM+jQ==}
+    engines: {node: '>=16.0.0 || 14 >= 14.17'}
+    peerDependencies:
+      rollup: ^2.68.0||^3.0.0||^4.0.0
+    peerDependenciesMeta:
+      rollup:
+        optional: true
+
+  '@rollup/plugin-node-resolve@15.2.3':
+    resolution: {integrity: sha512-j/lym8nf5E21LwBT4Df1VD6hRO2L2iwUeUmP7litikRsVp1H6NWx20NEp0Y7su+7XGc476GnXXc4kFeZNGmaSQ==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      rollup: ^2.78.0||^3.0.0||^4.0.0
+    peerDependenciesMeta:
+      rollup:
+        optional: true
+
+  '@rollup/plugin-terser@0.4.4':
+    resolution: {integrity: sha512-XHeJC5Bgvs8LfukDwWZp7yeqin6ns8RTl2B9avbejt6tZqsqvVoWI7ZTQrcNsfKEDWBTnTxM8nMDkO2IFFbd0A==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      rollup: ^2.0.0||^3.0.0||^4.0.0
+    peerDependenciesMeta:
+      rollup:
+        optional: true
+
+  '@rollup/plugin-typescript@11.1.6':
+    resolution: {integrity: sha512-R92yOmIACgYdJ7dJ97p4K69I8gg6IEHt8M7dUBxN3W6nrO8uUxX5ixl0yU/N3aZTi8WhPuICvOHXQvF6FaykAA==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      rollup: ^2.14.0||^3.0.0||^4.0.0
+      tslib: '*'
+      typescript: '>=3.7.0'
+    peerDependenciesMeta:
+      rollup:
+        optional: true
+      tslib:
+        optional: true
+
+  '@rollup/pluginutils@4.2.1':
+    resolution: {integrity: sha512-iKnFXr7NkdZAIHiIWE+BX5ULi/ucVFYWD6TbAV+rZctiRTY2PL6tsIKhoIOaoskiWAkgu+VsbXgUVDNLHf+InQ==}
+    engines: {node: '>= 8.0.0'}
+
+  '@rollup/pluginutils@5.1.0':
+    resolution: {integrity: sha512-XTIWOPPcpvyKI6L1NHo0lFlCyznUEyPmPY1mc3KpPVDYulHSTvyeLNVW00QTLIAFNhR3kYnJTQHeGqU4M3n09g==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0
+    peerDependenciesMeta:
+      rollup:
+        optional: true
+
+  '@rollup/rollup-android-arm-eabi@4.21.0':
+    resolution: {integrity: sha512-WTWD8PfoSAJ+qL87lE7votj3syLavxunWhzCnx3XFxFiI/BA/r3X7MUM8dVrH8rb2r4AiO8jJsr3ZjdaftmnfA==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/rollup-android-arm64@4.21.0':
+    resolution: {integrity: sha512-a1sR2zSK1B4eYkiZu17ZUZhmUQcKjk2/j9Me2IDjk1GHW7LB5Z35LEzj9iJch6gtUfsnvZs1ZNyDW2oZSThrkA==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/rollup-darwin-arm64@4.21.0':
+    resolution: {integrity: sha512-zOnKWLgDld/svhKO5PD9ozmL6roy5OQ5T4ThvdYZLpiOhEGY+dp2NwUmxK0Ld91LrbjrvtNAE0ERBwjqhZTRAA==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/rollup-darwin-x64@4.21.0':
+    resolution: {integrity: sha512-7doS8br0xAkg48SKE2QNtMSFPFUlRdw9+votl27MvT46vo44ATBmdZdGysOevNELmZlfd+NEa0UYOA8f01WSrg==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.21.0':
+    resolution: {integrity: sha512-pWJsfQjNWNGsoCq53KjMtwdJDmh/6NubwQcz52aEwLEuvx08bzcy6tOUuawAOncPnxz/3siRtd8hiQ32G1y8VA==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm-musleabihf@4.21.0':
+    resolution: {integrity: sha512-efRIANsz3UHZrnZXuEvxS9LoCOWMGD1rweciD6uJQIx2myN3a8Im1FafZBzh7zk1RJ6oKcR16dU3UPldaKd83w==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-gnu@4.21.0':
+    resolution: {integrity: sha512-ZrPhydkTVhyeGTW94WJ8pnl1uroqVHM3j3hjdquwAcWnmivjAwOYjTEAuEDeJvGX7xv3Z9GAvrBkEzCgHq9U1w==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-arm64-musl@4.21.0':
+    resolution: {integrity: sha512-cfaupqd+UEFeURmqNP2eEvXqgbSox/LHOyN9/d2pSdV8xTrjdg3NgOFJCtc1vQ/jEke1qD0IejbBfxleBPHnPw==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/rollup-linux-powerpc64le-gnu@4.21.0':
+    resolution: {integrity: sha512-ZKPan1/RvAhrUylwBXC9t7B2hXdpb/ufeu22pG2psV7RN8roOfGurEghw1ySmX/CmDDHNTDDjY3lo9hRlgtaHg==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/rollup-linux-riscv64-gnu@4.21.0':
+    resolution: {integrity: sha512-H1eRaCwd5E8eS8leiS+o/NqMdljkcb1d6r2h4fKSsCXQilLKArq6WS7XBLDu80Yz+nMqHVFDquwcVrQmGr28rg==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/rollup-linux-s390x-gnu@4.21.0':
+    resolution: {integrity: sha512-zJ4hA+3b5tu8u7L58CCSI0A9N1vkfwPhWd/puGXwtZlsB5bTkwDNW/+JCU84+3QYmKpLi+XvHdmrlwUwDA6kqw==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-gnu@4.21.0':
+    resolution: {integrity: sha512-e2hrvElFIh6kW/UNBQK/kzqMNY5mO+67YtEh9OA65RM5IJXYTWiXjX6fjIiPaqOkBthYF1EqgiZ6OXKcQsM0hg==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-linux-x64-musl@4.21.0':
+    resolution: {integrity: sha512-1vvmgDdUSebVGXWX2lIcgRebqfQSff0hMEkLJyakQ9JQUbLDkEaMsPTLOmyccyC6IJ/l3FZuJbmrBw/u0A0uCQ==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/rollup-win32-arm64-msvc@4.21.0':
+    resolution: {integrity: sha512-s5oFkZ/hFcrlAyBTONFY1TWndfyre1wOMwU+6KCpm/iatybvrRgmZVM+vCFwxmC5ZhdlgfE0N4XorsDpi7/4XQ==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/rollup-win32-ia32-msvc@4.21.0':
+    resolution: {integrity: sha512-G9+TEqRnAA6nbpqyUqgTiopmnfgnMkR3kMukFBDsiyy23LZvUCpiUwjTRx6ezYCjJODXrh52rBR9oXvm+Fp5wg==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/rollup-win32-x64-msvc@4.21.0':
+    resolution: {integrity: sha512-2jsCDZwtQvRhejHLfZ1JY6w6kEuEtfF9nzYsZxzSlNVKDX+DpsDJ+Rbjkm74nvg2rdx0gwBS+IMdvwJuq3S9pQ==}
+    cpu: [x64]
+    os: [win32]
+
+  '@trysound/sax@0.2.0':
+    resolution: {integrity: sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==}
+    engines: {node: '>=10.13.0'}
+
+  '@types/d3-scale-chromatic@3.0.3':
+    resolution: {integrity: sha512-laXM4+1o5ImZv3RpFAsTRn3TEkzqkytiOY0Dz0sq5cnd1dtNlk6sHLon4OvqaiJb28T0S/TdsBI3Sjsy+keJrw==}
+
+  '@types/d3-scale@4.0.8':
+    resolution: {integrity: sha512-gkK1VVTr5iNiYJ7vWDI+yUFFlszhNMtVeneJ6lUTKPjprsvLLI9/tgEGiXJOnlINJA8FyA88gfnQsHbybVZrYQ==}
+
+  '@types/d3-time@3.0.3':
+    resolution: {integrity: sha512-2p6olUZ4w3s+07q3Tm2dbiMZy5pCDfYwtLXXHUnVzXgQlZ/OyPtUz6OL382BkOuGlLXqfT+wqv8Fw2v8/0geBw==}
+
+  '@types/dompurify@3.0.5':
+    resolution: {integrity: sha512-1Wg0g3BtQF7sSb27fJQAKck1HECM6zV1EB66j8JH9i3LCjYabJa0FSdiSgsD5K/RbrsR0SiraKacLB+T8ZVYAg==}
+
+  '@types/estree@1.0.5':
+    resolution: {integrity: sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==}
+
+  '@types/fs-extra@8.1.5':
+    resolution: {integrity: sha512-0dzKcwO+S8s2kuF5Z9oUWatQJj5Uq/iqphEtE3GQJVRRYm/tD1LglU2UnXi2A8jLq5umkGouOXOR9y0n613ZwQ==}
+
+  '@types/glob@7.2.0':
+    resolution: {integrity: sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==}
+
+  '@types/minimatch@5.1.2':
+    resolution: {integrity: sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==}
+
+  '@types/node@22.5.0':
+    resolution: {integrity: sha512-DkFrJOe+rfdHTqqMg0bSNlGlQ85hSoh2TPzZyhHsXnMtligRWpxUySiyw8FY14ITt24HVCiQPWxS3KO/QlGmWg==}
+
+  '@types/resolve@1.20.2':
+    resolution: {integrity: sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==}
+
+  '@types/trusted-types@2.0.7':
+    resolution: {integrity: sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==}
+
+  acorn@8.12.1:
+    resolution: {integrity: sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
+  ansi-regex@5.0.1:
+    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+    engines: {node: '>=8'}
+
+  ansi-regex@6.0.1:
+    resolution: {integrity: sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==}
+    engines: {node: '>=12'}
+
+  ansi-styles@4.3.0:
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
+
+  ansi-styles@6.2.1:
+    resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==}
+    engines: {node: '>=12'}
+
+  any-promise@1.3.0:
+    resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==}
+
+  anymatch@3.1.3:
+    resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
+    engines: {node: '>= 8'}
+
+  arg@5.0.2:
+    resolution: {integrity: sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==}
+
+  aria-query@5.3.0:
+    resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==}
+
+  array-union@2.1.0:
+    resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
+    engines: {node: '>=8'}
+
+  autoprefixer@10.4.20:
+    resolution: {integrity: sha512-XY25y5xSv/wEoqzDyXXME4AFfkZI0P23z6Fs3YgymDnKJkCGOnkL0iTxCa85UTqaSgfcqyf3UA6+c7wUvx/16g==}
+    engines: {node: ^10 || ^12 || >=14}
+    hasBin: true
+    peerDependencies:
+      postcss: ^8.1.0
+
+  axobject-query@4.1.0:
+    resolution: {integrity: sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==}
+    engines: {node: '>= 0.4'}
+
+  balanced-match@1.0.2:
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+
+  binary-extensions@2.3.0:
+    resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==}
+    engines: {node: '>=8'}
+
+  boolbase@1.0.0:
+    resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==}
+
+  brace-expansion@1.1.11:
+    resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
+
+  brace-expansion@2.0.1:
+    resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==}
+
+  braces@3.0.3:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
+
+  browserslist@4.23.3:
+    resolution: {integrity: sha512-btwCFJVjI4YWDNfau8RhZ+B1Q/VLoUITrm3RlP6y1tYGWIOa+InuYiRGXUBXo8nA1qKmHMyLB/iVQg5TT4eFoA==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
+
+  buffer-from@1.1.2:
+    resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
+
+  builtin-modules@3.3.0:
+    resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==}
+    engines: {node: '>=6'}
+
+  camelcase-css@2.0.1:
+    resolution: {integrity: sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==}
+    engines: {node: '>= 6'}
+
+  caniuse-api@3.0.0:
+    resolution: {integrity: sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==}
+
+  caniuse-lite@1.0.30001651:
+    resolution: {integrity: sha512-9Cf+Xv1jJNe1xPZLGuUXLNkE1BoDkqRqYyFJ9TDYSqhduqA4hu4oR9HluGoWYQC/aj8WHjsGVV+bwkh0+tegRg==}
+
+  chalk@4.1.2:
+    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
+    engines: {node: '>=10'}
+
+  chokidar@3.6.0:
+    resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==}
+    engines: {node: '>= 8.10.0'}
+
+  code-red@1.0.4:
+    resolution: {integrity: sha512-7qJWqItLA8/VPVlKJlFXU+NBlo/qyfs39aJcuMT/2ere32ZqvF5OSxgdM5xOfJJ7O429gg2HM47y8v9P+9wrNw==}
+
+  color-convert@2.0.1:
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
+
+  color-name@1.1.4:
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+
+  colord@2.9.3:
+    resolution: {integrity: sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==}
+
+  colorette@1.4.0:
+    resolution: {integrity: sha512-Y2oEozpomLn7Q3HFP7dpww7AtMJplbM9lGZP6RDfHqmbeRjiwRg4n6VM6j4KLmRke85uWEI7JqF17f3pqdRA0g==}
+
+  commander@2.20.3:
+    resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
+
+  commander@4.1.1:
+    resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==}
+    engines: {node: '>= 6'}
+
+  commander@7.2.0:
+    resolution: {integrity: sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==}
+    engines: {node: '>= 10'}
+
+  commondir@1.0.1:
+    resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==}
+
+  concat-map@0.0.1:
+    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
+
+  concat-with-sourcemaps@1.1.0:
+    resolution: {integrity: sha512-4gEjHJFT9e+2W/77h/DS5SGUgwDaOwprX8L/gl5+3ixnzkVJJsZWDSelmN3Oilw3LNDZjZV0yqH1hLG3k6nghg==}
+
+  console-clear@1.1.1:
+    resolution: {integrity: sha512-pMD+MVR538ipqkG5JXeOEbKWS5um1H4LUUccUQG68qpeqBYbzYy79Gh55jkd2TtPdRfUaLWdv6LPP//5Zt0aPQ==}
+    engines: {node: '>=4'}
+
+  cross-spawn@7.0.3:
+    resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==}
+    engines: {node: '>= 8'}
+
+  css-declaration-sorter@6.4.1:
+    resolution: {integrity: sha512-rtdthzxKuyq6IzqX6jEcIzQF/YqccluefyCYheovBOLhFT/drQA9zj/UbRAa9J7C0o6EG6u3E6g+vKkay7/k3g==}
+    engines: {node: ^10 || ^12 || >=14}
+    peerDependencies:
+      postcss: ^8.0.9
+
+  css-declaration-sorter@7.2.0:
+    resolution: {integrity: sha512-h70rUM+3PNFuaBDTLe8wF/cdWu+dOZmb7pJt8Z2sedYbAcQVQV/tEchueg3GWxwqS0cxtbxmaHEdkNACqcvsow==}
+    engines: {node: ^14 || ^16 || >=18}
+    peerDependencies:
+      postcss: ^8.0.9
+
+  css-select@4.3.0:
+    resolution: {integrity: sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==}
+
+  css-select@5.1.0:
+    resolution: {integrity: sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==}
+
+  css-tree@1.1.3:
+    resolution: {integrity: sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==}
+    engines: {node: '>=8.0.0'}
+
+  css-tree@2.2.1:
+    resolution: {integrity: sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==}
+    engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0, npm: '>=7.0.0'}
+
+  css-tree@2.3.1:
+    resolution: {integrity: sha512-6Fv1DV/TYw//QF5IzQdqsNDjx/wc8TrMBZsqjL9eW01tWb7R7k/mq+/VXfJCl7SoD5emsJop9cOByJZfs8hYIw==}
+    engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0}
+
+  css-what@6.1.0:
+    resolution: {integrity: sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==}
+    engines: {node: '>= 6'}
+
+  cssesc@3.0.0:
+    resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  cssnano-preset-default@5.2.14:
+    resolution: {integrity: sha512-t0SFesj/ZV2OTylqQVOrFgEh5uanxbO6ZAdeCrNsUQ6fVuXwYTxJPNAGvGTxHbD68ldIJNec7PyYZDBrfDQ+6A==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  cssnano-preset-default@7.0.5:
+    resolution: {integrity: sha512-Jbzja0xaKwc5JzxPQoc+fotKpYtWEu4wQLMQe29CM0FjjdRjA4omvbGHl2DTGgARKxSTpPssBsok+ixv8uTBqw==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  cssnano-utils@3.1.0:
+    resolution: {integrity: sha512-JQNR19/YZhz4psLX/rQ9M83e3z2Wf/HdJbryzte4a3NSuafyp9w/I4U+hx5C2S9g41qlstH7DEWnZaaj83OuEA==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  cssnano-utils@5.0.0:
+    resolution: {integrity: sha512-Uij0Xdxc24L6SirFr25MlwC2rCFX6scyUmuKpzI+JQ7cyqDEwD42fJ0xfB3yLfOnRDU5LKGgjQ9FA6LYh76GWQ==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  cssnano@5.1.15:
+    resolution: {integrity: sha512-j+BKgDcLDQA+eDifLx0EO4XSA56b7uut3BQFH+wbSaSTuGLuiyTa/wbRYthUXX8LC9mLg+WWKe8h+qJuwTAbHw==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  cssnano@7.0.5:
+    resolution: {integrity: sha512-Aq0vqBLtpTT5Yxj+hLlLfNPFuRQCDIjx5JQAhhaedQKLNDvDGeVziF24PS+S1f0Z5KCxWvw0QVI3VNHNBITxVQ==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  csso@4.2.0:
+    resolution: {integrity: sha512-wvlcdIbf6pwKEk7vHj8/Bkc0B4ylXZruLvOgs9doS5eOsOpuodOV2zJChSpkp+pRpYQLQMeF04nr3Z68Sta9jA==}
+    engines: {node: '>=8.0.0'}
+
+  csso@5.0.5:
+    resolution: {integrity: sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==}
+    engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0, npm: '>=7.0.0'}
+
+  d3-array@3.2.4:
+    resolution: {integrity: sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==}
+    engines: {node: '>=12'}
+
+  d3-color@3.1.0:
+    resolution: {integrity: sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==}
+    engines: {node: '>=12'}
+
+  d3-format@3.1.0:
+    resolution: {integrity: sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA==}
+    engines: {node: '>=12'}
+
+  d3-interpolate@3.0.1:
+    resolution: {integrity: sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==}
+    engines: {node: '>=12'}
+
+  d3-scale-chromatic@3.1.0:
+    resolution: {integrity: sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ==}
+    engines: {node: '>=12'}
+
+  d3-scale@4.0.2:
+    resolution: {integrity: sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==}
+    engines: {node: '>=12'}
+
+  d3-time-format@4.1.0:
+    resolution: {integrity: sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==}
+    engines: {node: '>=12'}
+
+  d3-time@3.1.0:
+    resolution: {integrity: sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==}
+    engines: {node: '>=12'}
+
+  deepmerge@4.3.1:
+    resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
+    engines: {node: '>=0.10.0'}
+
+  dequal@2.0.3:
+    resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
+    engines: {node: '>=6'}
+
+  didyoumean@1.2.2:
+    resolution: {integrity: sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==}
+
+  dir-glob@3.0.1:
+    resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
+    engines: {node: '>=8'}
+
+  dlv@1.1.3:
+    resolution: {integrity: sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==}
+
+  dom-serializer@1.4.1:
+    resolution: {integrity: sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==}
+
+  dom-serializer@2.0.0:
+    resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==}
+
+  domelementtype@2.3.0:
+    resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==}
+
+  domhandler@4.3.1:
+    resolution: {integrity: sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==}
+    engines: {node: '>= 4'}
+
+  domhandler@5.0.3:
+    resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==}
+    engines: {node: '>= 4'}
+
+  dompurify@3.1.7:
+    resolution: {integrity: sha512-VaTstWtsneJY8xzy7DekmYWEOZcmzIe3Qb3zPd4STve1OBTa+e+WmS1ITQec1fZYXI3HCsOZZiSMpG6oxoWMWQ==}
+
+  domutils@2.8.0:
+    resolution: {integrity: sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==}
+
+  domutils@3.1.0:
+    resolution: {integrity: sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==}
+
+  eastasianwidth@0.2.0:
+    resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
+
+  electron-to-chromium@1.5.13:
+    resolution: {integrity: sha512-lbBcvtIJ4J6sS4tb5TLp1b4LyfCdMkwStzXPyAgVgTRAsep4bvrAGaBOP7ZJtQMNJpSQ9SqG4brWOroNaQtm7Q==}
+
+  emoji-regex@8.0.0:
+    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
+
+  emoji-regex@9.2.2:
+    resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
+
+  entities@2.2.0:
+    resolution: {integrity: sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==}
+
+  entities@4.5.0:
+    resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
+    engines: {node: '>=0.12'}
+
+  escalade@3.1.2:
+    resolution: {integrity: sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==}
+    engines: {node: '>=6'}
+
+  estree-walker@0.6.1:
+    resolution: {integrity: sha512-SqmZANLWS0mnatqbSfRP5g8OXZC12Fgg1IwNtLsyHDzJizORW4khDfjPqJZsemPWBB2uqykUah5YpQ6epsqC/w==}
+
+  estree-walker@2.0.2:
+    resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
+
+  estree-walker@3.0.3:
+    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
+  eventemitter3@4.0.7:
+    resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
+
+  fast-glob@3.3.2:
+    resolution: {integrity: sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==}
+    engines: {node: '>=8.6.0'}
+
+  fastq@1.17.1:
+    resolution: {integrity: sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==}
+
+  fill-range@7.1.1:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
+
+  foreground-child@3.3.0:
+    resolution: {integrity: sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==}
+    engines: {node: '>=14'}
+
+  fraction.js@4.3.7:
+    resolution: {integrity: sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==}
+
+  fs-extra@8.1.0:
+    resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==}
+    engines: {node: '>=6 <7 || >=8'}
+
+  fs.realpath@1.0.0:
+    resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==}
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  function-bind@1.1.2:
+    resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
+
+  generic-names@4.0.0:
+    resolution: {integrity: sha512-ySFolZQfw9FoDb3ed9d80Cm9f0+r7qj+HJkWjeD9RBfpxEVTlVhol+gvaQB/78WbwYfbnNh8nWHHBSlg072y6A==}
+
+  get-port@3.2.0:
+    resolution: {integrity: sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==}
+    engines: {node: '>=4'}
+
+  glob-parent@5.1.2:
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
+
+  glob-parent@6.0.2:
+    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
+    engines: {node: '>=10.13.0'}
+
+  glob@10.4.5:
+    resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==}
+    hasBin: true
+
+  glob@7.2.3:
+    resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
+    deprecated: Glob versions prior to v9 are no longer supported
+
+  globby@10.0.1:
+    resolution: {integrity: sha512-sSs4inE1FB2YQiymcmTv6NWENryABjUNPeWhOvmn4SjtKybglsyPZxFB3U1/+L1bYi0rNZDqCLlHyLYDl1Pq5A==}
+    engines: {node: '>=8'}
+
+  graceful-fs@4.2.11:
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
+
+  has-flag@4.0.0:
+    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+    engines: {node: '>=8'}
+
+  hasown@2.0.2:
+    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+    engines: {node: '>= 0.4'}
+
+  icss-replace-symbols@1.1.0:
+    resolution: {integrity: sha512-chIaY3Vh2mh2Q3RGXttaDIzeiPvaVXJ+C4DAh/w3c37SKZ/U6PGMmuicR2EQQp9bKG8zLMCl7I+PtIoOOPp8Gg==}
+
+  icss-utils@5.1.0:
+    resolution: {integrity: sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==}
+    engines: {node: ^10 || ^12 || >= 14}
+    peerDependencies:
+      postcss: ^8.1.0
+
+  ignore@5.3.2:
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
+
+  import-cwd@3.0.0:
+    resolution: {integrity: sha512-4pnzH16plW+hgvRECbDWpQl3cqtvSofHWh44met7ESfZ8UZOWWddm8hEyDTqREJ9RbYHY8gi8DqmaelApoOGMg==}
+    engines: {node: '>=8'}
+
+  import-from@3.0.0:
+    resolution: {integrity: sha512-CiuXOFFSzkU5x/CR0+z7T91Iht4CXgfCxVOFRhh2Zyhg5wOpWvvDLQUsWl+gcN+QscYBjez8hDCt85O7RLDttQ==}
+    engines: {node: '>=8'}
+
+  inflight@1.0.6:
+    resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
+    deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.
+
+  inherits@2.0.4:
+    resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
+
+  internmap@2.0.3:
+    resolution: {integrity: sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==}
+    engines: {node: '>=12'}
+
+  is-binary-path@2.1.0:
+    resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
+    engines: {node: '>=8'}
+
+  is-builtin-module@3.2.1:
+    resolution: {integrity: sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==}
+    engines: {node: '>=6'}
+
+  is-core-module@2.15.1:
+    resolution: {integrity: sha512-z0vtXSwucUJtANQWldhbtbt7BnL0vxiFjIdDLAatwhDYty2bad6s+rijD6Ri4YuYJubLzIJLUidCh09e1djEVQ==}
+    engines: {node: '>= 0.4'}
+
+  is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-fullwidth-code-point@3.0.0:
+    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
+    engines: {node: '>=8'}
+
+  is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
+  is-module@1.0.0:
+    resolution: {integrity: sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==}
+
+  is-number@7.0.0:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+
+  is-plain-object@3.0.1:
+    resolution: {integrity: sha512-Xnpx182SBMrr/aBik8y+GuR4U1L9FqMSojwDQwPMmxyC6bvEqly9UBCxhauBF5vNh2gwWJNX6oDV7O+OM4z34g==}
+    engines: {node: '>=0.10.0'}
+
+  is-reference@1.2.1:
+    resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==}
+
+  is-reference@3.0.2:
+    resolution: {integrity: sha512-v3rht/LgVcsdZa3O2Nqs+NMowLOxeOm7Ay9+/ARQ2F+qEoANRcqrjAZKGN0v8ymUetZGgkp26LTnGT7H0Qo9Pg==}
+
+  isexe@2.0.0:
+    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
+
+  jackspeak@3.4.3:
+    resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==}
+
+  jiti@1.21.6:
+    resolution: {integrity: sha512-2yTgeWTWzMWkHu6Jp9NKgePDaYHbntiwvYuuJLbbN9vl7DC9DvXKOB2BC3ZZ92D3cvV/aflH0osDfwpHepQ53w==}
+    hasBin: true
+
+  jsonfile@4.0.0:
+    resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==}
+
+  kleur@4.1.5:
+    resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==}
+    engines: {node: '>=6'}
+
+  lilconfig@2.1.0:
+    resolution: {integrity: sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==}
+    engines: {node: '>=10'}
+
+  lilconfig@3.1.2:
+    resolution: {integrity: sha512-eop+wDAvpItUys0FWkHIKeC9ybYrTGbU41U5K7+bttZZeohvnY7M9dZ5kB21GNWiFT2q1OoPTvncPCgSOVO5ow==}
+    engines: {node: '>=14'}
+
+  lines-and-columns@1.2.4:
+    resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
+
+  livereload-js@3.4.1:
+    resolution: {integrity: sha512-5MP0uUeVCec89ZbNOT/i97Mc+q3SxXmiUGhRFOTmhrGPn//uWVQdCvcLJDy64MSBR5MidFdOR7B9viumoavy6g==}
+
+  livereload@0.9.3:
+    resolution: {integrity: sha512-q7Z71n3i4X0R9xthAryBdNGVGAO2R5X+/xXpmKeuPMrteg+W2U8VusTKV3YiJbXZwKsOlFlHe+go6uSNjfxrZw==}
+    engines: {node: '>=8.0.0'}
+    hasBin: true
+
+  loader-utils@3.3.1:
+    resolution: {integrity: sha512-FMJTLMXfCLMLfJxcX9PFqX5qD88Z5MRGaZCVzfuqeZSPsyiBzs+pahDQjbIWz2QIzPZz0NX9Zy4FX3lmK6YHIg==}
+    engines: {node: '>= 12.13.0'}
+
+  local-access@1.1.0:
+    resolution: {integrity: sha512-XfegD5pyTAfb+GY6chk283Ox5z8WexG56OvM06RWLpAc/UHozO8X6xAxEkIitZOtsSMM1Yr3DkHgW5W+onLhCw==}
+    engines: {node: '>=6'}
+
+  locate-character@3.0.0:
+    resolution: {integrity: sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==}
+
+  lodash.camelcase@4.3.0:
+    resolution: {integrity: sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==}
+
+  lodash.memoize@4.1.2:
+    resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==}
+
+  lodash.uniq@4.5.0:
+    resolution: {integrity: sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==}
+
+  lru-cache@10.4.3:
+    resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
+
+  magic-string@0.30.11:
+    resolution: {integrity: sha512-+Wri9p0QHMy+545hKww7YAu5NyzF8iomPL/RQazugQ9+Ez4Ic3mERMd8ZTX5rfK944j+560ZJi8iAwgak1Ac7A==}
+
+  mdn-data@2.0.14:
+    resolution: {integrity: sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow==}
+
+  mdn-data@2.0.28:
+    resolution: {integrity: sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g==}
+
+  mdn-data@2.0.30:
+    resolution: {integrity: sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==}
+
+  merge2@1.4.1:
+    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
+    engines: {node: '>= 8'}
+
+  micromatch@4.0.7:
+    resolution: {integrity: sha512-LPP/3KorzCwBxfeUuZmaR6bG2kdeHSbe0P2tY3FLRU4vYrjYz5hI4QZwV0njUx3jeuKe67YukQ1LSPZBKDqO/Q==}
+    engines: {node: '>=8.6'}
+
+  mime@2.6.0:
+    resolution: {integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==}
+    engines: {node: '>=4.0.0'}
+    hasBin: true
+
+  minimatch@3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+
+  minimatch@9.0.5:
+    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  minipass@7.1.2:
+    resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  mri@1.2.0:
+    resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
+    engines: {node: '>=4'}
+
+  mrmime@2.0.0:
+    resolution: {integrity: sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==}
+    engines: {node: '>=10'}
+
+  mz@2.7.0:
+    resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==}
+
+  nanoid@3.3.7:
+    resolution: {integrity: sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  node-releases@2.0.18:
+    resolution: {integrity: sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==}
+
+  normalize-path@3.0.0:
+    resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
+    engines: {node: '>=0.10.0'}
+
+  normalize-range@0.1.2:
+    resolution: {integrity: sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==}
+    engines: {node: '>=0.10.0'}
+
+  normalize-url@6.1.0:
+    resolution: {integrity: sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==}
+    engines: {node: '>=10'}
+
+  nth-check@2.1.1:
+    resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==}
+
+  object-assign@4.1.1:
+    resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
+    engines: {node: '>=0.10.0'}
+
+  object-hash@3.0.0:
+    resolution: {integrity: sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==}
+    engines: {node: '>= 6'}
+
+  once@1.4.0:
+    resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
+
+  opener@1.5.2:
+    resolution: {integrity: sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==}
+    hasBin: true
+
+  opts@2.0.2:
+    resolution: {integrity: sha512-k41FwbcLnlgnFh69f4qdUfvDQ+5vaSDnVPFI/y5XuhKRq97EnVVneO9F1ESVCdiVu4fCS2L8usX3mU331hB7pg==}
+
+  p-finally@1.0.0:
+    resolution: {integrity: sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==}
+    engines: {node: '>=4'}
+
+  p-queue@6.6.2:
+    resolution: {integrity: sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==}
+    engines: {node: '>=8'}
+
+  p-timeout@3.2.0:
+    resolution: {integrity: sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==}
+    engines: {node: '>=8'}
+
+  package-json-from-dist@1.0.0:
+    resolution: {integrity: sha512-dATvCeZN/8wQsGywez1mzHtTlP22H8OEfPrVMLNr4/eGa+ijtLn/6M5f0dY8UKNrC2O9UCU6SSoG3qRKnt7STw==}
+
+  path-is-absolute@1.0.1:
+    resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==}
+    engines: {node: '>=0.10.0'}
+
+  path-key@3.1.1:
+    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
+    engines: {node: '>=8'}
+
+  path-parse@1.0.7:
+    resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
+
+  path-scurry@1.11.1:
+    resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
+    engines: {node: '>=16 || 14 >=14.18'}
+
+  path-type@4.0.0:
+    resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
+    engines: {node: '>=8'}
+
+  periscopic@3.1.0:
+    resolution: {integrity: sha512-vKiQ8RRtkl9P+r/+oefh25C3fhybptkHKCZSPlcXiJux2tJF55GnEj3BVn4A5gKfq9NWWXXrxkHBwVPUfH0opw==}
+
+  picocolors@1.0.1:
+    resolution: {integrity: sha512-anP1Z8qwhkbmu7MFP5iTt+wQKXgwzf7zTyGlcdzabySa9vd0Xt392U0rVmz9poOaBj0uHJKyyo9/upk0HrEQew==}
+
+  picomatch@2.3.1:
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+    engines: {node: '>=8.6'}
+
+  pify@2.3.0:
+    resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==}
+    engines: {node: '>=0.10.0'}
+
+  pify@5.0.0:
+    resolution: {integrity: sha512-eW/gHNMlxdSP6dmG6uJip6FXN0EQBwm2clYYd8Wul42Cwu/DK8HEftzsapcNdYe2MfLiIwZqsDk2RDEsTE79hA==}
+    engines: {node: '>=10'}
+
+  pirates@4.0.6:
+    resolution: {integrity: sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==}
+    engines: {node: '>= 6'}
+
+  postcss-calc@10.0.2:
+    resolution: {integrity: sha512-DT/Wwm6fCKgpYVI7ZEWuPJ4az8hiEHtCUeYjZXqU7Ou4QqYh1Df2yCQ7Ca6N7xqKPFkxN3fhf+u9KSoOCJNAjg==}
+    engines: {node: ^18.12 || ^20.9 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.38
+
+  postcss-calc@8.2.4:
+    resolution: {integrity: sha512-SmWMSJmB8MRnnULldx0lQIyhSNvuDl9HfrZkaqqE/WHAhToYsAvDq+yAsA/kIyINDszOp3Rh0GFoNuH5Ypsm3Q==}
+    peerDependencies:
+      postcss: ^8.2.2
+
+  postcss-colormin@5.3.1:
+    resolution: {integrity: sha512-UsWQG0AqTFQmpBegeLLc1+c3jIqBNB0zlDGRWR+dQ3pRKJL1oeMzyqmH3o2PIfn9MBdNrVPWhDbT769LxCTLJQ==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-colormin@7.0.2:
+    resolution: {integrity: sha512-YntRXNngcvEvDbEjTdRWGU606eZvB5prmHG4BF0yLmVpamXbpsRJzevyy6MZVyuecgzI2AWAlvFi8DAeCqwpvA==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-convert-values@5.1.3:
+    resolution: {integrity: sha512-82pC1xkJZtcJEfiLw6UXnXVXScgtBrjlO5CBmuDQc+dlb88ZYheFsjTn40+zBVi3DkfF7iezO0nJUPLcJK3pvA==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-convert-values@7.0.3:
+    resolution: {integrity: sha512-yJhocjCs2SQer0uZ9lXTMOwDowbxvhwFVrZeS6NPEij/XXthl73ggUmfwVvJM+Vaj5gtCKJV1jiUu4IhAUkX/Q==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-discard-comments@5.1.2:
+    resolution: {integrity: sha512-+L8208OVbHVF2UQf1iDmRcbdjJkuBF6IS29yBDSiWUIzpYaAhtNl6JYnYm12FnkeCwQqF5LeklOu6rAqgfBZqQ==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-discard-comments@7.0.2:
+    resolution: {integrity: sha512-/Hje9Ls1IYcB9duELO/AyDUJI6aQVY3h5Rj1ziXgaLYCTi1iVBLnjg/TS0D6NszR/kDG6I86OwLmAYe+bvJjiQ==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-discard-duplicates@5.1.0:
+    resolution: {integrity: sha512-zmX3IoSI2aoenxHV6C7plngHWWhUOV3sP1T8y2ifzxzbtnuhk1EdPwm0S1bIUNaJ2eNbWeGLEwzw8huPD67aQw==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-discard-duplicates@7.0.1:
+    resolution: {integrity: sha512-oZA+v8Jkpu1ct/xbbrntHRsfLGuzoP+cpt0nJe5ED2FQF8n8bJtn7Bo28jSmBYwqgqnqkuSXJfSUEE7if4nClQ==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-discard-empty@5.1.1:
+    resolution: {integrity: sha512-zPz4WljiSuLWsI0ir4Mcnr4qQQ5e1Ukc3i7UfE2XcrwKK2LIPIqE5jxMRxO6GbI3cv//ztXDsXwEWT3BHOGh3A==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-discard-empty@7.0.0:
+    resolution: {integrity: sha512-e+QzoReTZ8IAwhnSdp/++7gBZ/F+nBq9y6PomfwORfP7q9nBpK5AMP64kOt0bA+lShBFbBDcgpJ3X4etHg4lzA==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-discard-overridden@5.1.0:
+    resolution: {integrity: sha512-21nOL7RqWR1kasIVdKs8HNqQJhFxLsyRfAnUDm4Fe4t4mCWL9OJiHvlHPjcd8zc5Myu89b/7wZDnOSjFgeWRtw==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-discard-overridden@7.0.0:
+    resolution: {integrity: sha512-GmNAzx88u3k2+sBTZrJSDauR0ccpE24omTQCVmaTTZFz1du6AasspjaUPMJ2ud4RslZpoFKyf+6MSPETLojc6w==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-import@15.1.0:
+    resolution: {integrity: sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      postcss: ^8.0.0
+
+  postcss-js@4.0.1:
+    resolution: {integrity: sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==}
+    engines: {node: ^12 || ^14 || >= 16}
+    peerDependencies:
+      postcss: ^8.4.21
+
+  postcss-load-config@3.1.4:
+    resolution: {integrity: sha512-6DiM4E7v4coTE4uzA8U//WhtPwyhiim3eyjEMFCnUpzbrkK9wJHgKDT2mR+HbtSrd/NubVaYTOpSpjUl8NQeRg==}
+    engines: {node: '>= 10'}
+    peerDependencies:
+      postcss: '>=8.0.9'
+      ts-node: '>=9.0.0'
+    peerDependenciesMeta:
+      postcss:
+        optional: true
+      ts-node:
+        optional: true
+
+  postcss-load-config@4.0.2:
+    resolution: {integrity: sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==}
+    engines: {node: '>= 14'}
+    peerDependencies:
+      postcss: '>=8.0.9'
+      ts-node: '>=9.0.0'
+    peerDependenciesMeta:
+      postcss:
+        optional: true
+      ts-node:
+        optional: true
+
+  postcss-merge-longhand@5.1.7:
+    resolution: {integrity: sha512-YCI9gZB+PLNskrK0BB3/2OzPnGhPkBEwmwhfYk1ilBHYVAZB7/tkTHFBAnCrvBBOmeYyMYw3DMjT55SyxMBzjQ==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-merge-longhand@7.0.3:
+    resolution: {integrity: sha512-8waYomFxshdv6M9Em3QRM9MettRLDRcH2JQi2l0Z1KlYD/vhal3gbkeSES0NuACXOlZBB0V/B0AseHZaklzWOA==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-merge-rules@5.1.4:
+    resolution: {integrity: sha512-0R2IuYpgU93y9lhVbO/OylTtKMVcHb67zjWIfCiKR9rWL3GUk1677LAqD/BcHizukdZEjT8Ru3oHRoAYoJy44g==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-merge-rules@7.0.3:
+    resolution: {integrity: sha512-2eSas2p3voPxNfdI5sQrvIkMaeUHpVc3EezgVs18hz/wRTQAC9U99tp9j3W5Jx9/L3qHkEDvizEx/LdnmumIvQ==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-minify-font-values@5.1.0:
+    resolution: {integrity: sha512-el3mYTgx13ZAPPirSVsHqFzl+BBBDrXvbySvPGFnQcTI4iNslrPaFq4muTkLZmKlGk4gyFAYUBMH30+HurREyA==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-minify-font-values@7.0.0:
+    resolution: {integrity: sha512-2ckkZtgT0zG8SMc5aoNwtm5234eUx1GGFJKf2b1bSp8UflqaeFzR50lid4PfqVI9NtGqJ2J4Y7fwvnP/u1cQog==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-minify-gradients@5.1.1:
+    resolution: {integrity: sha512-VGvXMTpCEo4qHTNSa9A0a3D+dxGFZCYwR6Jokk+/3oB6flu2/PnPXAh2x7x52EkY5xlIHLm+Le8tJxe/7TNhzw==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-minify-gradients@7.0.0:
+    resolution: {integrity: sha512-pdUIIdj/C93ryCHew0UgBnL2DtUS3hfFa5XtERrs4x+hmpMYGhbzo6l/Ir5de41O0GaKVpK1ZbDNXSY6GkXvtg==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-minify-params@5.1.4:
+    resolution: {integrity: sha512-+mePA3MgdmVmv6g+30rn57USjOGSAyuxUmkfiWpzalZ8aiBkdPYjXWtHuwJGm1v5Ojy0Z0LaSYhHaLJQB0P8Jw==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-minify-params@7.0.2:
+    resolution: {integrity: sha512-nyqVLu4MFl9df32zTsdcLqCFfE/z2+f8GE1KHPxWOAmegSo6lpV2GNy5XQvrzwbLmiU7d+fYay4cwto1oNdAaQ==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-minify-selectors@5.2.1:
+    resolution: {integrity: sha512-nPJu7OjZJTsVUmPdm2TcaiohIwxP+v8ha9NehQ2ye9szv4orirRU3SDdtUmKH+10nzn0bAyOXZ0UEr7OpvLehg==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-minify-selectors@7.0.3:
+    resolution: {integrity: sha512-SxTgUQSgBk6wEqzQZKEv1xQYIp9UBju6no9q+npohzSdhuSICQdkqmD1UMKkZWItS3olJSJMDDEY9WOJ5oGJew==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-modules-extract-imports@3.1.0:
+    resolution: {integrity: sha512-k3kNe0aNFQDAZGbin48pL2VNidTF0w4/eASDsxlyspobzU3wZQLOGj7L9gfRe0Jo9/4uud09DsjFNH7winGv8Q==}
+    engines: {node: ^10 || ^12 || >= 14}
+    peerDependencies:
+      postcss: ^8.1.0
+
+  postcss-modules-local-by-default@4.0.5:
+    resolution: {integrity: sha512-6MieY7sIfTK0hYfafw1OMEG+2bg8Q1ocHCpoWLqOKj3JXlKu4G7btkmM/B7lFubYkYWmRSPLZi5chid63ZaZYw==}
+    engines: {node: ^10 || ^12 || >= 14}
+    peerDependencies:
+      postcss: ^8.1.0
+
+  postcss-modules-scope@3.2.0:
+    resolution: {integrity: sha512-oq+g1ssrsZOsx9M96c5w8laRmvEu9C3adDSjI8oTcbfkrTE8hx/zfyobUoWIxaKPO8bt6S62kxpw5GqypEw1QQ==}
+    engines: {node: ^10 || ^12 || >= 14}
+    peerDependencies:
+      postcss: ^8.1.0
+
+  postcss-modules-values@4.0.0:
+    resolution: {integrity: sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==}
+    engines: {node: ^10 || ^12 || >= 14}
+    peerDependencies:
+      postcss: ^8.1.0
+
+  postcss-modules@4.3.1:
+    resolution: {integrity: sha512-ItUhSUxBBdNamkT3KzIZwYNNRFKmkJrofvC2nWab3CPKhYBQ1f27XXh1PAPE27Psx58jeelPsxWB/+og+KEH0Q==}
+    peerDependencies:
+      postcss: ^8.0.0
+
+  postcss-nested@6.2.0:
+    resolution: {integrity: sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==}
+    engines: {node: '>=12.0'}
+    peerDependencies:
+      postcss: ^8.2.14
+
+  postcss-normalize-charset@5.1.0:
+    resolution: {integrity: sha512-mSgUJ+pd/ldRGVx26p2wz9dNZ7ji6Pn8VWBajMXFf8jk7vUoSrZ2lt/wZR7DtlZYKesmZI680qjr2CeFF2fbUg==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-normalize-charset@7.0.0:
+    resolution: {integrity: sha512-ABisNUXMeZeDNzCQxPxBCkXexvBrUHV+p7/BXOY+ulxkcjUZO0cp8ekGBwvIh2LbCwnWbyMPNJVtBSdyhM2zYQ==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-normalize-display-values@5.1.0:
+    resolution: {integrity: sha512-WP4KIM4o2dazQXWmFaqMmcvsKmhdINFblgSeRgn8BJ6vxaMyaJkwAzpPpuvSIoG/rmX3M+IrRZEz2H0glrQNEA==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-normalize-display-values@7.0.0:
+    resolution: {integrity: sha512-lnFZzNPeDf5uGMPYgGOw7v0BfB45+irSRz9gHQStdkkhiM0gTfvWkWB5BMxpn0OqgOQuZG/mRlZyJxp0EImr2Q==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-normalize-positions@5.1.1:
+    resolution: {integrity: sha512-6UpCb0G4eofTCQLFVuI3EVNZzBNPiIKcA1AKVka+31fTVySphr3VUgAIULBhxZkKgwLImhzMR2Bw1ORK+37INg==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-normalize-positions@7.0.0:
+    resolution: {integrity: sha512-I0yt8wX529UKIGs2y/9Ybs2CelSvItfmvg/DBIjTnoUSrPxSV7Z0yZ8ShSVtKNaV/wAY+m7bgtyVQLhB00A1NQ==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-normalize-repeat-style@5.1.1:
+    resolution: {integrity: sha512-mFpLspGWkQtBcWIRFLmewo8aC3ImN2i/J3v8YCFUwDnPu3Xz4rLohDO26lGjwNsQxB3YF0KKRwspGzE2JEuS0g==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-normalize-repeat-style@7.0.0:
+    resolution: {integrity: sha512-o3uSGYH+2q30ieM3ppu9GTjSXIzOrRdCUn8UOMGNw7Af61bmurHTWI87hRybrP6xDHvOe5WlAj3XzN6vEO8jLw==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-normalize-string@5.1.0:
+    resolution: {integrity: sha512-oYiIJOf4T9T1N4i+abeIc7Vgm/xPCGih4bZz5Nm0/ARVJ7K6xrDlLwvwqOydvyL3RHNf8qZk6vo3aatiw/go3w==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-normalize-string@7.0.0:
+    resolution: {integrity: sha512-w/qzL212DFVOpMy3UGyxrND+Kb0fvCiBBujiaONIihq7VvtC7bswjWgKQU/w4VcRyDD8gpfqUiBQ4DUOwEJ6Qg==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-normalize-timing-functions@5.1.0:
+    resolution: {integrity: sha512-DOEkzJ4SAXv5xkHl0Wa9cZLF3WCBhF3o1SKVxKQAa+0pYKlueTpCgvkFAHfk+Y64ezX9+nITGrDZeVGgITJXjg==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-normalize-timing-functions@7.0.0:
+    resolution: {integrity: sha512-tNgw3YV0LYoRwg43N3lTe3AEWZ66W7Dh7lVEpJbHoKOuHc1sLrzMLMFjP8SNULHaykzsonUEDbKedv8C+7ej6g==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-normalize-unicode@5.1.1:
+    resolution: {integrity: sha512-qnCL5jzkNUmKVhZoENp1mJiGNPcsJCs1aaRmURmeJGES23Z/ajaln+EPTD+rBeNkSryI+2WTdW+lwcVdOikrpA==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-normalize-unicode@7.0.2:
+    resolution: {integrity: sha512-ztisabK5C/+ZWBdYC+Y9JCkp3M9qBv/XFvDtSw0d/XwfT3UaKeW/YTm/MD/QrPNxuecia46vkfEhewjwcYFjkg==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-normalize-url@5.1.0:
+    resolution: {integrity: sha512-5upGeDO+PVthOxSmds43ZeMeZfKH+/DKgGRD7TElkkyS46JXAUhMzIKiCa7BabPeIy3AQcTkXwVVN7DbqsiCew==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-normalize-url@7.0.0:
+    resolution: {integrity: sha512-+d7+PpE+jyPX1hDQZYG+NaFD+Nd2ris6r8fPTBAjE8z/U41n/bib3vze8x7rKs5H1uEw5ppe9IojewouHk0klQ==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-normalize-whitespace@5.1.1:
+    resolution: {integrity: sha512-83ZJ4t3NUDETIHTa3uEg6asWjSBYL5EdkVB0sDncx9ERzOKBVJIUeDO9RyA9Zwtig8El1d79HBp0JEi8wvGQnA==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-normalize-whitespace@7.0.0:
+    resolution: {integrity: sha512-37/toN4wwZErqohedXYqWgvcHUGlT8O/m2jVkAfAe9Bd4MzRqlBmXrJRePH0e9Wgnz2X7KymTgTOaaFizQe3AQ==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-ordered-values@5.1.3:
+    resolution: {integrity: sha512-9UO79VUhPwEkzbb3RNpqqghc6lcYej1aveQteWY+4POIwlqkYE21HKWaLDF6lWNuqCobEAyTovVhtI32Rbv2RQ==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-ordered-values@7.0.1:
+    resolution: {integrity: sha512-irWScWRL6nRzYmBOXReIKch75RRhNS86UPUAxXdmW/l0FcAsg0lvAXQCby/1lymxn/o0gVa6Rv/0f03eJOwHxw==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-reduce-initial@5.1.2:
+    resolution: {integrity: sha512-dE/y2XRaqAi6OvjzD22pjTUQ8eOfc6m/natGHgKFBK9DxFmIm69YmaRVQrGgFlEfc1HePIurY0TmDeROK05rIg==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-reduce-initial@7.0.2:
+    resolution: {integrity: sha512-pOnu9zqQww7dEKf62Nuju6JgsW2V0KRNBHxeKohU+JkHd/GAH5uvoObqFLqkeB2n20mr6yrlWDvo5UBU5GnkfA==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-reduce-transforms@5.1.0:
+    resolution: {integrity: sha512-2fbdbmgir5AvpW9RLtdONx1QoYG2/EtqpNQbFASDlixBbAYuTcJ0dECwlqNqH7VbaUnEnh8SrxOe2sRIn24XyQ==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-reduce-transforms@7.0.0:
+    resolution: {integrity: sha512-pnt1HKKZ07/idH8cpATX/ujMbtOGhUfE+m8gbqwJE05aTaNw8gbo34a2e3if0xc0dlu75sUOiqvwCGY3fzOHew==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-selector-parser@6.1.2:
+    resolution: {integrity: sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==}
+    engines: {node: '>=4'}
+
+  postcss-svgo@5.1.0:
+    resolution: {integrity: sha512-D75KsH1zm5ZrHyxPakAxJWtkyXew5qwS70v56exwvw542d9CRtTo78K0WeFxZB4G7JXKKMbEZtZayTGdIky/eA==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-svgo@7.0.1:
+    resolution: {integrity: sha512-0WBUlSL4lhD9rA5k1e5D8EN5wCEyZD6HJk0jIvRxl+FDVOMlJ7DePHYWGGVc5QRqrJ3/06FTXM0bxjmJpmTPSA==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >= 18}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-unique-selectors@5.1.1:
+    resolution: {integrity: sha512-5JiODlELrz8L2HwxfPnhOWZYWDxVHWL83ufOv84NrcgipI7TaeRsatAhK4Tr2/ZiYldpK/wBvw5BD3qfaK96GA==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  postcss-unique-selectors@7.0.2:
+    resolution: {integrity: sha512-CjSam+7Vf8cflJQsHrMS0P2hmy9u0+n/P001kb5eAszLmhjMqrt/i5AqQuNFihhViwDvEAezqTmXqaYXL2ugMw==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  postcss-value-parser@4.2.0:
+    resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==}
+
+  postcss@8.4.41:
+    resolution: {integrity: sha512-TesUflQ0WKZqAvg52PWL6kHgLKP6xB6heTOdoYM0Wt2UHyxNa4K25EZZMgKns3BH1RLVbZCREPpLY0rhnNoHVQ==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  promise.series@0.2.0:
+    resolution: {integrity: sha512-VWQJyU2bcDTgZw8kpfBpB/ejZASlCrzwz5f2hjb/zlujOEB4oeiAhHygAWq8ubsX2GVkD4kCU5V2dwOTaCY5EQ==}
+    engines: {node: '>=0.12'}
+
+  queue-microtask@1.2.3:
+    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
+
+  randombytes@2.1.0:
+    resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==}
+
+  read-cache@1.0.0:
+    resolution: {integrity: sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==}
+
+  readdirp@3.6.0:
+    resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
+    engines: {node: '>=8.10.0'}
+
+  resolve-from@5.0.0:
+    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
+    engines: {node: '>=8'}
+
+  resolve.exports@2.0.2:
+    resolution: {integrity: sha512-X2UW6Nw3n/aMgDVy+0rSqgHlv39WZAlZrXCdnbyEiKm17DSqHX4MmQMaST3FbeWR5FTuRcUwYAziZajji0Y7mg==}
+    engines: {node: '>=10'}
+
+  resolve@1.22.8:
+    resolution: {integrity: sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==}
+    hasBin: true
+
+  reusify@1.0.4:
+    resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==}
+    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
+
+  rollup-plugin-copy@3.5.0:
+    resolution: {integrity: sha512-wI8D5dvYovRMx/YYKtUNt3Yxaw4ORC9xo6Gt9t22kveWz1enG9QrhVlagzwrxSC455xD1dHMKhIJkbsQ7d48BA==}
+    engines: {node: '>=8.3'}
+
+  rollup-plugin-html-bundle@0.0.3:
+    resolution: {integrity: sha512-vGMJTnpb57cT8p/BL2igUdohEAofxebRujd11Fk1ZY2zE0xGa3YMvzX4PH1kRUKm4nuQvFeW3ZdIksB9ZGzurw==}
+
+  rollup-plugin-livereload@2.0.5:
+    resolution: {integrity: sha512-vqQZ/UQowTW7VoiKEM5ouNW90wE5/GZLfdWuR0ELxyKOJUIaj+uismPZZaICU4DnWPVjnpCDDxEqwU7pcKY/PA==}
+    engines: {node: '>=8.3'}
+
+  rollup-plugin-postcss@4.0.2:
+    resolution: {integrity: sha512-05EaY6zvZdmvPUDi3uCcAQoESDcYnv8ogJJQRp6V5kZ6J6P7uAVJlrTZcaaA20wTH527YTnKfkAoPxWI/jPp4w==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      postcss: 8.x
+
+  rollup-plugin-serve@1.1.1:
+    resolution: {integrity: sha512-H0VarZRtFR0lfiiC9/P8jzCDvtFf1liOX4oSdIeeYqUCKrmFA7vNiQ0rg2D+TuoP7leaa/LBR8XBts5viF6lnw==}
+
+  rollup-plugin-svelte@7.2.2:
+    resolution: {integrity: sha512-hgnIblTRewaBEVQD6N0Q43o+y6q1TmDRhBjaEzQCi50bs8TXqjc+d1zFZyE8tsfgcfNHZQzclh4RxlFUB85H8Q==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      rollup: '>=2.0.0'
+      svelte: '>=3.5.0'
+
+  rollup-pluginutils@2.8.2:
+    resolution: {integrity: sha512-EEp9NhnUkwY8aif6bxgovPHMoMoNr2FulJziTndpt5H9RdwC47GSGuII9XxpSdzVGM0GWrNPHV6ie1LTNJPaLQ==}
+
+  rollup@4.21.0:
+    resolution: {integrity: sha512-vo+S/lfA2lMS7rZ2Qoubi6I5hwZwzXeUIctILZLbHI+laNtvhhOIon2S1JksA5UEDQ7l3vberd0fxK44lTYjbQ==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
+  run-parallel@1.2.0:
+    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
+
+  sade@1.8.1:
+    resolution: {integrity: sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==}
+    engines: {node: '>=6'}
+
+  safe-buffer@5.2.1:
+    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
+
+  safe-identifier@0.4.2:
+    resolution: {integrity: sha512-6pNbSMW6OhAi9j+N8V+U715yBQsaWJ7eyEUaOrawX+isg5ZxhUlV1NipNtgaKHmFGiABwt+ZF04Ii+3Xjkg+8w==}
+
+  semiver@1.1.0:
+    resolution: {integrity: sha512-QNI2ChmuioGC1/xjyYwyZYADILWyW6AmS1UH6gDj/SFUUUS4MBAWs/7mxnkRPc/F4iHezDP+O8t0dO8WHiEOdg==}
+    engines: {node: '>=6'}
+
+  serialize-javascript@6.0.2:
+    resolution: {integrity: sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==}
+
+  shebang-command@2.0.0:
+    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
+    engines: {node: '>=8'}
+
+  shebang-regex@3.0.0:
+    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
+    engines: {node: '>=8'}
+
+  signal-exit@4.1.0:
+    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
+    engines: {node: '>=14'}
+
+  sirv-cli@2.0.2:
+    resolution: {integrity: sha512-OtSJDwxsF1NWHc7ps3Sa0s+dPtP15iQNJzfKVz+MxkEo3z72mCD+yu30ct79rPr0CaV1HXSOBp+MIY5uIhHZ1A==}
+    engines: {node: '>= 10'}
+    hasBin: true
+
+  sirv@2.0.4:
+    resolution: {integrity: sha512-94Bdh3cC2PKrbgSOUqTiGPWVZeSiXfKOVZNJniWoqrWrRkB1CJzBU3NEbiTsPcYy1lDsANA/THzS+9WBiy5nfQ==}
+    engines: {node: '>= 10'}
+
+  slash@3.0.0:
+    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
+    engines: {node: '>=8'}
+
+  smob@1.5.0:
+    resolution: {integrity: sha512-g6T+p7QO8npa+/hNx9ohv1E5pVCmWrVCUzUXJyLdMmftX6ER0oiWY/w9knEonLpnOp6b6FenKnMfR8gqwWdwig==}
+
+  source-map-js@1.2.0:
+    resolution: {integrity: sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg==}
+    engines: {node: '>=0.10.0'}
+
+  source-map-support@0.5.21:
+    resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
+
+  source-map@0.6.1:
+    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
+    engines: {node: '>=0.10.0'}
+
+  stable@0.1.8:
+    resolution: {integrity: sha512-ji9qxRnOVfcuLDySj9qzhGSEFVobyt1kIOSkj1qZzYLzq7Tos/oUUWvotUPQLlrsidqsK6tBH89Bc9kL5zHA6w==}
+    deprecated: 'Modern JS already guarantees Array#sort() is a stable sort, so this library is deprecated. See the compatibility table on MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#browser_compatibility'
+
+  string-hash@1.1.3:
+    resolution: {integrity: sha512-kJUvRUFK49aub+a7T1nNE66EJbZBMnBgoC1UbCZ5n6bsZKBRga4KgBRTMn/pFkeCZSYtNeSyMxPDM0AXWELk2A==}
+
+  string-width@4.2.3:
+    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
+    engines: {node: '>=8'}
+
+  string-width@5.1.2:
+    resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==}
+    engines: {node: '>=12'}
+
+  strip-ansi@6.0.1:
+    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
+    engines: {node: '>=8'}
+
+  strip-ansi@7.1.0:
+    resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==}
+    engines: {node: '>=12'}
+
+  style-inject@0.3.0:
+    resolution: {integrity: sha512-IezA2qp+vcdlhJaVm5SOdPPTUu0FCEqfNSli2vRuSIBbu5Nq5UvygTk/VzeCqfLz2Atj3dVII5QBKGZRZ0edzw==}
+
+  stylehacks@5.1.1:
+    resolution: {integrity: sha512-sBpcd5Hx7G6seo7b1LkpttvTz7ikD0LlH5RmdcBNb6fFR0Fl7LQwHDFr300q4cwUqi+IYrFGmsIHieMBfnN/Bw==}
+    engines: {node: ^10 || ^12 || >=14.0}
+    peerDependencies:
+      postcss: ^8.2.15
+
+  stylehacks@7.0.3:
+    resolution: {integrity: sha512-4DqtecvI/Nd+2BCvW9YEF6lhBN5UM50IJ1R3rnEAhBwbCKf4VehRf+uqvnVArnBayjYD/WtT3g0G/HSRxWfTRg==}
+    engines: {node: ^18.12.0 || ^20.9.0 || >=22.0}
+    peerDependencies:
+      postcss: ^8.4.31
+
+  sucrase@3.35.0:
+    resolution: {integrity: sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    hasBin: true
+
+  supports-color@7.2.0:
+    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+    engines: {node: '>=8'}
+
+  supports-preserve-symlinks-flag@1.0.0:
+    resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
+    engines: {node: '>= 0.4'}
+
+  svelte-preprocess@6.0.2:
+    resolution: {integrity: sha512-OvDTLfaOkkhjprbDKO0SOCkjNYuHy16dbD4SpqbIi6QiabOMHxRT4km5/dzbFFkmW1L0E2INF3MFltG2pgOyKQ==}
+    engines: {node: '>= 18.0.0'}
+    peerDependencies:
+      '@babel/core': ^7.10.2
+      coffeescript: ^2.5.1
+      less: ^3.11.3 || ^4.0.0
+      postcss: ^7 || ^8
+      postcss-load-config: '>=3'
+      pug: ^3.0.0
+      sass: ^1.26.8
+      stylus: '>=0.55'
+      sugarss: ^2.0.0 || ^3.0.0 || ^4.0.0
+      svelte: ^4.0.0 || ^5.0.0-next.100 || ^5.0.0
+      typescript: ^5.0.0
+    peerDependenciesMeta:
+      '@babel/core':
+        optional: true
+      coffeescript:
+        optional: true
+      less:
+        optional: true
+      postcss:
+        optional: true
+      postcss-load-config:
+        optional: true
+      pug:
+        optional: true
+      sass:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      typescript:
+        optional: true
+
+  svelte@4.2.18:
+    resolution: {integrity: sha512-d0FdzYIiAePqRJEb90WlJDkjUEx42xhivxN8muUBmfZnP+tzUgz12DJ2hRJi8sIHCME7jeK1PTMgKPSfTd8JrA==}
+    engines: {node: '>=16'}
+
+  svgo@2.8.0:
+    resolution: {integrity: sha512-+N/Q9kV1+F+UeWYoSiULYo4xYSDQlTgb+ayMobAXPwMnLvop7oxKMo9OzIrX5x3eS4L4f2UHhc9axXwY8DpChg==}
+    engines: {node: '>=10.13.0'}
+    hasBin: true
+
+  svgo@3.3.2:
+    resolution: {integrity: sha512-OoohrmuUlBs8B8o6MB2Aevn+pRIH9zDALSR+6hhqVfa6fRwG/Qw9VUMSMW9VNg2CFc/MTIfabtdOVl9ODIJjpw==}
+    engines: {node: '>=14.0.0'}
+    hasBin: true
+
+  tailwindcss@3.4.10:
+    resolution: {integrity: sha512-KWZkVPm7yJRhdu4SRSl9d4AK2wM3a50UsvgHZO7xY77NQr2V+fIrEuoDGQcbvswWvFGbS2f6e+jC/6WJm1Dl0w==}
+    engines: {node: '>=14.0.0'}
+    hasBin: true
+
+  terser@5.31.6:
+    resolution: {integrity: sha512-PQ4DAriWzKj+qgehQ7LK5bQqCFNMmlhjR2PFFLuqGCpuCAauxemVBWwWOxo3UIwWQx8+Pr61Df++r76wDmkQBg==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  thenify-all@1.6.0:
+    resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==}
+    engines: {node: '>=0.8'}
+
+  thenify@3.3.1:
+    resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==}
+
+  tinydate@1.3.0:
+    resolution: {integrity: sha512-7cR8rLy2QhYHpsBDBVYnnWXm8uRTr38RoZakFSW7Bs7PzfMPNZthuMLkwqZv7MTu8lhQ91cOFYS5a7iFj2oR3w==}
+    engines: {node: '>=4'}
+
+  to-regex-range@5.0.1:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+
+  totalist@3.0.1:
+    resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==}
+    engines: {node: '>=6'}
+
+  ts-interface-checker@0.1.13:
+    resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==}
+
+  tslib@2.6.3:
+    resolution: {integrity: sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==}
+
+  typescript@5.5.4:
+    resolution: {integrity: sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  undici-types@6.19.8:
+    resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==}
+
+  universalify@0.1.2:
+    resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==}
+    engines: {node: '>= 4.0.0'}
+
+  update-browserslist-db@1.1.0:
+    resolution: {integrity: sha512-EdRAaAyk2cUE1wOf2DkEhzxqOQvFOoRJFNS6NeyJ01Gp2beMRpBAINjM2iDXE3KCuKhwnvHIQCJm6ThL2Z+HzQ==}
+    hasBin: true
+    peerDependencies:
+      browserslist: '>= 4.21.0'
+
+  util-deprecate@1.0.2:
+    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
+
+  which@2.0.2:
+    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
+    engines: {node: '>= 8'}
+    hasBin: true
+
+  wrap-ansi@7.0.0:
+    resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==}
+    engines: {node: '>=10'}
+
+  wrap-ansi@8.1.0:
+    resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==}
+    engines: {node: '>=12'}
+
+  wrappy@1.0.2:
+    resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
+
+  ws@7.5.10:
+    resolution: {integrity: sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==}
+    engines: {node: '>=8.3.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: ^5.0.2
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
+  yaml@1.10.2:
+    resolution: {integrity: sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==}
+    engines: {node: '>= 6'}
+
+  yaml@2.5.0:
+    resolution: {integrity: sha512-2wWLbGbYDiSqqIKoPjar3MPgB94ErzCtrNE1FdqGuaO0pi2JGjmE8aW8TDZwzU7vuxcGRdL/4gPQwQ7hD5AMSw==}
+    engines: {node: '>= 14'}
+    hasBin: true
+
+snapshots:
+
+  '@alloc/quick-lru@5.2.0': {}
+
+  '@ampproject/remapping@2.3.0':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.5
+      '@jridgewell/trace-mapping': 0.3.25
+
+  '@isaacs/cliui@8.0.2':
+    dependencies:
+      string-width: 5.1.2
+      string-width-cjs: string-width@4.2.3
+      strip-ansi: 7.1.0
+      strip-ansi-cjs: strip-ansi@6.0.1
+      wrap-ansi: 8.1.0
+      wrap-ansi-cjs: wrap-ansi@7.0.0
+
+  '@jridgewell/gen-mapping@0.3.5':
+    dependencies:
+      '@jridgewell/set-array': 1.2.1
+      '@jridgewell/sourcemap-codec': 1.5.0
+      '@jridgewell/trace-mapping': 0.3.25
+
+  '@jridgewell/resolve-uri@3.1.2': {}
+
+  '@jridgewell/set-array@1.2.1': {}
+
+  '@jridgewell/source-map@0.3.6':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.5
+      '@jridgewell/trace-mapping': 0.3.25
+
+  '@jridgewell/sourcemap-codec@1.5.0': {}
+
+  '@jridgewell/trace-mapping@0.3.25':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.0
+
+  '@nodelib/fs.scandir@2.1.5':
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      run-parallel: 1.2.0
+
+  '@nodelib/fs.stat@2.0.5': {}
+
+  '@nodelib/fs.walk@1.2.8':
+    dependencies:
+      '@nodelib/fs.scandir': 2.1.5
+      fastq: 1.17.1
+
+  '@pkgjs/parseargs@0.11.0':
+    optional: true
+
+  '@polka/url@1.0.0-next.25': {}
+
+  '@rollup/plugin-commonjs@26.0.1(rollup@4.21.0)':
+    dependencies:
+      '@rollup/pluginutils': 5.1.0(rollup@4.21.0)
+      commondir: 1.0.1
+      estree-walker: 2.0.2
+      glob: 10.4.5
+      is-reference: 1.2.1
+      magic-string: 0.30.11
+    optionalDependencies:
+      rollup: 4.21.0
+
+  '@rollup/plugin-node-resolve@15.2.3(rollup@4.21.0)':
+    dependencies:
+      '@rollup/pluginutils': 5.1.0(rollup@4.21.0)
+      '@types/resolve': 1.20.2
+      deepmerge: 4.3.1
+      is-builtin-module: 3.2.1
+      is-module: 1.0.0
+      resolve: 1.22.8
+    optionalDependencies:
+      rollup: 4.21.0
+
+  '@rollup/plugin-terser@0.4.4(rollup@4.21.0)':
+    dependencies:
+      serialize-javascript: 6.0.2
+      smob: 1.5.0
+      terser: 5.31.6
+    optionalDependencies:
+      rollup: 4.21.0
+
+  '@rollup/plugin-typescript@11.1.6(rollup@4.21.0)(tslib@2.6.3)(typescript@5.5.4)':
+    dependencies:
+      '@rollup/pluginutils': 5.1.0(rollup@4.21.0)
+      resolve: 1.22.8
+      typescript: 5.5.4
+    optionalDependencies:
+      rollup: 4.21.0
+      tslib: 2.6.3
+
+  '@rollup/pluginutils@4.2.1':
+    dependencies:
+      estree-walker: 2.0.2
+      picomatch: 2.3.1
+
+  '@rollup/pluginutils@5.1.0(rollup@4.21.0)':
+    dependencies:
+      '@types/estree': 1.0.5
+      estree-walker: 2.0.2
+      picomatch: 2.3.1
+    optionalDependencies:
+      rollup: 4.21.0
+
+  '@rollup/rollup-android-arm-eabi@4.21.0':
+    optional: true
+
+  '@rollup/rollup-android-arm64@4.21.0':
+    optional: true
+
+  '@rollup/rollup-darwin-arm64@4.21.0':
+    optional: true
+
+  '@rollup/rollup-darwin-x64@4.21.0':
+    optional: true
+
+  '@rollup/rollup-linux-arm-gnueabihf@4.21.0':
+    optional: true
+
+  '@rollup/rollup-linux-arm-musleabihf@4.21.0':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-gnu@4.21.0':
+    optional: true
+
+  '@rollup/rollup-linux-arm64-musl@4.21.0':
+    optional: true
+
+  '@rollup/rollup-linux-powerpc64le-gnu@4.21.0':
+    optional: true
+
+  '@rollup/rollup-linux-riscv64-gnu@4.21.0':
+    optional: true
+
+  '@rollup/rollup-linux-s390x-gnu@4.21.0':
+    optional: true
+
+  '@rollup/rollup-linux-x64-gnu@4.21.0':
+    optional: true
+
+  '@rollup/rollup-linux-x64-musl@4.21.0':
+    optional: true
+
+  '@rollup/rollup-win32-arm64-msvc@4.21.0':
+    optional: true
+
+  '@rollup/rollup-win32-ia32-msvc@4.21.0':
+    optional: true
+
+  '@rollup/rollup-win32-x64-msvc@4.21.0':
+    optional: true
+
+  '@trysound/sax@0.2.0': {}
+
+  '@types/d3-scale-chromatic@3.0.3': {}
+
+  '@types/d3-scale@4.0.8':
+    dependencies:
+      '@types/d3-time': 3.0.3
+
+  '@types/d3-time@3.0.3': {}
+
+  '@types/dompurify@3.0.5':
+    dependencies:
+      '@types/trusted-types': 2.0.7
+
+  '@types/estree@1.0.5': {}
+
+  '@types/fs-extra@8.1.5':
+    dependencies:
+      '@types/node': 22.5.0
+
+  '@types/glob@7.2.0':
+    dependencies:
+      '@types/minimatch': 5.1.2
+      '@types/node': 22.5.0
+
+  '@types/minimatch@5.1.2': {}
+
+  '@types/node@22.5.0':
+    dependencies:
+      undici-types: 6.19.8
+
+  '@types/resolve@1.20.2': {}
+
+  '@types/trusted-types@2.0.7': {}
+
+  acorn@8.12.1: {}
+
+  ansi-regex@5.0.1: {}
+
+  ansi-regex@6.0.1: {}
+
+  ansi-styles@4.3.0:
+    dependencies:
+      color-convert: 2.0.1
+
+  ansi-styles@6.2.1: {}
+
+  any-promise@1.3.0: {}
+
+  anymatch@3.1.3:
+    dependencies:
+      normalize-path: 3.0.0
+      picomatch: 2.3.1
+
+  arg@5.0.2: {}
+
+  aria-query@5.3.0:
+    dependencies:
+      dequal: 2.0.3
+
+  array-union@2.1.0: {}
+
+  autoprefixer@10.4.20(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      caniuse-lite: 1.0.30001651
+      fraction.js: 4.3.7
+      normalize-range: 0.1.2
+      picocolors: 1.0.1
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  axobject-query@4.1.0: {}
+
+  balanced-match@1.0.2: {}
+
+  binary-extensions@2.3.0: {}
+
+  boolbase@1.0.0: {}
+
+  brace-expansion@1.1.11:
+    dependencies:
+      balanced-match: 1.0.2
+      concat-map: 0.0.1
+
+  brace-expansion@2.0.1:
+    dependencies:
+      balanced-match: 1.0.2
+
+  braces@3.0.3:
+    dependencies:
+      fill-range: 7.1.1
+
+  browserslist@4.23.3:
+    dependencies:
+      caniuse-lite: 1.0.30001651
+      electron-to-chromium: 1.5.13
+      node-releases: 2.0.18
+      update-browserslist-db: 1.1.0(browserslist@4.23.3)
+
+  buffer-from@1.1.2: {}
+
+  builtin-modules@3.3.0: {}
+
+  camelcase-css@2.0.1: {}
+
+  caniuse-api@3.0.0:
+    dependencies:
+      browserslist: 4.23.3
+      caniuse-lite: 1.0.30001651
+      lodash.memoize: 4.1.2
+      lodash.uniq: 4.5.0
+
+  caniuse-lite@1.0.30001651: {}
+
+  chalk@4.1.2:
+    dependencies:
+      ansi-styles: 4.3.0
+      supports-color: 7.2.0
+
+  chokidar@3.6.0:
+    dependencies:
+      anymatch: 3.1.3
+      braces: 3.0.3
+      glob-parent: 5.1.2
+      is-binary-path: 2.1.0
+      is-glob: 4.0.3
+      normalize-path: 3.0.0
+      readdirp: 3.6.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  code-red@1.0.4:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.0
+      '@types/estree': 1.0.5
+      acorn: 8.12.1
+      estree-walker: 3.0.3
+      periscopic: 3.1.0
+
+  color-convert@2.0.1:
+    dependencies:
+      color-name: 1.1.4
+
+  color-name@1.1.4: {}
+
+  colord@2.9.3: {}
+
+  colorette@1.4.0: {}
+
+  commander@2.20.3: {}
+
+  commander@4.1.1: {}
+
+  commander@7.2.0: {}
+
+  commondir@1.0.1: {}
+
+  concat-map@0.0.1: {}
+
+  concat-with-sourcemaps@1.1.0:
+    dependencies:
+      source-map: 0.6.1
+
+  console-clear@1.1.1: {}
+
+  cross-spawn@7.0.3:
+    dependencies:
+      path-key: 3.1.1
+      shebang-command: 2.0.0
+      which: 2.0.2
+
+  css-declaration-sorter@6.4.1(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  css-declaration-sorter@7.2.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  css-select@4.3.0:
+    dependencies:
+      boolbase: 1.0.0
+      css-what: 6.1.0
+      domhandler: 4.3.1
+      domutils: 2.8.0
+      nth-check: 2.1.1
+
+  css-select@5.1.0:
+    dependencies:
+      boolbase: 1.0.0
+      css-what: 6.1.0
+      domhandler: 5.0.3
+      domutils: 3.1.0
+      nth-check: 2.1.1
+
+  css-tree@1.1.3:
+    dependencies:
+      mdn-data: 2.0.14
+      source-map: 0.6.1
+
+  css-tree@2.2.1:
+    dependencies:
+      mdn-data: 2.0.28
+      source-map-js: 1.2.0
+
+  css-tree@2.3.1:
+    dependencies:
+      mdn-data: 2.0.30
+      source-map-js: 1.2.0
+
+  css-what@6.1.0: {}
+
+  cssesc@3.0.0: {}
+
+  cssnano-preset-default@5.2.14(postcss@8.4.41):
+    dependencies:
+      css-declaration-sorter: 6.4.1(postcss@8.4.41)
+      cssnano-utils: 3.1.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-calc: 8.2.4(postcss@8.4.41)
+      postcss-colormin: 5.3.1(postcss@8.4.41)
+      postcss-convert-values: 5.1.3(postcss@8.4.41)
+      postcss-discard-comments: 5.1.2(postcss@8.4.41)
+      postcss-discard-duplicates: 5.1.0(postcss@8.4.41)
+      postcss-discard-empty: 5.1.1(postcss@8.4.41)
+      postcss-discard-overridden: 5.1.0(postcss@8.4.41)
+      postcss-merge-longhand: 5.1.7(postcss@8.4.41)
+      postcss-merge-rules: 5.1.4(postcss@8.4.41)
+      postcss-minify-font-values: 5.1.0(postcss@8.4.41)
+      postcss-minify-gradients: 5.1.1(postcss@8.4.41)
+      postcss-minify-params: 5.1.4(postcss@8.4.41)
+      postcss-minify-selectors: 5.2.1(postcss@8.4.41)
+      postcss-normalize-charset: 5.1.0(postcss@8.4.41)
+      postcss-normalize-display-values: 5.1.0(postcss@8.4.41)
+      postcss-normalize-positions: 5.1.1(postcss@8.4.41)
+      postcss-normalize-repeat-style: 5.1.1(postcss@8.4.41)
+      postcss-normalize-string: 5.1.0(postcss@8.4.41)
+      postcss-normalize-timing-functions: 5.1.0(postcss@8.4.41)
+      postcss-normalize-unicode: 5.1.1(postcss@8.4.41)
+      postcss-normalize-url: 5.1.0(postcss@8.4.41)
+      postcss-normalize-whitespace: 5.1.1(postcss@8.4.41)
+      postcss-ordered-values: 5.1.3(postcss@8.4.41)
+      postcss-reduce-initial: 5.1.2(postcss@8.4.41)
+      postcss-reduce-transforms: 5.1.0(postcss@8.4.41)
+      postcss-svgo: 5.1.0(postcss@8.4.41)
+      postcss-unique-selectors: 5.1.1(postcss@8.4.41)
+
+  cssnano-preset-default@7.0.5(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      css-declaration-sorter: 7.2.0(postcss@8.4.41)
+      cssnano-utils: 5.0.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-calc: 10.0.2(postcss@8.4.41)
+      postcss-colormin: 7.0.2(postcss@8.4.41)
+      postcss-convert-values: 7.0.3(postcss@8.4.41)
+      postcss-discard-comments: 7.0.2(postcss@8.4.41)
+      postcss-discard-duplicates: 7.0.1(postcss@8.4.41)
+      postcss-discard-empty: 7.0.0(postcss@8.4.41)
+      postcss-discard-overridden: 7.0.0(postcss@8.4.41)
+      postcss-merge-longhand: 7.0.3(postcss@8.4.41)
+      postcss-merge-rules: 7.0.3(postcss@8.4.41)
+      postcss-minify-font-values: 7.0.0(postcss@8.4.41)
+      postcss-minify-gradients: 7.0.0(postcss@8.4.41)
+      postcss-minify-params: 7.0.2(postcss@8.4.41)
+      postcss-minify-selectors: 7.0.3(postcss@8.4.41)
+      postcss-normalize-charset: 7.0.0(postcss@8.4.41)
+      postcss-normalize-display-values: 7.0.0(postcss@8.4.41)
+      postcss-normalize-positions: 7.0.0(postcss@8.4.41)
+      postcss-normalize-repeat-style: 7.0.0(postcss@8.4.41)
+      postcss-normalize-string: 7.0.0(postcss@8.4.41)
+      postcss-normalize-timing-functions: 7.0.0(postcss@8.4.41)
+      postcss-normalize-unicode: 7.0.2(postcss@8.4.41)
+      postcss-normalize-url: 7.0.0(postcss@8.4.41)
+      postcss-normalize-whitespace: 7.0.0(postcss@8.4.41)
+      postcss-ordered-values: 7.0.1(postcss@8.4.41)
+      postcss-reduce-initial: 7.0.2(postcss@8.4.41)
+      postcss-reduce-transforms: 7.0.0(postcss@8.4.41)
+      postcss-svgo: 7.0.1(postcss@8.4.41)
+      postcss-unique-selectors: 7.0.2(postcss@8.4.41)
+
+  cssnano-utils@3.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  cssnano-utils@5.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  cssnano@5.1.15(postcss@8.4.41):
+    dependencies:
+      cssnano-preset-default: 5.2.14(postcss@8.4.41)
+      lilconfig: 2.1.0
+      postcss: 8.4.41
+      yaml: 1.10.2
+
+  cssnano@7.0.5(postcss@8.4.41):
+    dependencies:
+      cssnano-preset-default: 7.0.5(postcss@8.4.41)
+      lilconfig: 3.1.2
+      postcss: 8.4.41
+
+  csso@4.2.0:
+    dependencies:
+      css-tree: 1.1.3
+
+  csso@5.0.5:
+    dependencies:
+      css-tree: 2.2.1
+
+  d3-array@3.2.4:
+    dependencies:
+      internmap: 2.0.3
+
+  d3-color@3.1.0: {}
+
+  d3-format@3.1.0: {}
+
+  d3-interpolate@3.0.1:
+    dependencies:
+      d3-color: 3.1.0
+
+  d3-scale-chromatic@3.1.0:
+    dependencies:
+      d3-color: 3.1.0
+      d3-interpolate: 3.0.1
+
+  d3-scale@4.0.2:
+    dependencies:
+      d3-array: 3.2.4
+      d3-format: 3.1.0
+      d3-interpolate: 3.0.1
+      d3-time: 3.1.0
+      d3-time-format: 4.1.0
+
+  d3-time-format@4.1.0:
+    dependencies:
+      d3-time: 3.1.0
+
+  d3-time@3.1.0:
+    dependencies:
+      d3-array: 3.2.4
+
+  deepmerge@4.3.1: {}
+
+  dequal@2.0.3: {}
+
+  didyoumean@1.2.2: {}
+
+  dir-glob@3.0.1:
+    dependencies:
+      path-type: 4.0.0
+
+  dlv@1.1.3: {}
+
+  dom-serializer@1.4.1:
+    dependencies:
+      domelementtype: 2.3.0
+      domhandler: 4.3.1
+      entities: 2.2.0
+
+  dom-serializer@2.0.0:
+    dependencies:
+      domelementtype: 2.3.0
+      domhandler: 5.0.3
+      entities: 4.5.0
+
+  domelementtype@2.3.0: {}
+
+  domhandler@4.3.1:
+    dependencies:
+      domelementtype: 2.3.0
+
+  domhandler@5.0.3:
+    dependencies:
+      domelementtype: 2.3.0
+
+  dompurify@3.1.7: {}
+
+  domutils@2.8.0:
+    dependencies:
+      dom-serializer: 1.4.1
+      domelementtype: 2.3.0
+      domhandler: 4.3.1
+
+  domutils@3.1.0:
+    dependencies:
+      dom-serializer: 2.0.0
+      domelementtype: 2.3.0
+      domhandler: 5.0.3
+
+  eastasianwidth@0.2.0: {}
+
+  electron-to-chromium@1.5.13: {}
+
+  emoji-regex@8.0.0: {}
+
+  emoji-regex@9.2.2: {}
+
+  entities@2.2.0: {}
+
+  entities@4.5.0: {}
+
+  escalade@3.1.2: {}
+
+  estree-walker@0.6.1: {}
+
+  estree-walker@2.0.2: {}
+
+  estree-walker@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.5
+
+  eventemitter3@4.0.7: {}
+
+  fast-glob@3.3.2:
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      '@nodelib/fs.walk': 1.2.8
+      glob-parent: 5.1.2
+      merge2: 1.4.1
+      micromatch: 4.0.7
+
+  fastq@1.17.1:
+    dependencies:
+      reusify: 1.0.4
+
+  fill-range@7.1.1:
+    dependencies:
+      to-regex-range: 5.0.1
+
+  foreground-child@3.3.0:
+    dependencies:
+      cross-spawn: 7.0.3
+      signal-exit: 4.1.0
+
+  fraction.js@4.3.7: {}
+
+  fs-extra@8.1.0:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 4.0.0
+      universalify: 0.1.2
+
+  fs.realpath@1.0.0: {}
+
+  fsevents@2.3.3:
+    optional: true
+
+  function-bind@1.1.2: {}
+
+  generic-names@4.0.0:
+    dependencies:
+      loader-utils: 3.3.1
+
+  get-port@3.2.0: {}
+
+  glob-parent@5.1.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  glob-parent@6.0.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  glob@10.4.5:
+    dependencies:
+      foreground-child: 3.3.0
+      jackspeak: 3.4.3
+      minimatch: 9.0.5
+      minipass: 7.1.2
+      package-json-from-dist: 1.0.0
+      path-scurry: 1.11.1
+
+  glob@7.2.3:
+    dependencies:
+      fs.realpath: 1.0.0
+      inflight: 1.0.6
+      inherits: 2.0.4
+      minimatch: 3.1.2
+      once: 1.4.0
+      path-is-absolute: 1.0.1
+
+  globby@10.0.1:
+    dependencies:
+      '@types/glob': 7.2.0
+      array-union: 2.1.0
+      dir-glob: 3.0.1
+      fast-glob: 3.3.2
+      glob: 7.2.3
+      ignore: 5.3.2
+      merge2: 1.4.1
+      slash: 3.0.0
+
+  graceful-fs@4.2.11: {}
+
+  has-flag@4.0.0: {}
+
+  hasown@2.0.2:
+    dependencies:
+      function-bind: 1.1.2
+
+  icss-replace-symbols@1.1.0: {}
+
+  icss-utils@5.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  ignore@5.3.2: {}
+
+  import-cwd@3.0.0:
+    dependencies:
+      import-from: 3.0.0
+
+  import-from@3.0.0:
+    dependencies:
+      resolve-from: 5.0.0
+
+  inflight@1.0.6:
+    dependencies:
+      once: 1.4.0
+      wrappy: 1.0.2
+
+  inherits@2.0.4: {}
+
+  internmap@2.0.3: {}
+
+  is-binary-path@2.1.0:
+    dependencies:
+      binary-extensions: 2.3.0
+
+  is-builtin-module@3.2.1:
+    dependencies:
+      builtin-modules: 3.3.0
+
+  is-core-module@2.15.1:
+    dependencies:
+      hasown: 2.0.2
+
+  is-extglob@2.1.1: {}
+
+  is-fullwidth-code-point@3.0.0: {}
+
+  is-glob@4.0.3:
+    dependencies:
+      is-extglob: 2.1.1
+
+  is-module@1.0.0: {}
+
+  is-number@7.0.0: {}
+
+  is-plain-object@3.0.1: {}
+
+  is-reference@1.2.1:
+    dependencies:
+      '@types/estree': 1.0.5
+
+  is-reference@3.0.2:
+    dependencies:
+      '@types/estree': 1.0.5
+
+  isexe@2.0.0: {}
+
+  jackspeak@3.4.3:
+    dependencies:
+      '@isaacs/cliui': 8.0.2
+    optionalDependencies:
+      '@pkgjs/parseargs': 0.11.0
+
+  jiti@1.21.6: {}
+
+  jsonfile@4.0.0:
+    optionalDependencies:
+      graceful-fs: 4.2.11
+
+  kleur@4.1.5: {}
+
+  lilconfig@2.1.0: {}
+
+  lilconfig@3.1.2: {}
+
+  lines-and-columns@1.2.4: {}
+
+  livereload-js@3.4.1: {}
+
+  livereload@0.9.3:
+    dependencies:
+      chokidar: 3.6.0
+      livereload-js: 3.4.1
+      opts: 2.0.2
+      ws: 7.5.10
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  loader-utils@3.3.1: {}
+
+  local-access@1.1.0: {}
+
+  locate-character@3.0.0: {}
+
+  lodash.camelcase@4.3.0: {}
+
+  lodash.memoize@4.1.2: {}
+
+  lodash.uniq@4.5.0: {}
+
+  lru-cache@10.4.3: {}
+
+  magic-string@0.30.11:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.0
+
+  mdn-data@2.0.14: {}
+
+  mdn-data@2.0.28: {}
+
+  mdn-data@2.0.30: {}
+
+  merge2@1.4.1: {}
+
+  micromatch@4.0.7:
+    dependencies:
+      braces: 3.0.3
+      picomatch: 2.3.1
+
+  mime@2.6.0: {}
+
+  minimatch@3.1.2:
+    dependencies:
+      brace-expansion: 1.1.11
+
+  minimatch@9.0.5:
+    dependencies:
+      brace-expansion: 2.0.1
+
+  minipass@7.1.2: {}
+
+  mri@1.2.0: {}
+
+  mrmime@2.0.0: {}
+
+  mz@2.7.0:
+    dependencies:
+      any-promise: 1.3.0
+      object-assign: 4.1.1
+      thenify-all: 1.6.0
+
+  nanoid@3.3.7: {}
+
+  node-releases@2.0.18: {}
+
+  normalize-path@3.0.0: {}
+
+  normalize-range@0.1.2: {}
+
+  normalize-url@6.1.0: {}
+
+  nth-check@2.1.1:
+    dependencies:
+      boolbase: 1.0.0
+
+  object-assign@4.1.1: {}
+
+  object-hash@3.0.0: {}
+
+  once@1.4.0:
+    dependencies:
+      wrappy: 1.0.2
+
+  opener@1.5.2: {}
+
+  opts@2.0.2: {}
+
+  p-finally@1.0.0: {}
+
+  p-queue@6.6.2:
+    dependencies:
+      eventemitter3: 4.0.7
+      p-timeout: 3.2.0
+
+  p-timeout@3.2.0:
+    dependencies:
+      p-finally: 1.0.0
+
+  package-json-from-dist@1.0.0: {}
+
+  path-is-absolute@1.0.1: {}
+
+  path-key@3.1.1: {}
+
+  path-parse@1.0.7: {}
+
+  path-scurry@1.11.1:
+    dependencies:
+      lru-cache: 10.4.3
+      minipass: 7.1.2
+
+  path-type@4.0.0: {}
+
+  periscopic@3.1.0:
+    dependencies:
+      '@types/estree': 1.0.5
+      estree-walker: 3.0.3
+      is-reference: 3.0.2
+
+  picocolors@1.0.1: {}
+
+  picomatch@2.3.1: {}
+
+  pify@2.3.0: {}
+
+  pify@5.0.0: {}
+
+  pirates@4.0.6: {}
+
+  postcss-calc@10.0.2(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+      postcss-value-parser: 4.2.0
+
+  postcss-calc@8.2.4(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+      postcss-value-parser: 4.2.0
+
+  postcss-colormin@5.3.1(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      caniuse-api: 3.0.0
+      colord: 2.9.3
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-colormin@7.0.2(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      caniuse-api: 3.0.0
+      colord: 2.9.3
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-convert-values@5.1.3(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-convert-values@7.0.3(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-discard-comments@5.1.2(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  postcss-discard-comments@7.0.2(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  postcss-discard-duplicates@5.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  postcss-discard-duplicates@7.0.1(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  postcss-discard-empty@5.1.1(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  postcss-discard-empty@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  postcss-discard-overridden@5.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  postcss-discard-overridden@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  postcss-import@15.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+      read-cache: 1.0.0
+      resolve: 1.22.8
+
+  postcss-js@4.0.1(postcss@8.4.41):
+    dependencies:
+      camelcase-css: 2.0.1
+      postcss: 8.4.41
+
+  postcss-load-config@3.1.4(postcss@8.4.41):
+    dependencies:
+      lilconfig: 2.1.0
+      yaml: 1.10.2
+    optionalDependencies:
+      postcss: 8.4.41
+
+  postcss-load-config@4.0.2(postcss@8.4.41):
+    dependencies:
+      lilconfig: 3.1.2
+      yaml: 2.5.0
+    optionalDependencies:
+      postcss: 8.4.41
+
+  postcss-merge-longhand@5.1.7(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+      stylehacks: 5.1.1(postcss@8.4.41)
+
+  postcss-merge-longhand@7.0.3(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+      stylehacks: 7.0.3(postcss@8.4.41)
+
+  postcss-merge-rules@5.1.4(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      caniuse-api: 3.0.0
+      cssnano-utils: 3.1.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  postcss-merge-rules@7.0.3(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      caniuse-api: 3.0.0
+      cssnano-utils: 5.0.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  postcss-minify-font-values@5.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-minify-font-values@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-minify-gradients@5.1.1(postcss@8.4.41):
+    dependencies:
+      colord: 2.9.3
+      cssnano-utils: 3.1.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-minify-gradients@7.0.0(postcss@8.4.41):
+    dependencies:
+      colord: 2.9.3
+      cssnano-utils: 5.0.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-minify-params@5.1.4(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      cssnano-utils: 3.1.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-minify-params@7.0.2(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      cssnano-utils: 5.0.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-minify-selectors@5.2.1(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  postcss-minify-selectors@7.0.3(postcss@8.4.41):
+    dependencies:
+      cssesc: 3.0.0
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  postcss-modules-extract-imports@3.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  postcss-modules-local-by-default@4.0.5(postcss@8.4.41):
+    dependencies:
+      icss-utils: 5.1.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+      postcss-value-parser: 4.2.0
+
+  postcss-modules-scope@3.2.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  postcss-modules-values@4.0.0(postcss@8.4.41):
+    dependencies:
+      icss-utils: 5.1.0(postcss@8.4.41)
+      postcss: 8.4.41
+
+  postcss-modules@4.3.1(postcss@8.4.41):
+    dependencies:
+      generic-names: 4.0.0
+      icss-replace-symbols: 1.1.0
+      lodash.camelcase: 4.3.0
+      postcss: 8.4.41
+      postcss-modules-extract-imports: 3.1.0(postcss@8.4.41)
+      postcss-modules-local-by-default: 4.0.5(postcss@8.4.41)
+      postcss-modules-scope: 3.2.0(postcss@8.4.41)
+      postcss-modules-values: 4.0.0(postcss@8.4.41)
+      string-hash: 1.1.3
+
+  postcss-nested@6.2.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  postcss-normalize-charset@5.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  postcss-normalize-charset@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+
+  postcss-normalize-display-values@5.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-display-values@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-positions@5.1.1(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-positions@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-repeat-style@5.1.1(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-repeat-style@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-string@5.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-string@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-timing-functions@5.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-timing-functions@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-unicode@5.1.1(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-unicode@7.0.2(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-url@5.1.0(postcss@8.4.41):
+    dependencies:
+      normalize-url: 6.1.0
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-url@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-whitespace@5.1.1(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-normalize-whitespace@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-ordered-values@5.1.3(postcss@8.4.41):
+    dependencies:
+      cssnano-utils: 3.1.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-ordered-values@7.0.1(postcss@8.4.41):
+    dependencies:
+      cssnano-utils: 5.0.0(postcss@8.4.41)
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-reduce-initial@5.1.2(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      caniuse-api: 3.0.0
+      postcss: 8.4.41
+
+  postcss-reduce-initial@7.0.2(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      caniuse-api: 3.0.0
+      postcss: 8.4.41
+
+  postcss-reduce-transforms@5.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-reduce-transforms@7.0.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+
+  postcss-selector-parser@6.1.2:
+    dependencies:
+      cssesc: 3.0.0
+      util-deprecate: 1.0.2
+
+  postcss-svgo@5.1.0(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+      svgo: 2.8.0
+
+  postcss-svgo@7.0.1(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-value-parser: 4.2.0
+      svgo: 3.3.2
+
+  postcss-unique-selectors@5.1.1(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  postcss-unique-selectors@7.0.2(postcss@8.4.41):
+    dependencies:
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  postcss-value-parser@4.2.0: {}
+
+  postcss@8.4.41:
+    dependencies:
+      nanoid: 3.3.7
+      picocolors: 1.0.1
+      source-map-js: 1.2.0
+
+  promise.series@0.2.0: {}
+
+  queue-microtask@1.2.3: {}
+
+  randombytes@2.1.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  read-cache@1.0.0:
+    dependencies:
+      pify: 2.3.0
+
+  readdirp@3.6.0:
+    dependencies:
+      picomatch: 2.3.1
+
+  resolve-from@5.0.0: {}
+
+  resolve.exports@2.0.2: {}
+
+  resolve@1.22.8:
+    dependencies:
+      is-core-module: 2.15.1
+      path-parse: 1.0.7
+      supports-preserve-symlinks-flag: 1.0.0
+
+  reusify@1.0.4: {}
+
+  rollup-plugin-copy@3.5.0:
+    dependencies:
+      '@types/fs-extra': 8.1.5
+      colorette: 1.4.0
+      fs-extra: 8.1.0
+      globby: 10.0.1
+      is-plain-object: 3.0.1
+
+  rollup-plugin-html-bundle@0.0.3: {}
+
+  rollup-plugin-livereload@2.0.5:
+    dependencies:
+      livereload: 0.9.3
+    transitivePeerDependencies:
+      - bufferutil
+      - utf-8-validate
+
+  rollup-plugin-postcss@4.0.2(postcss@8.4.41):
+    dependencies:
+      chalk: 4.1.2
+      concat-with-sourcemaps: 1.1.0
+      cssnano: 5.1.15(postcss@8.4.41)
+      import-cwd: 3.0.0
+      p-queue: 6.6.2
+      pify: 5.0.0
+      postcss: 8.4.41
+      postcss-load-config: 3.1.4(postcss@8.4.41)
+      postcss-modules: 4.3.1(postcss@8.4.41)
+      promise.series: 0.2.0
+      resolve: 1.22.8
+      rollup-pluginutils: 2.8.2
+      safe-identifier: 0.4.2
+      style-inject: 0.3.0
+    transitivePeerDependencies:
+      - ts-node
+
+  rollup-plugin-serve@1.1.1:
+    dependencies:
+      mime: 2.6.0
+      opener: 1.5.2
+
+  rollup-plugin-svelte@7.2.2(rollup@4.21.0)(svelte@4.2.18):
+    dependencies:
+      '@rollup/pluginutils': 4.2.1
+      resolve.exports: 2.0.2
+      rollup: 4.21.0
+      svelte: 4.2.18
+
+  rollup-pluginutils@2.8.2:
+    dependencies:
+      estree-walker: 0.6.1
+
+  rollup@4.21.0:
+    dependencies:
+      '@types/estree': 1.0.5
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.21.0
+      '@rollup/rollup-android-arm64': 4.21.0
+      '@rollup/rollup-darwin-arm64': 4.21.0
+      '@rollup/rollup-darwin-x64': 4.21.0
+      '@rollup/rollup-linux-arm-gnueabihf': 4.21.0
+      '@rollup/rollup-linux-arm-musleabihf': 4.21.0
+      '@rollup/rollup-linux-arm64-gnu': 4.21.0
+      '@rollup/rollup-linux-arm64-musl': 4.21.0
+      '@rollup/rollup-linux-powerpc64le-gnu': 4.21.0
+      '@rollup/rollup-linux-riscv64-gnu': 4.21.0
+      '@rollup/rollup-linux-s390x-gnu': 4.21.0
+      '@rollup/rollup-linux-x64-gnu': 4.21.0
+      '@rollup/rollup-linux-x64-musl': 4.21.0
+      '@rollup/rollup-win32-arm64-msvc': 4.21.0
+      '@rollup/rollup-win32-ia32-msvc': 4.21.0
+      '@rollup/rollup-win32-x64-msvc': 4.21.0
+      fsevents: 2.3.3
+
+  run-parallel@1.2.0:
+    dependencies:
+      queue-microtask: 1.2.3
+
+  sade@1.8.1:
+    dependencies:
+      mri: 1.2.0
+
+  safe-buffer@5.2.1: {}
+
+  safe-identifier@0.4.2: {}
+
+  semiver@1.1.0: {}
+
+  serialize-javascript@6.0.2:
+    dependencies:
+      randombytes: 2.1.0
+
+  shebang-command@2.0.0:
+    dependencies:
+      shebang-regex: 3.0.0
+
+  shebang-regex@3.0.0: {}
+
+  signal-exit@4.1.0: {}
+
+  sirv-cli@2.0.2:
+    dependencies:
+      console-clear: 1.1.1
+      get-port: 3.2.0
+      kleur: 4.1.5
+      local-access: 1.1.0
+      sade: 1.8.1
+      semiver: 1.1.0
+      sirv: 2.0.4
+      tinydate: 1.3.0
+
+  sirv@2.0.4:
+    dependencies:
+      '@polka/url': 1.0.0-next.25
+      mrmime: 2.0.0
+      totalist: 3.0.1
+
+  slash@3.0.0: {}
+
+  smob@1.5.0: {}
+
+  source-map-js@1.2.0: {}
+
+  source-map-support@0.5.21:
+    dependencies:
+      buffer-from: 1.1.2
+      source-map: 0.6.1
+
+  source-map@0.6.1: {}
+
+  stable@0.1.8: {}
+
+  string-hash@1.1.3: {}
+
+  string-width@4.2.3:
+    dependencies:
+      emoji-regex: 8.0.0
+      is-fullwidth-code-point: 3.0.0
+      strip-ansi: 6.0.1
+
+  string-width@5.1.2:
+    dependencies:
+      eastasianwidth: 0.2.0
+      emoji-regex: 9.2.2
+      strip-ansi: 7.1.0
+
+  strip-ansi@6.0.1:
+    dependencies:
+      ansi-regex: 5.0.1
+
+  strip-ansi@7.1.0:
+    dependencies:
+      ansi-regex: 6.0.1
+
+  style-inject@0.3.0: {}
+
+  stylehacks@5.1.1(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  stylehacks@7.0.3(postcss@8.4.41):
+    dependencies:
+      browserslist: 4.23.3
+      postcss: 8.4.41
+      postcss-selector-parser: 6.1.2
+
+  sucrase@3.35.0:
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.5
+      commander: 4.1.1
+      glob: 10.4.5
+      lines-and-columns: 1.2.4
+      mz: 2.7.0
+      pirates: 4.0.6
+      ts-interface-checker: 0.1.13
+
+  supports-color@7.2.0:
+    dependencies:
+      has-flag: 4.0.0
+
+  supports-preserve-symlinks-flag@1.0.0: {}
+
+  svelte-preprocess@6.0.2(postcss-load-config@4.0.2(postcss@8.4.41))(postcss@8.4.41)(svelte@4.2.18)(typescript@5.5.4):
+    dependencies:
+      svelte: 4.2.18
+    optionalDependencies:
+      postcss: 8.4.41
+      postcss-load-config: 4.0.2(postcss@8.4.41)
+      typescript: 5.5.4
+
+  svelte@4.2.18:
+    dependencies:
+      '@ampproject/remapping': 2.3.0
+      '@jridgewell/sourcemap-codec': 1.5.0
+      '@jridgewell/trace-mapping': 0.3.25
+      '@types/estree': 1.0.5
+      acorn: 8.12.1
+      aria-query: 5.3.0
+      axobject-query: 4.1.0
+      code-red: 1.0.4
+      css-tree: 2.3.1
+      estree-walker: 3.0.3
+      is-reference: 3.0.2
+      locate-character: 3.0.0
+      magic-string: 0.30.11
+      periscopic: 3.1.0
+
+  svgo@2.8.0:
+    dependencies:
+      '@trysound/sax': 0.2.0
+      commander: 7.2.0
+      css-select: 4.3.0
+      css-tree: 1.1.3
+      csso: 4.2.0
+      picocolors: 1.0.1
+      stable: 0.1.8
+
+  svgo@3.3.2:
+    dependencies:
+      '@trysound/sax': 0.2.0
+      commander: 7.2.0
+      css-select: 5.1.0
+      css-tree: 2.3.1
+      css-what: 6.1.0
+      csso: 5.0.5
+      picocolors: 1.0.1
+
+  tailwindcss@3.4.10:
+    dependencies:
+      '@alloc/quick-lru': 5.2.0
+      arg: 5.0.2
+      chokidar: 3.6.0
+      didyoumean: 1.2.2
+      dlv: 1.1.3
+      fast-glob: 3.3.2
+      glob-parent: 6.0.2
+      is-glob: 4.0.3
+      jiti: 1.21.6
+      lilconfig: 2.1.0
+      micromatch: 4.0.7
+      normalize-path: 3.0.0
+      object-hash: 3.0.0
+      picocolors: 1.0.1
+      postcss: 8.4.41
+      postcss-import: 15.1.0(postcss@8.4.41)
+      postcss-js: 4.0.1(postcss@8.4.41)
+      postcss-load-config: 4.0.2(postcss@8.4.41)
+      postcss-nested: 6.2.0(postcss@8.4.41)
+      postcss-selector-parser: 6.1.2
+      resolve: 1.22.8
+      sucrase: 3.35.0
+    transitivePeerDependencies:
+      - ts-node
+
+  terser@5.31.6:
+    dependencies:
+      '@jridgewell/source-map': 0.3.6
+      acorn: 8.12.1
+      commander: 2.20.3
+      source-map-support: 0.5.21
+
+  thenify-all@1.6.0:
+    dependencies:
+      thenify: 3.3.1
+
+  thenify@3.3.1:
+    dependencies:
+      any-promise: 1.3.0
+
+  tinydate@1.3.0: {}
+
+  to-regex-range@5.0.1:
+    dependencies:
+      is-number: 7.0.0
+
+  totalist@3.0.1: {}
+
+  ts-interface-checker@0.1.13: {}
+
+  tslib@2.6.3: {}
+
+  typescript@5.5.4: {}
+
+  undici-types@6.19.8: {}
+
+  universalify@0.1.2: {}
+
+  update-browserslist-db@1.1.0(browserslist@4.23.3):
+    dependencies:
+      browserslist: 4.23.3
+      escalade: 3.1.2
+      picocolors: 1.0.1
+
+  util-deprecate@1.0.2: {}
+
+  which@2.0.2:
+    dependencies:
+      isexe: 2.0.0
+
+  wrap-ansi@7.0.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+
+  wrap-ansi@8.1.0:
+    dependencies:
+      ansi-styles: 6.2.1
+      string-width: 5.1.2
+      strip-ansi: 7.1.0
+
+  wrappy@1.0.2: {}
+
+  ws@7.5.10: {}
+
+  yaml@1.10.2: {}
+
+  yaml@2.5.0: {}
diff --git a/client/graphpaper-inline/postcss.config.js b/client/graphpaper-inline/postcss.config.js
new file mode 100644
index 000000000..48f950f50
--- /dev/null
+++ b/client/graphpaper-inline/postcss.config.js
@@ -0,0 +1,7 @@
+module.exports = {
+    plugins: {
+        tailwindcss: {},
+        autoprefixer: {},
+        cssnano: { preset: 'default' }
+    }
+}
\ No newline at end of file
diff --git a/client/graphpaper-inline/rollup.config.mjs b/client/graphpaper-inline/rollup.config.mjs
new file mode 100644
index 000000000..ff11355b8
--- /dev/null
+++ b/client/graphpaper-inline/rollup.config.mjs
@@ -0,0 +1,58 @@
+import svelte from 'rollup-plugin-svelte';
+import { sveltePreprocess } from 'svelte-preprocess';
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import terser from '@rollup/plugin-terser';
+import typescript from '@rollup/plugin-typescript';
+import postcss from 'rollup-plugin-postcss';
+import livereload from 'rollup-plugin-livereload';
+// @ts-ignore
+import serve from 'rollup-plugin-serve';
+// @ts-ignore
+import htmlBundle from 'rollup-plugin-html-bundle';
+import copy from 'rollup-plugin-copy';
+
+const production = !process.env.ROLLUP_WATCH;
+
+export default [{
+	input: 'src/main.js',
+	output: {
+		format: 'iife',
+		name: 'app',
+		file: 'build/bundle.js',
+		sourcemap: !production,
+	},
+	plugins: [
+		typescript(),
+		svelte({
+			compilerOptions: {
+				dev: !production
+			},
+			preprocess: sveltePreprocess()
+		}),
+		resolve({
+			browser: true,
+			dedupe: importee => importee === 'svelte' || importee.startsWith('svelte/'),
+			extensions: ['.svelte', '.mjs', '.ts', '.js', '.json', '.node']
+		}),
+		commonjs(),
+		postcss(),
+		copy({
+			targets: [
+				{ src: 'src/template.html', dest: 'build' }
+			]
+		}),
+		htmlBundle({
+			template: 'build/template.html',
+			target: production ? 'dist/index.html' : 'build/index.html',
+			targetElement: 'body',
+			inline: production
+		}),
+		!production && serve('build'),
+		!production && livereload('build'),
+		production && terser()
+	],
+	watch: {
+		clearScreen: false
+	}
+}];
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/App.svelte b/client/graphpaper-inline/src/App.svelte
new file mode 100644
index 000000000..7aee50b09
--- /dev/null
+++ b/client/graphpaper-inline/src/App.svelte
@@ -0,0 +1,251 @@
+<!-- Main app that handles token rendering and metrics.
+
+This has bidirectional communication between the guidance server (usually Jupyter kernel) and client.
+For upcoming features, we won't be able to send all details over the wire, and will need to operate on client request.
+-->
+<script lang="ts">
+    import './main.css';
+    import TokenGrid from './TokenGrid.svelte';
+    import ResizeListener from './ResizeListener.svelte';
+	import {
+		kernelmsg,
+		clientmsg,
+		type StitchMessage,
+		type NodeAttr,
+		type GenTokenExtra,
+		isTraceMessage,
+		isTextOutput,
+		isRoleOpenerInput,
+		isRoleCloserInput,
+		isResetDisplayMessage,
+		isMetricMessage,
+		isExecutionCompletedMessage,
+		isTokensMessage,
+		isClientReadyAckMessage,
+		isExecutionStartedMessage,
+	} from './stitch';
+    import StitchHandler from './StitchHandler.svelte';
+	import {onMount} from "svelte";
+	import {type MetricDef, type MetricVal} from "./interfaces";
+	import MetricCard from "./MetricCard.svelte";
+	import {mockGenTokens, mockNodeAttrs} from "./mocks";
+	import Select from "./Select.svelte";
+
+    let msg: any;
+    let textComponents: Array<NodeAttr> = [];
+	let tokenDetails: Array<GenTokenExtra> = [];
+	let isCompleted: boolean = false;
+	let isError: boolean = false;
+	let showMetrics: boolean = true;
+	let requireFullReplay: boolean = true;
+
+	let bgField: string = "Type";
+	let underlineField: string = "Probability";
+
+	// textComponents = mockNodeAttrs;
+	// tokenDetails = mockGenTokens;
+
+	$: if ($kernelmsg !== undefined) {
+		if ($kernelmsg.content !== '') {
+			msg = JSON.parse($kernelmsg.content);
+			if (isTraceMessage(msg)) {
+				if (isTextOutput(msg.node_attr)) {
+					textComponents.push(msg.node_attr);
+				} else if (isRoleOpenerInput(msg.node_attr)) {
+					textComponents.push(msg.node_attr)
+				} else if (isRoleCloserInput(msg.node_attr)) {
+					textComponents.push(msg.node_attr)
+				}
+			} else if (isExecutionStartedMessage(msg)) {
+				requireFullReplay = false;
+			} else if (isClientReadyAckMessage(msg)) {
+				if (requireFullReplay) {
+					console.log("Require full replay and went past completion output message.");
+					const msg: StitchMessage = {
+						type: "clientmsg",
+						content: JSON.stringify({ 'class_name': 'OutputRequestMessage' })
+					}
+					clientmsg.set(msg);
+				}
+			} else if (isResetDisplayMessage(msg)) {
+				textComponents = [];
+				isCompleted = false;
+			} else if (isMetricMessage(msg)) {
+				const name = msg.name;
+				const value = msg.value;
+
+				if (name in metrics && name in metricDefs) {
+					let currVal = metrics[name];
+					const metricDef = metricDefs[name];
+					if (metricDef.isScalar === false) {
+						if (value.constructor === Array) {
+							metrics[name] = value;
+						} else {
+							currVal = currVal as Array<any>;
+							metrics[name] = [...currVal.slice(1), value as string | number];
+						}
+					} else if (metricDef.isScalar === true) {
+						metrics[name] = value;
+					} else {
+						console.log(`Cannot handle metric: ${name}: ${value}.`)
+					}
+
+					if (name === 'status') {
+						isError = value === '⚠';
+					}
+				}
+			} else if (isExecutionCompletedMessage(msg)) {
+				isCompleted = true;
+			} else if (isTokensMessage(msg)) {
+				requireFullReplay = false;
+				isCompleted = true;
+				tokenDetails = msg.tokens;
+
+				console.log(textComponents);
+				console.log(msg.tokens);
+			}
+			textComponents = textComponents;
+		}
+	}
+
+	const metricDefs: Record<string, MetricDef> = {
+		'status': {
+			name: 'status',
+			units: '',
+			description: 'Determines whether engine is running, completed or in error.',
+			isScalar: true,
+			precision: 0,
+		},
+		'cpu': {
+			name: 'cpu',
+			units: '%',
+			description: 'Average utilization across CPU cores.',
+			isScalar: false,
+			precision: 1,
+		},
+		'gpu': {
+			name: 'gpu',
+			units: '%',
+			description: 'Average utilization across GPUs.',
+			isScalar: false,
+			precision: 1,
+		},
+		'ram': {
+			name: 'ram',
+			units: 'GB',
+			description: 'Utilization of RAM.',
+			isScalar: true,
+			precision: 1,
+		},
+		'vram': {
+			name: 'vram',
+			units: 'GB',
+			description: 'Utilization of video RAM.',
+			isScalar: true,
+			precision: 1,
+		},
+		'wall time': {
+			name: 'wall time',
+			units: 's',
+			description: 'Time taken from initial display to engine completion.',
+			isScalar: true,
+			precision: 1,
+		},
+		'avg latency': {
+			name: 'avg latency',
+			units: 'ms',
+			description: 'Average roundtrip latency per token',
+			isScalar: true,
+			precision: 0,
+		},
+		'consumed': {
+			name: 'consumed',
+			units: 'tkn',
+			description: 'Total tokens consumed by language model.',
+			isScalar: true,
+			precision: 0,
+		},
+		'token reduction': {
+			name: 'token reduction',
+			units: '%',
+			description: 'Total tokens consumed by language model divided by total tokens.',
+			isScalar: true,
+			precision: 0,
+		}
+	};
+	const metrics: Record<string, MetricVal> = {
+		'status': '⟳',
+		// 'gpu': [0.0, 0.0, 0.0, 0.0, 0.0],
+		// 'vram': 0,
+		'cpu': [0.0, 0.0, 0.0, 0.0, 0.0],
+		'ram': 0,
+		'wall time': 0,
+		'avg latency': 0,
+		'consumed': 0,
+		'token reduction': 0,
+	};
+
+	onMount(() => {
+		const msg: StitchMessage = {
+			type: "clientmsg",
+			content: JSON.stringify({ 'class_name': 'ClientReadyMessage' })
+		}
+		clientmsg.set(msg);
+	});
+
+	const onMetricClick = (_: any) => {
+		showMetrics = !showMetrics;
+	}
+	const doNothing = (_: any) => {}
+</script>
+
+<svelte:head>
+    <title>graphpaper</title>
+    <meta name="description" content="graphpaper"/>
+</svelte:head>
+
+<StitchHandler/>
+<ResizeListener/>
+<div class="w-full min-h-72">
+	<nav class="sticky top-0 z-50 opacity-90">
+		<!-- Metric bar -->
+		{#if showMetrics}
+			<section class="w-full flex bg-gray-100 border-b border-gray-200 text-gray-500 justify-between">
+				<div class="pl-2 flex">
+					{#each Object.entries(metrics) as [name, value]}
+						<MetricCard value={value} metricDef={metricDefs[name]}/>
+					{/each}
+				</div>
+			</section>
+		{/if}
+
+		<!-- Controls -->
+		<section>
+			<div class="text-sm pt-2 pb-2 flex border-b border-gray-200">
+				<div class="ml-4 mr-4 inline-flex justify-between items-center hover:bg-gray-700 hover:text-white" tabindex="-1" on:click={onMetricClick} on:keydown={doNothing} role="button">
+					<span class="text-xs inline-flex flex-col justify-center uppercase tracking-wider">
+						Metrics
+					</span>
+					{#if showMetrics}
+						<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="currentColor" class="size-3">
+							<path d="M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z" />
+							<path fill-rule="evenodd" d="M1.38 8.28a.87.87 0 0 1 0-.566 7.003 7.003 0 0 1 13.238.006.87.87 0 0 1 0 .566A7.003 7.003 0 0 1 1.379 8.28ZM11 8a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z" clip-rule="evenodd" />
+						</svg>
+					{:else}
+						<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="currentColor" class="size-3">
+							<path fill-rule="evenodd" d="M3.28 2.22a.75.75 0 0 0-1.06 1.06l10.5 10.5a.75.75 0 1 0 1.06-1.06l-1.322-1.323a7.012 7.012 0 0 0 2.16-3.11.87.87 0 0 0 0-.567A7.003 7.003 0 0 0 4.82 3.76l-1.54-1.54Zm3.196 3.195 1.135 1.136A1.502 1.502 0 0 1 9.45 8.389l1.136 1.135a3 3 0 0 0-4.109-4.109Z" clip-rule="evenodd" />
+						  	<path d="m7.812 10.994 1.816 1.816A7.003 7.003 0 0 1 1.38 8.28a.87.87 0 0 1 0-.566 6.985 6.985 0 0 1 1.113-2.039l2.513 2.513a3 3 0 0 0 2.806 2.806Z" />
+						</svg>
+					{/if}
+				</div>
+				<Select values={["None", "Type", "Probability", "Latency (ms)"]} classes="bg-gray-200" defaultValue={"Type"} on:select={(selected) => bgField = selected.detail}/>
+				<Select values={["None", "Probability", "Latency (ms)"]} classes="border-b-2 border-gray-400" defaultValue={"Probability"} on:select={(selected) => underlineField = selected.detail}/>
+			</div>
+		</section>
+	</nav>
+
+	<!-- Content pane -->
+	<section class="w-full">
+		<TokenGrid textComponents={textComponents} tokenDetails={tokenDetails} isCompleted={isCompleted} isError={isError} bgField={bgField} underlineField={underlineField} requireFullReplay="{requireFullReplay}"/>
+	</section>
+</div>
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/MetricCard.svelte b/client/graphpaper-inline/src/MetricCard.svelte
new file mode 100644
index 000000000..85c19d358
--- /dev/null
+++ b/client/graphpaper-inline/src/MetricCard.svelte
@@ -0,0 +1,28 @@
+<!-- Each metric is displayed as a card. -->
+<script lang="ts">
+    import Minibar from "./Minibar.svelte";
+    import { type MetricDef, type MetricVal} from "./interfaces";
+
+    export let metricDef: MetricDef;
+    export let value: MetricVal;
+
+    const minibarPadding = {
+        'left': 0,
+        'right': 0,
+        'top': 4,
+        'bottom': 0,
+    };
+</script>
+
+<div class={`flex flex-col items-center py-1 px-4 hover:bg-gray-700 group`}>
+    <div class={`uppercase tracking-wider text-xs text-gray-500 group-hover:text-gray-100 whitespace-nowrap`}>{metricDef.name}</div>
+    {#if value.constructor === Array}
+        <Minibar values={value} svgClass={"w-12 h-6"} rectClass={`fill-gray-700 group-hover:fill-gray-100`} padding={minibarPadding}/>
+    {:else}
+        {#if typeof value === "number"}
+            <div class={`min-w-12 text-center text-lg text-gray-700 group-hover:text-gray-100`}>{value.toFixed(metricDef.precision)}<span class="text-xs pl-1">{metricDef.units}</span></div>
+        {:else}
+            <div class={`min-w-12 text-center text-lg text-gray-700 group-hover:text-gray-100`}>{value}<span class="text-xs pl-1">{metricDef.units}</span></div>
+        {/if}
+    {/if}
+</div>
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/Minibar.svelte b/client/graphpaper-inline/src/Minibar.svelte
new file mode 100644
index 000000000..0b54777f2
--- /dev/null
+++ b/client/graphpaper-inline/src/Minibar.svelte
@@ -0,0 +1,40 @@
+<!-- Mini bar graph for tracking distributions or values over time scaled from 0 to 1. -->
+
+<script lang="ts">
+	import {scaleLinear} from 'd3-scale';
+
+    export let values;
+	export let svgClass: string;
+	export let rectClass: string;
+	export let padding = {
+		'left': 0,
+		'right': 0,
+		'top': 0,
+		'bottom': 0,
+	};
+	$: typedValues = values as Array<number>;
+
+	let height = 0;
+	let width = 0;
+	let minVal = 0.05;
+	$: xScale = scaleLinear()
+		.domain([0, typedValues.length])
+		.range([0, width - padding.right]);
+
+	$: yScale = scaleLinear()
+		.domain([0, 1])
+		.range([height - padding.bottom, padding.top]);
+
+	$: innerWidth = width - (padding.left + padding.right);
+	$: barWidth = innerWidth / typedValues.length;
+</script>
+
+<div class="flex items-center" bind:clientHeight={height} bind:clientWidth={width}>
+	<svg class={svgClass}>
+		<g>
+		{#each typedValues as val, i}
+			<rect x={xScale(i)} y={yScale(Math.max(val, minVal))} width={barWidth-1} height={yScale(0) - yScale(Math.max(val, minVal))} class={rectClass}></rect>
+			{/each}
+		</g>
+	</svg>
+</div>
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/ResizeListener.svelte b/client/graphpaper-inline/src/ResizeListener.svelte
new file mode 100644
index 000000000..aa46655c8
--- /dev/null
+++ b/client/graphpaper-inline/src/ResizeListener.svelte
@@ -0,0 +1,33 @@
+<!-- Handles resizing of content, especially important for jupyter notebooks. -->
+<script lang="ts">
+    import { onMount, onDestroy } from 'svelte';
+    import { clientmsg, type StitchMessage} from "./stitch";
+
+    const INTERVAL_MS = 20;
+    let interval: any = null;
+    let htmlElem: any;
+
+    onMount(() => {
+        htmlElem = document.querySelector('html');
+        window.addEventListener("load", () => {
+            let prevHeight = 0;
+
+            interval = setInterval(() => {
+                const height = htmlElem.getBoundingClientRect().height;
+                if (height !== prevHeight && htmlElem.checkVisibility()) {
+                    const msg: StitchMessage = {
+                        'type': 'resize',
+                        'content': {
+                            height: `${height}px`,
+                            width: '100%'
+                        }
+                    };
+                    clientmsg.set(msg);
+                }
+            }, INTERVAL_MS);
+        });
+    });
+    onDestroy(() => {
+        clearInterval(interval);
+    });
+</script>
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/Select.svelte b/client/graphpaper-inline/src/Select.svelte
new file mode 100644
index 000000000..8546a1d67
--- /dev/null
+++ b/client/graphpaper-inline/src/Select.svelte
@@ -0,0 +1,46 @@
+<!-- Custom select dropdown -->
+<script lang="ts">
+    import { clickOutside } from "./clickoutside";
+    import { createEventDispatcher } from 'svelte';
+
+    export let classes: string = "";
+    export let values: Array<string> = [];
+    export let defaultValue: string = "";
+
+    let selected = defaultValue;
+    let showList = false;
+
+    const dispatch = createEventDispatcher();
+
+    const onDropdownClick = (_: MouseEvent) => {
+        showList = !showList;
+    };
+    const onOutClick = (_: MouseEvent) => {
+        showList = false;
+    };
+    const selectOption = (option: string) => {
+        selected = option;
+        showList = false;
+        dispatch('select', selected);
+    }
+</script>
+
+<div class="relative" use:clickOutside on:outclick={onOutClick}>
+    <button use:clickOutside on:click={onDropdownClick}>
+        <span class={`mr-4 inline-flex justify-between items-center hover:bg-gray-700 hover:text-white ${classes}`}>
+            <span class="">
+                {selected}
+            </span>
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" fill="currentColor" class="size-4">
+                <path fill-rule="evenodd" d="M4.22 6.22a.75.75 0 0 1 1.06 0L8 8.94l2.72-2.72a.75.75 0 1 1 1.06 1.06l-3.25 3.25a.75.75 0 0 1-1.06 0L4.22 7.28a.75.75 0 0 1 0-1.06Z" clip-rule="evenodd" />
+            </svg>
+        </span>
+    </button>
+    {#if showList}
+        <ul role="listbox" class="absolute pt-2 pb-3 z-10 mt-1 bg-white shadow border border-gray-300">
+            {#each values as value, i}
+                <li class={`w-full px-4 py-1 ${i === 0 ? "mt-1" : ""} hover:bg-gray-700 hover:text-white text-nowrap`} role="option" aria-selected="false" on:click={(_) => selectOption(value)} on:keypress={(_) => {}}>{value}</li>
+            {/each}
+        </ul>
+    {/if}
+</div>
diff --git a/client/graphpaper-inline/src/StitchHandler.svelte b/client/graphpaper-inline/src/StitchHandler.svelte
new file mode 100644
index 000000000..fdc7058c4
--- /dev/null
+++ b/client/graphpaper-inline/src/StitchHandler.svelte
@@ -0,0 +1,31 @@
+<!-- Handles stitch client and kernel messages. -->
+<script lang="ts">
+    import type { Unsubscriber } from 'svelte/store';
+    import { kernelmsg, clientmsg, type StitchMessage } from './stitch';
+    import { onMount, onDestroy } from 'svelte';
+
+    const handleMessage = (event: MessageEvent<any>) => {
+        if (event.source === window.parent && 'type' in event.data && event.data.type === 'kernelmsg') {
+            let stitchMessage: StitchMessage = event.data;
+
+            // Notify kernel message has been received to subscribers
+            kernelmsg.set(stitchMessage);
+        }
+    };
+
+    let unsubscribe: Unsubscriber | null = null;
+    onMount(() => {
+        unsubscribe = clientmsg.subscribe((msg) => {
+            if (msg !== undefined) {
+                window.parent.postMessage(msg, "*");
+            }
+        });
+    });
+    onDestroy(() => {
+        if (unsubscribe) {
+            unsubscribe();
+        }
+    });
+</script>
+
+<svelte:window on:message={handleMessage} />
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/TokenGrid.svelte b/client/graphpaper-inline/src/TokenGrid.svelte
new file mode 100644
index 000000000..24ffaa1a7
--- /dev/null
+++ b/client/graphpaper-inline/src/TokenGrid.svelte
@@ -0,0 +1,519 @@
+<!-- Token grid that exposes each token and hover info. -->
+<script lang="ts">
+    import {isRoleOpenerInput, isTextOutput, type NodeAttr, type RoleOpenerInput, type GenTokenExtra} from './stitch';
+    import TokenGridItem from "./TokenGridItem.svelte";
+    import {type Token, type TokenCallback} from "./interfaces";
+    import {longhover} from "./longhover";
+    import DOMPurify from "dompurify";
+
+    import {interpolateGreens, interpolateYlOrRd, interpolateBlues} from "d3-scale-chromatic";
+
+    export let textComponents: Array<NodeAttr>;
+    export let tokenDetails: Array<GenTokenExtra>;
+    export let isCompleted: boolean;
+    export let isError: boolean;
+    export let requireFullReplay: boolean = false;
+    export let bgField: string = "Token";
+    export let underlineField: string = "Probability";
+
+    let underline: TokenCallback = (_: Token) => "";
+    let bg: TokenCallback = (_: Token) => "";
+
+    const tokenDisplayValue = (x: Token, s: string) => {
+        if (s === "Probability") {
+            return x.prob.toFixed(3);
+        } else if (s === "Latency (ms)") {
+            return (x.latency_ms).toFixed(0);
+        } else if (s === "Type") {
+            if (x.is_input) {
+                return "Input";
+            } else if (x.is_force_forwarded) {
+                return "Forwarded";
+            } else if (x.is_generated) {
+                return "Generated";
+            }
+        } else if (s === "None") {
+            return "";
+        }
+    };
+
+    const getBrightness = (rgba: string) => {
+        const rgbMatch = rgba.match(/rgba?\(\s*(\d+),\s*(\d+),\s*(\d+)/);
+        if (!rgbMatch) {
+            console.error('Invalid RGBA format.');
+            return 0;
+        }
+
+        const r = parseInt(rgbMatch[1], 10);
+        const g = parseInt(rgbMatch[2], 10);
+        const b = parseInt(rgbMatch[3], 10);
+        return (r * 0.299 + g * 0.587 + b * 0.114);
+    };
+
+    const getTextColor = (backgroundColor: string) => {
+        const brightness = getBrightness(backgroundColor);
+        return (brightness) > 186 ? 'rgba(0, 0, 0, 1)' : 'rgba(255, 255, 255, 1)'; // Black for light bg, white for dark bg
+    };
+
+    const bgStyle = (x: number | undefined, color?: ((x: number) => string) | undefined) => {
+        if (x === undefined) {
+            return "";
+        }
+
+        // let colorVal = interpolateYlOrRd(x * 0.85);
+        let colorVal = interpolateBlues(x);
+        if (color !== undefined) {
+            colorVal = color(x);
+        }
+        let textColor = getTextColor(colorVal);
+        return `background-color: ${colorVal}; color: ${textColor};`;
+    };
+
+    const underlineStyle = (x: number | undefined, color?: ((x: number) => string) | undefined) => {
+        if (x === undefined) {
+            return "";
+        }
+
+        let colorVal = interpolateGreens(x * 0.70);
+        if (color !== undefined) {
+            colorVal = color(x);
+        }
+        return `border-bottom-color: ${colorVal};`;
+    };
+
+    const bgTokenStyle = (x: Token) => {
+        let color = "";
+        if (x.is_input) {
+            color = "rgba(255, 255, 255, 0)";
+        } else if (x.is_force_forwarded) {
+            color = "rgba(243, 244, 246, 1)";
+        } else if (x.is_generated) {
+            color = "rgba(229, 231, 235, 1)";
+        } else {
+            console.log(`ERROR: token ${x.text} does not have emit flags.`)
+            color = "rgba(255, 255, 255, 0)";
+        }
+        return `background-color: ${color};`;
+    };
+
+    function findTargetWords(text: string, targetWords: string[]): [number, number, string][] {
+        // NOTE(nopdive): Not the most efficient approach, but there aren't many special words anyway.
+
+        const results: [number, number, string][] = [];
+        for (const targetWord of targetWords) {
+            let start = 0;
+            while ((start = text.indexOf(targetWord, start)) !== -1) {
+                results.push([start, start + targetWord.length, targetWord]);
+                start += targetWord.length;
+            }
+        }
+
+        results.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);
+        return results;
+    }
+
+    const checkOverlapped = (tokenStart: number, tokenEnd: number, matchStart: number, matchEnd: number) => {
+        let overlapped = false;
+        let noSpecialOverride = false;
+
+        if (tokenStart <= matchStart && (tokenEnd-1) >= matchStart) {
+            // Match with token leading
+            overlapped = true;
+        } else if (tokenStart <= (matchEnd-1) && tokenEnd >= matchEnd) {
+            // Match with token trailing
+            overlapped = true;
+
+            // Visually looks bad when next word is also greyed out.
+            noSpecialOverride = true;
+        } else if (tokenStart >= matchStart && tokenEnd <= matchEnd) {
+            // Match with token equal or within
+            overlapped = true;
+        }
+
+        return [overlapped, noSpecialOverride];
+    }
+
+    let tokens: Array<Token> = [];
+    let activeOpenerRoles: Array<RoleOpenerInput> = [];
+    let activeCloserRoleText: Array<string> = [];
+    let specialSet: Set<string> = new Set<string>();
+    let namedRoleSet: Record<string, string> = {};
+    let currentTokenIndex: number = 0;
+    let statCounter: Record<string, number> = {};
+    $: {
+        if (textComponents.length === 0) {
+            // Reset
+            tokens = [];
+            activeOpenerRoles = [];
+            activeCloserRoleText = [];
+            specialSet.clear();
+            namedRoleSet = {};
+            currentTokenIndex = 0;
+        }
+
+        for (; currentTokenIndex < textComponents.length; currentTokenIndex += 1) {
+            const nodeAttr = textComponents[currentTokenIndex];
+
+            if (isRoleOpenerInput(nodeAttr)) {
+                activeOpenerRoles.push(nodeAttr);
+                activeCloserRoleText.push(nodeAttr.closer_text || "");
+            } else if (isTextOutput(nodeAttr)) {
+                if (activeOpenerRoles.length === 0) {
+                    if (activeCloserRoleText.length !== 0 && activeCloserRoleText[activeCloserRoleText.length - 1] === nodeAttr.value) {
+                        const token = {
+                            text: nodeAttr.value, prob: 1, latency_ms: 0,
+                            role: "", special: true,
+                            is_input: nodeAttr.is_input, is_force_forwarded: nodeAttr.is_force_forwarded,
+                            is_generated: nodeAttr.is_generated,
+                        };
+                        specialSet.add(token.text);
+                        tokens.push(token);
+                        activeCloserRoleText.pop();
+                    } else {
+                        const token = {
+                            text: nodeAttr.value, prob: 1, latency_ms: 0, role: "", special: false,
+                            is_input: nodeAttr.is_input, is_force_forwarded: nodeAttr.is_force_forwarded,
+                            is_generated: nodeAttr.is_generated,
+                        };
+                        tokens.push(token);
+                    }
+                } else {
+                    const activeOpenerRole = activeOpenerRoles[activeOpenerRoles.length - 1];
+                    if (activeOpenerRole.text && activeOpenerRole.text !== nodeAttr.value) {
+                        console.log(`Active role text does not match next text output: ${activeOpenerRole.text} - ${nodeAttr.value}`)
+                    }
+
+                    const token = {
+                        text: nodeAttr.value, prob: 1, latency_ms: 0, role: activeOpenerRole.name || "", special: true,
+                        is_input: nodeAttr.is_input, is_force_forwarded: nodeAttr.is_force_forwarded,
+                        is_generated: nodeAttr.is_generated,
+                    };
+                    if (token.role !== "") {
+                        namedRoleSet[nodeAttr.value] = token.role;
+                    }
+                    specialSet.add(token.text);
+                    tokens.push(token);
+                    activeOpenerRoles.pop();
+                }
+            }
+        }
+        // NOTE(nopdive): Often the closer text is missing at the end of output.
+        if (activeOpenerRoles.length !== 0 || activeCloserRoleText.length !== 0) {
+            // console.log("Opener and closer role texts did not balance.")
+        }
+
+        // Process tokens to have detail if we have it (should only happen once at the end).
+        const isDetailed = (tokenDetails.length > 0);
+        if (isDetailed) {
+            // Preprocess for special words
+            const fullText = tokenDetails.map((x) => {return x.text}).join("");
+
+            const specialMatchStack = findTargetWords(fullText, Array.from(specialSet));
+            // for (const [start, end, match] of specialMatchStack) {
+            //     console.log(match, start, end);
+            // }
+
+            tokens = [];
+            let tokenStart = 0;
+            let tokenEnd = 0;
+            let withinRoleMatch = false;
+            for (const tokenDetail of tokenDetails) {
+                tokenStart = tokenEnd;
+                tokenEnd = tokenStart + tokenDetail.text.length;
+                let special = false;
+                let role = "";
+
+                if (specialMatchStack.length > 0) {
+                    let [matchStart, matchEnd, match] = specialMatchStack[0];
+                    if (tokenStart >= matchEnd) {
+                        specialMatchStack.shift();
+                        if (specialMatchStack.length > 0) {
+                            [matchStart, matchEnd, match] = specialMatchStack[0];
+                        }
+                    }
+
+                    let [overlapped, noSpecialOverride] = checkOverlapped(tokenStart, tokenEnd, matchStart, matchEnd);
+                    // console.log("token: ", tokenStart, tokenEnd, withinRoleMatch, fullText.slice(tokenStart, tokenEnd));
+                    // console.log("match: ", matchStart, matchEnd, match);
+                    // console.log(overlapped ? "matched" : "");
+
+                    if (overlapped) {
+                        if (Object.keys(namedRoleSet).includes(match)) {
+                            if (!withinRoleMatch) {
+                                role = namedRoleSet[match];
+                                withinRoleMatch = true;
+                            }
+                        }
+
+                        // Peek for overlap of next role (needed for phi 3)
+                        if (specialMatchStack.length > 1) {
+                            let [matchStart, matchEnd, match] = specialMatchStack[1];
+                            const [overlapped, _] = checkOverlapped(tokenStart, tokenEnd, matchStart, matchEnd);
+                            if (overlapped && Object.keys(namedRoleSet).includes(match)) {
+                                role = namedRoleSet[match];
+                                withinRoleMatch = true;
+                                noSpecialOverride = false;
+                            }
+                        }
+
+                        if (!noSpecialOverride) {
+                            special = true;
+                        }
+                    } else {
+                        withinRoleMatch = false;
+                    }
+                }
+
+                const token = {
+                    text: tokenDetail.text,
+                    prob: tokenDetail.prob,
+                    latency_ms: tokenDetail.latency_ms,
+                    role: role,
+                    special: special,
+                    is_input: tokenDetail.is_input,
+                    is_force_forwarded: tokenDetail.is_force_forwarded,
+                    is_generated: tokenDetail.is_generated,
+                    top_k: tokenDetail.top_k,
+                };
+                statCounter["latency.max"] = Math.max(token.latency_ms, statCounter["latency.max"] || 0);
+                tokens.push(token);
+            }
+        }
+
+        // Visual updates
+        if (!isCompleted || isError) {
+            underline = (_: Token) => "border: none;";
+        } else if (underlineField === "Probability") {
+            underline = (x: Token) => underlineStyle(x.prob);
+        } else if (underlineField === "Latency (ms)") {
+            underline = (x: Token) => underlineStyle(Math.log(x.latency_ms) / Math.log(statCounter['latency.max']));
+        } else {
+            underline = (_: Token) => "border: none;";
+        }
+
+        if (!isCompleted || isError) {
+            // bg = (_: Token) => "";
+            bg = (x: Token) => bgTokenStyle(x);
+        } else if (bgField === "Type") {
+            bg = (x: Token) => bgTokenStyle(x);
+        } else if (bgField === "Probability") {
+            bg = (x: Token) => bgStyle(x.prob);
+        } else if (bgField === "Latency (ms)") {
+            bg = (x: Token) => bgStyle(Math.log(x.latency_ms) / Math.log(statCounter['latency.max']));
+            console.log(statCounter['latency.max']);
+        } else {
+            bg = (_: Token) => "";
+        }
+
+        // End bookkeeping (svelte)
+        isCompleted = isCompleted;
+        isError = isError;
+        tokenDetails = tokenDetails;
+        textComponents = textComponents;
+        tokens = tokens;
+    }
+
+    let tooltip: HTMLElement;
+    let tooltipX = 0;
+    let tooltipY = 0;
+    let tooltipToken: Token;
+    const mouseLongHoverDuration = 200;
+
+    const handleLongMouseOver = (event: CustomEvent<MouseEvent>) => {
+        const target = event.detail.target as HTMLElement;
+        if (target.matches('.token-grid-item')) {
+            const index = target.dataset.index;
+            const positionXOffset = 15;
+            const positionYOffset = 10;
+
+            // Add tooltip
+            const rect = target.getBoundingClientRect();
+            tooltipX = (rect.left + window.scrollX + rect.width / 2) + positionXOffset;
+            tooltipY = (rect.bottom + window.scrollY) + positionYOffset;
+            tooltip.style.display = 'block';
+            const indexNum = Number(index);
+            tooltipToken = tokens[indexNum];
+
+            // Adjust if near edge of viewport
+            if (tooltipX + tooltip.offsetWidth > window.innerWidth) {
+                tooltipX = window.innerWidth - tooltip.offsetWidth;
+            }
+            if (tooltipY + tooltip.offsetHeight > window.innerHeight) {
+                tooltipY = window.innerHeight - tooltip.offsetHeight;
+            }
+        }
+    }
+
+    let highlightPrevColor = '';
+    let highlightPrevBackgroundColor = '';
+    const handleMouseOver = (event: MouseEvent) => {
+        const target = event.target as HTMLElement;
+        if (target.matches('.token-grid-item')) {
+            const index = target.dataset.index;
+            const siblingsIncludingSelf = target.parentElement?.querySelectorAll(`.token-grid-item[data-index="${index}"]`);
+
+            // Add highlight
+            if (siblingsIncludingSelf) {
+                for (const sibling of siblingsIncludingSelf) {
+                    const htmlSibling = sibling as HTMLElement;
+                    highlightPrevColor = htmlSibling.style.color;
+                    highlightPrevBackgroundColor = htmlSibling.style.backgroundColor;
+                    htmlSibling.style.color = "rgb(249, 250, 251)";
+                    htmlSibling.style.backgroundColor = "rgb(75, 85, 99)";
+                }
+            }
+        }
+    }
+
+    const handleLongMouseOut = (event: CustomEvent<MouseEvent>) => {
+        const target = event.detail.target as HTMLElement;
+        if (target.matches('.token-grid-item')) {
+            // Remove tooltip
+            tooltip.style.display = 'none';
+        }
+    }
+
+    const handleMouseOut = (event: MouseEvent) => {
+        const target = event.target as HTMLElement;
+        if (target.matches('.token-grid-item')) {
+            const index = target.dataset.index;
+            const siblingsIncludingSelf = target.parentElement?.querySelectorAll(`.token-grid-item[data-index="${index}"]`);
+
+            // Remove highlight
+            if (siblingsIncludingSelf) {
+                for (const sibling of siblingsIncludingSelf) {
+                    const htmlSibling = sibling as HTMLElement;
+                    htmlSibling.style.color = highlightPrevColor;
+                    htmlSibling.style.backgroundColor = highlightPrevBackgroundColor;
+                }
+            }
+        }
+    }
+    const doNothing = (_: any) => {}
+    const renderText = (text: string) => {
+        return DOMPurify.sanitize(
+            text.replaceAll(' ', '&nbsp;').replaceAll('\t', '\\t').replaceAll('\n', '\\n')
+        );
+    }
+    const continuationToken = {
+        text: "...",
+        prob: 1,
+        latency_ms: 0,
+        role: "",
+        special: false,
+        is_input: true,
+        is_force_forwarded: false,
+        is_generated: true,
+    };
+</script>
+
+<!-- Tooltip -->
+<div bind:this={tooltip} class="px-1 pt-1 pb-3 absolute opacity-95 bg-white shadow border border-gray-300 pointer-events-none z-50" style="top: {tooltipY}px; left: {tooltipX}px; display: none;">
+    <div>
+        {#if tooltipToken}
+            <div class={`col-1 flex flex-col items-center`}>
+                <div class="text-2xl px-1 pb-1 text-left w-full bg-white">
+                    <div class="mb-5 mt-1">
+                        <TokenGridItem token={tooltipToken} index={-1} underlineStyle={underline(tooltipToken)} bgStyle={bg(tooltipToken)}/>
+                    </div>
+                    <table class="w-full">
+                        <tbody class="text-xs tracking-wider">
+                            {#if bgField !== 'None'}
+                                <tr>
+                                    <td>
+                                        <span style={bg(tooltipToken)}>
+                                            {bgField}
+                                        </span>
+                                    </td>
+                                    <td class="text-right">
+                                        <span class="pl-1">
+                                            {tokenDisplayValue(tooltipToken, bgField)}
+                                        </span>
+                                    </td>
+                                </tr>
+                            {/if}
+                            {#if underlineField !== 'None'}
+                                <tr>
+                                    <td>
+                                        <span class="border-b-2" style={underline(tooltipToken)}>
+                                            {underlineField}
+                                        </span>
+                                    </td>
+                                    <td class="text-right">
+                                        <span>
+                                            {tokenDisplayValue(tooltipToken, underlineField)}
+                                        </span>
+                                    </td>
+                                </tr>
+                            {/if}
+                        </tbody>
+                    </table>
+                </div>
+                {#if tooltipToken.top_k !== undefined}
+                <hr class="bg-gray-400 w-full my-2"/>
+                <table class="w-full">
+                    <thead>
+                        <tr>
+                            <th class={`px-1 pb-1 font-normal text-xs text-left text-gray-700 tracking-wide`}>
+                                Candidate
+                            </th>
+                            <th class={`px-1 pb-1 font-normal text-xs text-right text-gray-700 tracking-wide`}>
+                                Prob
+                            </th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                    {#each tooltipToken.top_k as candidate, i}
+                        <tr class={`${i === 5 ? "border-t border-dashed border-gray-300" : ""}`}>
+                            <td class={`px-1 text-left font-mono text-sm decoration-2 ${candidate.is_masked ? "line-through" : ""}`}>
+                                <span class="bg-gray-200">
+                                    {@html renderText(candidate.text)}
+                                </span>
+                            </td>
+                            <td class={`px-1 text-right font-mono text-sm decoration-2 ${candidate.is_masked ? "line-through" : ""}`}>
+                                {candidate.prob.toFixed(3)}
+                            </td>
+                        </tr>
+                    {/each}
+                    </tbody>
+                </table>
+                {/if}
+            </div>
+        {:else}
+            <div class="text-sm border-b text-red-700">Missing tokens will show on completion.</div>
+        {/if}
+    </div>
+</div>
+
+<!-- Tokens view -->
+<div class="pt-6 pb-6 flex text-gray-800 font-token">
+    <div class="px-4">
+        <span class="flex flex-wrap text-sm" role="main" use:longhover={mouseLongHoverDuration} on:longmouseover={handleLongMouseOver} on:longmouseout={handleLongMouseOut} on:mouseover={handleMouseOver} on:mouseout={handleMouseOut} on:focus={doNothing} on:blur={doNothing}>
+            {#if requireFullReplay}
+                <TokenGridItem token={continuationToken} index={-1}/>
+                <div class="basis-full h-2"></div>
+            {/if}
+            {#each tokens as token, i}
+                {#if token.special === true && token.role !== ""}
+                    <!-- Vertical spacing for role -->
+                    {#if i === 0}
+                        <div class="basis-full h-2"></div>
+                    {:else}
+                        {#each {length: 2} as _}
+                            <div class="basis-full h-0"></div>
+                            <span class="inline-block">&nbsp;</span>
+                        {/each}
+                        <div class="basis-full h-0"></div>
+                    {/if}
+                {/if}
+                <TokenGridItem token={token} index={i} underlineStyle={underline(token)} bgStyle={bg(token)}/>
+            {/each}
+
+            {#if isCompleted === false}
+                <span class="inline-block mt-2 border-b-2 border-white bg-gray-700 animate-cpulse">
+                    &nbsp;
+                </span>
+            {/if}
+        </span>
+    </div>
+</div>
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/TokenGridItem.svelte b/client/graphpaper-inline/src/TokenGridItem.svelte
new file mode 100644
index 000000000..32857ba8d
--- /dev/null
+++ b/client/graphpaper-inline/src/TokenGridItem.svelte
@@ -0,0 +1,50 @@
+<!-- Token(s) within token grid -->
+<script lang="ts">
+    import {type Token} from "./interfaces";
+
+    export let token: Token;
+    export let index: number;
+    export let underlineStyle: string = "";
+    export let bgStyle: string = "";
+</script>
+
+{#each token.text as ch, i}
+    {#if ch === ' '}
+        <span data-index="{index}" role="tooltip" class={`token-grid-item inline-block mt-2 border-b-2 text-gray-300`} style={`${underlineStyle} ${bgStyle}`}>
+            {#if i === 0}
+                <span class="absolute text-xs uppercase -mt-4 text-purple-800 font-sans">
+                    {token.role}
+                </span>
+            {/if}
+            &nbsp;
+        </span>
+    {:else if ch === '\t'}
+        <span data-index="{index}" role="tooltip" class={`token-grid-item inline-block mt-2 border-b-2 text-gray-300`} style={`${underlineStyle} ${bgStyle}`}>
+            {#if i === 0}
+                <span class="absolute text-xs uppercase -mt-4 text-purple-800 font-sans">
+                    {token.role}
+                </span>
+            {/if}
+            \t&nbsp;&nbsp;
+        </span>
+    {:else if ch === '\n'}
+        <span data-index="{index}" role="tooltip" class={`token-grid-item inline-block mt-2 border-b-2 text-gray-300`} style={`${underlineStyle} ${bgStyle}`}>
+            {#if i === 0}
+                <span class="absolute text-xs uppercase -mt-4 text-purple-800 font-sans">
+                    {token.role}
+                </span>
+            {/if}
+            \n
+        </span>
+        <div class="basis-full h-full"></div>
+    {:else}
+        <span data-index="{index}" role="tooltip" class={`token-grid-item inline-block mt-2 border-b-2 ${token.special ? "text-gray-300" : ""}`} style={`${underlineStyle} ${bgStyle}`}>
+            {#if i === 0}
+                <span class="absolute text-xs uppercase -mt-4 text-purple-800 font-sans">
+                    {token.role}
+                </span>
+            {/if}
+            {ch}
+        </span>
+    {/if}
+{/each}
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/clickoutside.ts b/client/graphpaper-inline/src/clickoutside.ts
new file mode 100644
index 000000000..0c8b38c27
--- /dev/null
+++ b/client/graphpaper-inline/src/clickoutside.ts
@@ -0,0 +1,18 @@
+// Action for clicking outside an element.
+
+export function clickOutside(node: HTMLElement) {
+	const handleClick = (event: MouseEvent) => {
+		let target = event.target as HTMLElement;
+		if (!node.contains(target)) {
+			node.dispatchEvent(new CustomEvent('outclick'));
+		}
+	};
+
+	document.addEventListener('click', handleClick, true);
+
+	return {
+		destroy() {
+			document.removeEventListener('click', handleClick, true);
+		}
+	};
+}
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/interfaces.ts b/client/graphpaper-inline/src/interfaces.ts
new file mode 100644
index 000000000..84d528740
--- /dev/null
+++ b/client/graphpaper-inline/src/interfaces.ts
@@ -0,0 +1,26 @@
+// Interfaces used within the client. This is separate to messaging interfaces.
+
+import type {GenToken} from "./stitch";
+
+export interface MetricDef {
+    name: string,
+    units: string,
+    description: string,
+    isScalar: boolean,
+    precision: number,
+}
+
+export type MetricVal = string | number | Array<number | string>;
+
+export interface Token {
+    text: string,
+    prob: number,
+    latency_ms: number,
+    is_input: boolean,
+    is_force_forwarded: boolean,
+    is_generated: boolean,
+    role: string,
+    special: boolean,
+    top_k?: Array<GenToken>
+}
+export declare type TokenCallback = (token: Token) => string;
diff --git a/client/graphpaper-inline/src/longhover.ts b/client/graphpaper-inline/src/longhover.ts
new file mode 100644
index 000000000..2d8ddbb40
--- /dev/null
+++ b/client/graphpaper-inline/src/longhover.ts
@@ -0,0 +1,28 @@
+// Action for long mouse hovers.
+
+export function longhover(node: HTMLElement, duration: number) {
+    let timer: any;
+
+    const handleMouseOver = (event: MouseEvent) => {
+        timer = setTimeout(() => {
+            node.dispatchEvent(new CustomEvent('longmouseover', {detail: event}));
+        }, duration);
+    };
+    const handleMouseOut = (event: MouseEvent) => {
+        clearTimeout(timer);
+        node.dispatchEvent(new CustomEvent('longmouseout', {detail: event}));
+    }
+
+    node.addEventListener('mouseover', handleMouseOver);
+    node.addEventListener('mouseout', handleMouseOut);
+
+    return {
+        update(newDuration: number) {
+            duration = newDuration
+        },
+        destroy() {
+            node.removeEventListener('mouseover', handleMouseOver);
+            node.removeEventListener('mouseout', handleMouseOut);
+        }
+    };
+}
diff --git a/client/graphpaper-inline/src/main.css b/client/graphpaper-inline/src/main.css
new file mode 100644
index 000000000..feee674eb
--- /dev/null
+++ b/client/graphpaper-inline/src/main.css
@@ -0,0 +1,4 @@
+/* Custom CSS for web app. */
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/main.js b/client/graphpaper-inline/src/main.js
new file mode 100644
index 000000000..a2cc0f9d8
--- /dev/null
+++ b/client/graphpaper-inline/src/main.js
@@ -0,0 +1,9 @@
+// Entrypoint for web app.
+
+import App from './App.svelte';
+
+const app = new App({
+	target: document.body,
+});
+
+export default app;
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/mocks.ts b/client/graphpaper-inline/src/mocks.ts
new file mode 100644
index 000000000..02174899e
--- /dev/null
+++ b/client/graphpaper-inline/src/mocks.ts
@@ -0,0 +1,2852 @@
+// Mocks for interactive testing
+
+import {type TextOutput, type RoleOpenerInput, type RoleCloserInput, type GenTokenExtra} from './stitch';
+
+export const mockNodeAttrs: Array<RoleCloserInput | RoleOpenerInput | TextOutput> = [
+  {
+    "class_name": "RoleOpenerInput",
+    "name": "user",
+    "text": "<|user|>\n",
+    "closer_text": "<|end|>\n"
+  },
+  {
+    "class_name": "TextOutput",
+    "value": "<|user|>\n",
+    "is_input": true,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": "What is the capital of France?",
+    "is_input": true,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "RoleCloserInput",
+    "name": "user",
+    "text": "<|end|>\n"
+  },
+  {
+    "class_name": "TextOutput",
+    "value": "<|end|>\n",
+    "is_input": true,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "RoleOpenerInput",
+    "name": "assistant",
+    "text": "<|assistant|>\n",
+    "closer_text": "<|end|>\n"
+  },
+  {
+    "class_name": "TextOutput",
+    "value": "<|assistant|>\n",
+    "is_input": true,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " The",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " capital",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " of",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " France",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " is",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " Paris",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": ".",
+    "is_input": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " It",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " is",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " not",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " only",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " the",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " largest",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " city",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " in",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " France",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " but",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " also",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " one",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " of",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " the",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " most",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " important",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " cultural",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " and",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " commercial",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " cent",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": "ers",
+    "is_input": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " in",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  },
+  {
+    "class_name": "TextOutput",
+    "value": " Europe",
+    "is_input": false,
+    "is_generated": false,
+    "is_force_forwarded": true,
+    "token_count": 0,
+    "prob": 0
+  }
+];
+
+export const mockGenTokens: Array<GenTokenExtra> = [
+  {
+    "token_id": 32010,
+    "prob": 0.0001471998548367992,
+    "text": "<|user|>",
+    "latency_ms": 0,
+    "is_masked": false,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "is_input": true,
+    "top_k": [
+      {
+        "token_id": 29906,
+        "prob": 0.11696617305278778,
+        "text": "2",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29896,
+        "prob": 0.10765588283538818,
+        "text": "1",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29941,
+        "prob": 0.05305387079715729,
+        "text": "3",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 13,
+        "prob": 0.034597232937812805,
+        "text": "\n",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29946,
+        "prob": 0.029241180047392845,
+        "text": "4",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 32010,
+        "prob": 0.0001471998548367992,
+        "text": "<|user|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 5618,
+    "prob": 0.0000025939498300431296,
+    "text": "\nWhat",
+    "latency_ms": 0,
+    "is_masked": false,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "is_input": true,
+    "top_k": [
+      {
+        "token_id": 306,
+        "prob": 0.07540036737918854,
+        "text": "I",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 512,
+        "prob": 0.05664486810564995,
+        "text": "In",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 448,
+        "prob": 0.05062797665596008,
+        "text": "-",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1724,
+        "prob": 0.028206998482346535,
+        "text": "What",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 6527,
+        "prob": 0.024746403098106384,
+        "text": "Could",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 5618,
+        "prob": 0.0000025939498300431296,
+        "text": "What",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 338,
+    "prob": 0.39458176493644714,
+    "text": " is",
+    "latency_ms": 0,
+    "is_masked": false,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "is_input": true,
+    "top_k": [
+      {
+        "token_id": 338,
+        "prob": 0.39458176493644714,
+        "text": "is",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 526,
+        "prob": 0.20252063870429993,
+        "text": "are",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29915,
+        "prob": 0.03513995558023453,
+        "text": "'",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 947,
+        "prob": 0.029331203550100327,
+        "text": "does",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 723,
+        "prob": 0.0216793455183506,
+        "text": "would",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 278,
+    "prob": 0.8396025896072388,
+    "text": " the",
+    "latency_ms": 0,
+    "is_masked": false,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "is_input": true,
+    "top_k": [
+      {
+        "token_id": 278,
+        "prob": 0.8396025896072388,
+        "text": "the",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 263,
+        "prob": 0.04767822101712227,
+        "text": "a",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 596,
+        "prob": 0.014672422781586647,
+        "text": "your",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 385,
+        "prob": 0.01002463512122631,
+        "text": "an",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29871,
+        "prob": 0.002904066350311041,
+        "text": "",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 7483,
+    "prob": 0.00797582883387804,
+    "text": " capital",
+    "latency_ms": 0,
+    "is_masked": false,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "is_input": true,
+    "top_k": [
+      {
+        "token_id": 995,
+        "prob": 0.1165241077542305,
+        "text": "value",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 2533,
+        "prob": 0.041466087102890015,
+        "text": "sum",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 6297,
+        "prob": 0.026729455217719078,
+        "text": "role",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3001,
+        "prob": 0.026081698015332222,
+        "text": "total",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 26002,
+        "prob": 0.025236951187253,
+        "text": "significance",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 7483,
+        "prob": 0.00797582883387804,
+        "text": "capital",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 310,
+    "prob": 0.6770157217979431,
+    "text": " of",
+    "latency_ms": 0,
+    "is_masked": false,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "is_input": true,
+    "top_k": [
+      {
+        "token_id": 310,
+        "prob": 0.6770157217979431,
+        "text": "of",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 4272,
+        "prob": 0.3132016360759735,
+        "text": "city",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 330,
+        "prob": 0.0018248602282255888,
+        "text": "g",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 2133,
+        "prob": 0.0009512827382422984,
+        "text": "ization",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1891,
+        "prob": 0.0006871097721159458,
+        "text": "ized",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 3444,
+    "prob": 0.8318758606910706,
+    "text": " France",
+    "latency_ms": 0,
+    "is_masked": false,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "is_input": true,
+    "top_k": [
+      {
+        "token_id": 3444,
+        "prob": 0.8318758606910706,
+        "text": "France",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 7400,
+        "prob": 0.03954508528113365,
+        "text": "Canada",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 8314,
+        "prob": 0.018492599949240685,
+        "text": "Australia",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 4810,
+        "prob": 0.0115347346290946,
+        "text": "CO",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 15198,
+        "prob": 0.00963549967855215,
+        "text": "Kaz",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 29973,
+    "prob": 0.9806775450706482,
+    "text": "?",
+    "latency_ms": 0,
+    "is_masked": false,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "is_input": true,
+    "top_k": [
+      {
+        "token_id": 29973,
+        "prob": 0.9806775450706482,
+        "text": "?",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29892,
+        "prob": 0.008077787235379219,
+        "text": ",",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 322,
+        "prob": 0.004824829287827015,
+        "text": "and",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 32007,
+        "prob": 0.0023883178364485502,
+        "text": "<|end|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 13,
+        "prob": 0.001062076073139906,
+        "text": "\n",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 32007,
+    "prob": 0.2750667631626129,
+    "text": "<|end|>",
+    "latency_ms": 0,
+    "is_masked": false,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "is_input": true,
+    "top_k": [
+      {
+        "token_id": 13,
+        "prob": 0.4481906592845917,
+        "text": "\n",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 32007,
+        "prob": 0.2750667631626129,
+        "text": "<|end|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29871,
+        "prob": 0.1448775678873062,
+        "text": "",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 9133,
+        "prob": 0.014615979976952076,
+        "text": "Prov",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 259,
+        "prob": 0.011606425978243351,
+        "text": " ",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 32001,
+    "prob": 0.8795124888420105,
+    "text": "\n<|assistant|>",
+    "latency_ms": 0,
+    "is_masked": false,
+    "is_generated": false,
+    "is_force_forwarded": false,
+    "is_input": true,
+    "top_k": [
+      {
+        "token_id": 32001,
+        "prob": 0.8795124888420105,
+        "text": "<|assistant|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 32010,
+        "prob": 0.04064176231622696,
+        "text": "<|user|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 835,
+        "prob": 0.030805600807070732,
+        "text": "###",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3579,
+        "prob": 0.017812293022871017,
+        "text": "**",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 444,
+        "prob": 0.014047935605049133,
+        "text": "##",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 1576,
+    "prob": 0.00006422422302421182,
+    "text": "\n The",
+    "latency_ms": 791.1298274993896,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 450,
+        "prob": 0.9857171773910522,
+        "text": "The",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3681,
+        "prob": 0.011184466071426868,
+        "text": "Paris",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3444,
+        "prob": 0.0011331287678331137,
+        "text": "France",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3579,
+        "prob": 0.0004644235013984144,
+        "text": "**",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 448,
+        "prob": 0.00026546273147687316,
+        "text": "-",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1576,
+        "prob": 0.00006422422302421182,
+        "text": "The",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 7483,
+    "prob": 0.999437153339386,
+    "text": " capital",
+    "latency_ms": 187.8337860107422,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 7483,
+        "prob": 0.999437153339386,
+        "text": "capital",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1234,
+        "prob": 0.0003310518804937601,
+        "text": "answer",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1139,
+        "prob": 0.00011426454148022458,
+        "text": "question",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 6221,
+        "prob": 0.00001873375367722474,
+        "text": "official",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1857,
+        "prob": 0.000014494446986645926,
+        "text": "current",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 310,
+    "prob": 0.9986506104469299,
+    "text": " of",
+    "latency_ms": 183.6080551147461,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 310,
+        "prob": 0.9986506104469299,
+        "text": "of",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 4272,
+        "prob": 0.0013466310920193791,
+        "text": "city",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 32007,
+        "prob": 0.0000010585043810351635,
+        "text": "<|end|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29871,
+        "prob": 6.448343583542737e-7,
+        "text": "",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 4412,
+        "prob": 1.6180513284780318e-7,
+        "text": "City",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 3444,
+    "prob": 0.999962329864502,
+    "text": " France",
+    "latency_ms": 186.737060546875,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 3444,
+        "prob": 0.999962329864502,
+        "text": "France",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 32007,
+        "prob": 0.000017144215235020965,
+        "text": "<|end|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 278,
+        "prob": 0.000008596942279837094,
+        "text": "the",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3579,
+        "prob": 0.000004998890744900564,
+        "text": "**",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 16066,
+        "prob": 0.0000016594119642832084,
+        "text": "France",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 338,
+    "prob": 0.9999902248382568,
+    "text": " is",
+    "latency_ms": 185.22119522094727,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 338,
+        "prob": 0.9999902248382568,
+        "text": "is",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29892,
+        "prob": 0.000004214996351947775,
+        "text": ",",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1752,
+        "prob": 9.97037091110542e-7,
+        "text": "ist",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29901,
+        "prob": 8.132024618134892e-7,
+        "text": ":",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 32007,
+        "prob": 7.06779985648609e-7,
+        "text": "<|end|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 3681,
+    "prob": 0.9999117851257324,
+    "text": " Paris",
+    "latency_ms": 187.99996376037598,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 3681,
+        "prob": 0.9999117851257324,
+        "text": "Paris",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3579,
+        "prob": 0.000049396130634704605,
+        "text": "**",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1459,
+        "prob": 0.000025039666070370004,
+        "text": "Par",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 32007,
+        "prob": 0.0000015687925269958214,
+        "text": "<|end|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 4257,
+        "prob": 0.0000014064415836401167,
+        "text": "named",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 29889,
+    "prob": 0.9989786148071289,
+    "text": ".",
+    "latency_ms": 184.83901023864746,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 29889,
+        "prob": 0.9989786148071289,
+        "text": ".",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29892,
+        "prob": 0.000967636238783598,
+        "text": ",",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 32007,
+        "prob": 0.0000353920622728765,
+        "text": "<|end|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 313,
+        "prob": 0.000010462333193572704,
+        "text": "(",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29936,
+        "prob": 0.0000014101174201641697,
+        "text": ";",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 739,
+    "prob": 0.3691301941871643,
+    "text": " It",
+    "latency_ms": 182.1460723876953,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 32007,
+        "prob": 0.4036679267883301,
+        "text": "<|end|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 739,
+        "prob": 0.3691301941871643,
+        "text": "It",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3681,
+        "prob": 0.18517325818538666,
+        "text": "Paris",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 5976,
+        "prob": 0.009475378319621086,
+        "text": "Loc",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 910,
+        "prob": 0.007770691066980362,
+        "text": "This",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 338,
+    "prob": 0.7372497916221619,
+    "text": " is",
+    "latency_ms": 186.75732612609863,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 338,
+        "prob": 0.7372497916221619,
+        "text": "is",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29915,
+        "prob": 0.22102417051792145,
+        "text": "'",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 19700,
+        "prob": 0.018399816006422043,
+        "text": "serves",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 30010,
+        "prob": 0.010582340881228447,
+        "text": "’",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 756,
+        "prob": 0.010219420306384563,
+        "text": "has",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 451,
+    "prob": 0.5775279402732849,
+    "text": " not",
+    "latency_ms": 192.30103492736816,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 451,
+        "prob": 0.5775279402732849,
+        "text": "not",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 278,
+        "prob": 0.30363428592681885,
+        "text": "the",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 884,
+        "prob": 0.055202122777700424,
+        "text": "also",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1716,
+        "prob": 0.01739770546555519,
+        "text": "both",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 2998,
+        "prob": 0.014207991771399975,
+        "text": "known",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 871,
+    "prob": 0.9856061339378357,
+    "text": " only",
+    "latency_ms": 186.07521057128906,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 871,
+        "prob": 0.9856061339378357,
+        "text": "only",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 925,
+        "prob": 0.01367239747196436,
+        "text": "just",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 13586,
+        "prob": 0.0006267011631280184,
+        "text": "merely",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3763,
+        "prob": 0.00005819142097607255,
+        "text": "simply",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 2197,
+        "prob": 0.000014317490240500774,
+        "text": "ably",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 278,
+    "prob": 0.982492208480835,
+    "text": " the",
+    "latency_ms": 203.89771461486816,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 278,
+        "prob": 0.982492208480835,
+        "text": "the",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3444,
+        "prob": 0.009905748069286346,
+        "text": "France",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 263,
+        "prob": 0.006513569038361311,
+        "text": "a",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1737,
+        "prob": 0.00027604380738921463,
+        "text": "ge",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 2998,
+        "prob": 0.0002052166237263009,
+        "text": "known",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 10150,
+    "prob": 0.4096444845199585,
+    "text": " largest",
+    "latency_ms": 196.5487003326416,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 4234,
+        "prob": 0.4371485412120819,
+        "text": "country",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 10150,
+        "prob": 0.4096444845199585,
+        "text": "largest",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 8604,
+        "prob": 0.08317449688911438,
+        "text": "political",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1556,
+        "prob": 0.03200649842619896,
+        "text": "most",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 7483,
+        "prob": 0.02671337127685547,
+        "text": "capital",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 4272,
+    "prob": 0.999167799949646,
+    "text": " city",
+    "latency_ms": 307.5690269470215,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 4272,
+        "prob": 0.999167799949646,
+        "text": "city",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 25311,
+        "prob": 0.0005337278707884252,
+        "text": "metropol",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 310,
+        "prob": 0.00022632069885730743,
+        "text": "of",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 322,
+        "prob": 0.000033229585824301466,
+        "text": "and",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 5176,
+        "prob": 0.000019576928025344387,
+        "text": "French",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 297,
+    "prob": 0.6239914894104004,
+    "text": " in",
+    "latency_ms": 306.05530738830566,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 297,
+        "prob": 0.6239914894104004,
+        "text": "in",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 310,
+        "prob": 0.2546098828315735,
+        "text": "of",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 541,
+        "prob": 0.115852952003479,
+        "text": "but",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 2629,
+        "prob": 0.0023302428890019655,
+        "text": "within",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 373,
+        "prob": 0.0022443863563239574,
+        "text": "on",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 3444,
+    "prob": 0.6372988224029541,
+    "text": " France",
+    "latency_ms": 179.40211296081543,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 3444,
+        "prob": 0.6372988224029541,
+        "text": "France",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 278,
+        "prob": 0.3625364601612091,
+        "text": "the",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 25311,
+        "prob": 0.00004971169983036816,
+        "text": "metropol",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 4958,
+        "prob": 0.000036445129808271304,
+        "text": "terms",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 4234,
+        "prob": 0.00002782431874948088,
+        "text": "country",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 541,
+    "prob": 0.9793675541877747,
+    "text": " but",
+    "latency_ms": 178.9560317993164,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 541,
+        "prob": 0.9793675541877747,
+        "text": "but",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29892,
+        "prob": 0.02007644809782505,
+        "text": ",",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 411,
+        "prob": 0.00042435049545019865,
+        "text": "with",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29936,
+        "prob": 0.00003524085332173854,
+        "text": ";",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 322,
+        "prob": 0.000032845084206201136,
+        "text": "and",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 884,
+    "prob": 0.9989857077598572,
+    "text": " also",
+    "latency_ms": 181.1509132385254,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 884,
+        "prob": 0.9989857077598572,
+        "text": "also",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 338,
+        "prob": 0.000602494168560952,
+        "text": "is",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 372,
+        "prob": 0.0001398069434799254,
+        "text": "it",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 756,
+        "prob": 0.00009900984878186136,
+        "text": "has",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 19700,
+        "prob": 0.00004597084625856951,
+        "text": "serves",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 697,
+    "prob": 0.3192960321903229,
+    "text": " one",
+    "latency_ms": 181.49805068969727,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 697,
+        "prob": 0.3192960321903229,
+        "text": "one",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 263,
+        "prob": 0.3170034885406494,
+        "text": "a",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 19700,
+        "prob": 0.16621005535125732,
+        "text": "serves",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 278,
+        "prob": 0.07940118759870529,
+        "text": "the",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 967,
+        "prob": 0.06430594623088837,
+        "text": "its",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 310,
+    "prob": 0.9997043013572693,
+    "text": " of",
+    "latency_ms": 186.09094619750977,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 310,
+        "prob": 0.9997043013572693,
+        "text": "of",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 411,
+        "prob": 0.00016257438983302563,
+        "text": "with",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 393,
+        "prob": 0.00008909530879464,
+        "text": "that",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 32007,
+        "prob": 0.000011212241588509642,
+        "text": "<|end|>",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 2998,
+        "prob": 0.000008543695912521798,
+        "text": "known",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 278,
+    "prob": 0.9882127642631531,
+    "text": " the",
+    "latency_ms": 183.80475044250488,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 278,
+        "prob": 0.9882127642631531,
+        "text": "the",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 967,
+        "prob": 0.010567160323262215,
+        "text": "its",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 4092,
+        "prob": 0.0011446235002949834,
+        "text": "Europe",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3444,
+        "prob": 0.00002321232750546187,
+        "text": "France",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1009,
+        "prob": 0.000013299547390488442,
+        "text": "their",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 1556,
+    "prob": 0.8675132989883423,
+    "text": " most",
+    "latency_ms": 189.83983993530273,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 1556,
+        "prob": 0.8675132989883423,
+        "text": "most",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 4655,
+        "prob": 0.07431504875421524,
+        "text": "major",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 363,
+        "prob": 0.03438625484704971,
+        "text": "for",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3186,
+        "prob": 0.012852047570049763,
+        "text": "world",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 8236,
+        "prob": 0.006348212715238333,
+        "text": "leading",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 4100,
+    "prob": 0.5192220211029053,
+    "text": " important",
+    "latency_ms": 182.08789825439453,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 4100,
+        "prob": 0.5192220211029053,
+        "text": "important",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 9849,
+        "prob": 0.2267724722623825,
+        "text": "icon",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 13834,
+        "prob": 0.10495571792125702,
+        "text": "famous",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 16669,
+        "prob": 0.07289287447929382,
+        "text": "visited",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 14938,
+        "prob": 0.01952418126165867,
+        "text": "popul",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 16375,
+    "prob": 0.7161048054695129,
+    "text": " cultural",
+    "latency_ms": 181.44798278808594,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 16375,
+        "prob": 0.7161048054695129,
+        "text": "cultural",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 322,
+        "prob": 0.134635791182518,
+        "text": "and",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 5534,
+        "prob": 0.056849200278520584,
+        "text": "global",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 17407,
+        "prob": 0.04618300125002861,
+        "text": "economic",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 8604,
+        "prob": 0.016588550060987473,
+        "text": "political",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 322,
+    "prob": 0.8125864863395691,
+    "text": " and",
+    "latency_ms": 182.1150779724121,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 322,
+        "prob": 0.8125864863395691,
+        "text": "and",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29892,
+        "prob": 0.15330319106578827,
+        "text": ",",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1644,
+        "prob": 0.02392854355275631,
+        "text": "cent",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 19766,
+        "prob": 0.009282657876610756,
+        "text": "hub",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 14368,
+        "prob": 0.0005479487008415163,
+        "text": "cities",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 12128,
+    "prob": 0.6127476096153259,
+    "text": " commercial",
+    "latency_ms": 213.25373649597168,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 12128,
+        "prob": 0.6127476096153259,
+        "text": "commercial",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 17407,
+        "prob": 0.26235485076904297,
+        "text": "economic",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 5381,
+        "prob": 0.0556219108402729,
+        "text": "business",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 15839,
+        "prob": 0.050407830625772476,
+        "text": "historical",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 18161,
+        "prob": 0.010083277709782124,
+        "text": "financial",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 1644,
+    "prob": 0.9685200452804565,
+    "text": " cent",
+    "latency_ms": 187.485933303833,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 1644,
+        "prob": 0.9685200452804565,
+        "text": "cent",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 19766,
+        "prob": 0.028621848672628403,
+        "text": "hub",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 14368,
+        "prob": 0.0017020675586536527,
+        "text": "cities",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 11934,
+        "prob": 0.0007980230147950351,
+        "text": "capit",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 25311,
+        "prob": 0.00012140109174652025,
+        "text": "metropol",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 414,
+    "prob": 0.9984211921691895,
+    "text": "ers",
+    "latency_ms": 191.87593460083008,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 414,
+        "prob": 0.9984211921691895,
+        "text": "ers",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 690,
+        "prob": 0.0015741386450827122,
+        "text": "res",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29878,
+        "prob": 0.0000014762757700736984,
+        "text": "r",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1007,
+        "prob": 0.0000012054251783411019,
+        "text": "roid",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 2288,
+        "prob": 0.0000010710768947319593,
+        "text": "rs",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 297,
+    "prob": 0.9748722314834595,
+    "text": " in",
+    "latency_ms": 183.5949420928955,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 297,
+        "prob": 0.9748722314834595,
+        "text": "in",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 13149,
+        "prob": 0.011514736339449883,
+        "text": "glob",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 29889,
+        "prob": 0.007136909756809473,
+        "text": ".",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 310,
+        "prob": 0.0027969765942543745,
+        "text": "of",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 451,
+        "prob": 0.0016226732404902577,
+        "text": "not",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  },
+  {
+    "token_id": 4092,
+    "prob": 0.49644505977630615,
+    "text": " Europe",
+    "latency_ms": 181.49399757385254,
+    "is_masked": false,
+    "is_generated": true,
+    "is_force_forwarded": false,
+    "is_input": false,
+    "top_k": [
+      {
+        "token_id": 4092,
+        "prob": 0.49644505977630615,
+        "text": "Europe",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 278,
+        "prob": 0.4951532781124115,
+        "text": "the",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 3444,
+        "prob": 0.005787685979157686,
+        "text": "France",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 10504,
+        "prob": 0.0018548371735960245,
+        "text": "Western",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      },
+      {
+        "token_id": 1716,
+        "prob": 0.0003810191119555384,
+        "text": "both",
+        "latency_ms": 0,
+        "is_masked": false,
+        "is_generated": false,
+        "is_force_forwarded": false,
+        "is_input": false
+      }
+    ]
+  }
+];
\ No newline at end of file
diff --git a/client/graphpaper-inline/src/stitch.ts b/client/graphpaper-inline/src/stitch.ts
new file mode 100644
index 000000000..3abcffe93
--- /dev/null
+++ b/client/graphpaper-inline/src/stitch.ts
@@ -0,0 +1,160 @@
+// Interfaces for working with guidance messages and stitch.
+
+import {writable} from 'svelte/store';
+
+export interface GenToken {
+    token_id: number,
+    prob: number,
+    text: string,
+    latency_ms: number,
+    is_masked: boolean,
+    is_generated: boolean,
+    is_force_forwarded: boolean,
+    is_input: boolean,
+}
+
+export interface GenTokenExtra extends GenToken {
+    top_k: Array<GenToken>,
+}
+
+export interface NodeAttr {
+    class_name: string
+}
+
+export interface TextOutput extends NodeAttr {
+    class_name: 'TextOutput',
+    value: string,
+    is_input: boolean,
+    is_generated: boolean,
+    is_force_forwarded: boolean,
+    token_count: number,
+    prob: number,
+}
+
+export interface RoleOpenerInput extends NodeAttr {
+    class_name: 'RoleOpenerInput',
+    name?: string,
+    text?: string,
+    closer_text?: string,
+}
+
+export interface RoleCloserInput extends NodeAttr {
+    class_name: 'RoleCloserInput',
+    name?: string,
+    text?: string,
+}
+
+export interface GuidanceMessage {
+    message_id: number,
+    class_name: string,
+}
+
+export interface TraceMessage extends GuidanceMessage {
+    class_name: 'TraceMessage',
+    trace_id: number,
+    parent_trace_id?: number,
+    node_attr?: NodeAttr,
+}
+
+export interface ResetDisplayMessage extends GuidanceMessage {
+    class_name: 'ResetDisplayMessage'
+}
+
+export interface ExecutionStartedMessage extends GuidanceMessage {
+    class_name: 'ExecutionStartedMessage',
+}
+
+export interface ExecutionCompletedMessage extends GuidanceMessage {
+    class_name: 'ExecutionCompletedMessage',
+    last_trace_id?: number,
+}
+
+export interface TokensMessage extends GuidanceMessage {
+    class_name: 'TokensMessage',
+    trace_id: number,
+    text: string,
+    tokens: Array<GenTokenExtra>,
+}
+
+export interface ClientReadyMessage extends GuidanceMessage {
+    class_name: 'ClientReadyMessage'
+}
+
+export interface ClientReadyAckMessage extends GuidanceMessage {
+    class_name: 'ClientReadyAckMessage'
+}
+
+export interface OutputRequestMessage extends GuidanceMessage {
+    class_name: 'OutputRequestMessage'
+}
+
+export interface MetricMessage extends GuidanceMessage {
+    class_name: 'MetricMessage',
+    name: string,
+    value: number | string | Array<number> | Array<string>,
+    scalar: boolean,
+}
+
+export interface StitchMessage {
+    type: "resize" | "clientmsg" | "kernelmsg",
+    content: any
+}
+
+export function isGuidanceMessage(o: GuidanceMessage | undefined | null): o is GuidanceMessage {
+    if (o === undefined || o === null) return false;
+    return o.hasOwnProperty("class_name") && o.hasOwnProperty("message_id");
+}
+
+export function isTraceMessage(o: GuidanceMessage | undefined | null): o is TraceMessage {
+    if (o === undefined || o === null) return false;
+    return o.class_name === "TraceMessage";
+}
+
+export function isRoleOpenerInput(o: NodeAttr | undefined | null): o is RoleOpenerInput {
+    if (o === undefined || o === null) return false;
+    return o.class_name === "RoleOpenerInput";
+}
+
+export function isRoleCloserInput(o: NodeAttr | undefined | null): o is RoleCloserInput {
+    if (o === undefined || o === null) return false;
+    return o.class_name === "RoleCloserInput";
+}
+
+export function isTextOutput(o: NodeAttr | undefined | null): o is TextOutput {
+    if (o === undefined || o === null) return false;
+    return o.class_name === "TextOutput";
+}
+
+export function isResetDisplayMessage(o: GuidanceMessage | undefined | null): o is ResetDisplayMessage {
+    if (o === undefined || o === null) return false;
+    return o.class_name === "ResetDisplayMessage";
+}
+
+export function isMetricMessage(o: GuidanceMessage | undefined | null): o is MetricMessage {
+    if (o === undefined || o === null) return false;
+    return o.class_name === "MetricMessage";
+}
+
+export function isClientReadyAckMessage(o: GuidanceMessage | undefined | null): o is MetricMessage {
+    if (o === undefined || o === null) return false;
+    return o.class_name === "ClientReadyAckMessage";
+}
+
+export function isExecutionCompletedMessage(o: GuidanceMessage | undefined | null): o is ExecutionCompletedMessage {
+    if (o === undefined || o === null) return false;
+    return o.class_name === "ExecutionCompletedMessage";
+}
+
+export function isExecutionStartedMessage(o: GuidanceMessage | undefined | null): o is ExecutionStartedMessage {
+    if (o === undefined || o === null) return false;
+    return o.class_name === "ExecutionStartedMessage";
+}
+
+export function isTokensMessage(o: GuidanceMessage | undefined | null): o is TokensMessage {
+    if (o === undefined || o === null) return false;
+    return o.class_name === "TokensMessage";
+}
+
+export const kernelmsg = writable<StitchMessage | undefined>(undefined);
+export const clientmsg = writable<StitchMessage | undefined>(undefined);
+
diff --git a/client/graphpaper-inline/src/template.html b/client/graphpaper-inline/src/template.html
new file mode 100644
index 000000000..8f7102cca
--- /dev/null
+++ b/client/graphpaper-inline/src/template.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:ital,wght@0,100..800;1,100..800&family=Roboto+Mono:ital,wght@0,100..700;1,100..700&display=swap" rel="stylesheet">
+</head>
+<body>
+</body>
+</html>
diff --git a/client/graphpaper-inline/tailwind.config.js b/client/graphpaper-inline/tailwind.config.js
new file mode 100644
index 000000000..b14f79b5c
--- /dev/null
+++ b/client/graphpaper-inline/tailwind.config.js
@@ -0,0 +1,21 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: ["./src/**/*.{html,ts,js,svelte}"],
+  theme: {
+    extend: {
+      fontFamily: {
+        'token': ['JetBrains Mono'],
+      },
+      keyframes: {
+        'cpulse': {
+          '50%': { opacity: 0.0 }
+        }
+      },
+      animation: {
+        'cpulse': 'cpulse 3.5s cubic-bezier(0.4, 0, 0.6, 1) infinite'
+      }
+    }
+  },
+  plugins: [],
+}
+
diff --git a/client/graphpaper-inline/tsconfig.json b/client/graphpaper-inline/tsconfig.json
new file mode 100644
index 000000000..a627cd343
--- /dev/null
+++ b/client/graphpaper-inline/tsconfig.json
@@ -0,0 +1,15 @@
+{
+	"compilerOptions": {
+		"allowJs": true,
+		"checkJs": true,
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"skipLibCheck": true,
+		"sourceMap": true,
+		"strict": true,
+        "verbatimModuleSyntax": true,
+		"module": "ESNext",
+		"moduleResolution": "bundler"
+	}
+}
\ No newline at end of file
diff --git a/guidance/__init__.py b/guidance/__init__.py
index 9175b3dc0..7fec48a57 100644
--- a/guidance/__init__.py
+++ b/guidance/__init__.py
@@ -30,3 +30,6 @@ def __call__(
 
 # we expose all the library functions at the top level of the module
 from .library import *
+
+# expose legacy mode for visualization
+from .visual import legacy_mode
\ No newline at end of file
diff --git a/guidance/_parser.py b/guidance/_parser.py
index d4df1c108..bfd56d6e9 100644
--- a/guidance/_parser.py
+++ b/guidance/_parser.py
@@ -8,7 +8,7 @@
 from numpy.typing import NDArray
 
 from ._grammar import GrammarFunction, Join, Terminal
-from ._schema import GenData, EngineCallResponse, LLInterpreterResponse
+from ._schema import EngineOutput, GenData, EngineCallResponse, GenToken, LLInterpreterResponse
 from .models._byte_tokenizer import ByteTokenizer
 from .models._tokenizer import Tokenizer
 
@@ -46,9 +46,7 @@ def __init__(
             serialized_grammar = grammar
 
         self.tokenizer = tokenizer
-        self.ll_tokenizer = llguidance.LLTokenizer(
-            llguidance.TokenizerWrapper(tokenizer)
-        )
+        self.ll_tokenizer = llguidance.LLTokenizer(llguidance.TokenizerWrapper(tokenizer))
         self.ll_interpreter = llguidance.LLInterpreter(
             self.ll_tokenizer,
             serialized_grammar,
@@ -68,19 +66,23 @@ def done(self) -> bool:
         return self._done
 
     def advance(
-        self, token: Optional[int]
-    ) -> tuple[list[int], Future[tuple[Optional[bytes], LLInterpreterResponse]]]:
+        self, engine_output: Optional[EngineOutput]
+    ) -> tuple[
+        list[int], 
+        Future[tuple[Optional[bytes], LLInterpreterResponse]], 
+        int
+    ]:
         if self.done():
             raise TokenParserException("Cannot advance on a done parser")
-        return self._generator.send(token)
-
+        
+        return self._generator.send(engine_output)
+    
     def has_pending_stop(self) -> bool:
         return self._has_pending_stop
 
-    def _process_prompt(self, prompt: bytes, ensure_bos_token: bool) -> list[int]:
-        prompt_tokens = self.ll_interpreter.process_prompt(
-            self.tokenizer.encode(prompt)
-        )
+    def _process_prompt(self, prompt: bytes, ensure_bos_token: bool) -> tuple[list[int], int]:
+        _prompt_tokens = self.tokenizer.encode(prompt)
+        prompt_tokens = self.ll_interpreter.process_prompt(_prompt_tokens)
         if (
             ensure_bos_token
             and self.tokenizer.bos_token is not None
@@ -101,47 +103,56 @@ def _parse(
         prompt: bytes,
         ensure_bos_token: bool,
     ) -> Generator[
-            tuple[
-                list[int],
-                Future[tuple[Optional[bytes], LLInterpreterResponse]],
-            ],
-            Optional[int],
-            None
-        ]:
+        tuple[
+            list[int], 
+            Future[tuple[Optional[bytes], LLInterpreterResponse]],
+            int
+        ], Optional[EngineOutput], None
+    ]:
         tokens = self._process_prompt(prompt=prompt, ensure_bos_token=ensure_bos_token)
 
+        backtrack = 0
+        engine_output = None
+        ff_tokens = []
         while True:
             # Note: need to call/set has_pending_stop before spinning up the compute mask 
             # future as the two methods cannot be called concurrently
             self._has_pending_stop = self.ll_interpreter.has_pending_stop()
-            mask_future = self._threadpool.submit(self.compute_mask)
-            token = yield (tokens, mask_future)
+            compute_mask_future = self._threadpool.submit(self.compute_mask)
+
+            # Send caller the mask and response; wait for token
+            engine_output = yield (tokens, compute_mask_future, backtrack)
 
             # Upstairs should have already waited on this future
-            mask, ll_response = mask_future.result()
+            mask, r = compute_mask_future.result()
 
-            if ll_response.stop:
+            if r.stop:
                 # This is the only case in which the mask is None
                 assert mask is None
                 # If we're done, our caller should NOT send us a token
-                if token is not None:
-                    raise TokenParserException(f"Expected None, got token {token}")
+                if engine_output is not None:
+                    raise TokenParserException(f"Expected None, got token {engine_output.issued_token.token_id}")
                 self._done = True
                 break
 
             assert mask is not None
-            if token is None:
+            assert r.temperature is not None
+
+            if engine_output is None:
                 raise TokenParserException("Expected token, got None")
-            if not mask[token]:
+            
+            if not mask[engine_output.issued_token.token_id]:
                 # Note: we could punt this probem to ll_interpreter.post_process,
                 # but it's a bit clearer to handle it here
                 raise InvalidTokenException(
-                    token=token,
+                    token=engine_output.issued_token.token_id,
                     valid_tokens=[i for i in range(len(mask)) if mask[i]],
                     prompt_tokens=tokens
-                )
+                )            
 
-            backtrack, ff_tokens = self.ll_interpreter.commit_token(token)
+            backtrack, ff_tokens = self.ll_interpreter.commit_token(
+                engine_output.issued_token.token_id
+            )
             if backtrack:
                 tokens = tokens[:-backtrack]
             tokens = tokens + ff_tokens
@@ -200,9 +211,7 @@ def valid_next_bytes(self) -> set[bytes]:
         if self.gen_data is None:
             return set()
         return {
-            bytes([t])
-            for t in self.gen_data.valid_next_tokens
-            if t != self.tokenizer.eos_token_id
+            bytes([t]) for t in self.gen_data.valid_next_tokens if t != self.tokenizer.eos_token_id
         }
 
     def next_byte_mask(self) -> NDArray[np.uint8]:
@@ -211,9 +220,9 @@ def next_byte_mask(self) -> NDArray[np.uint8]:
             mask[t[0]] = 1
         return mask
 
-    def _advance(self, token: Optional[int]) -> None:
-        tokens, mask_fut = self.token_parser.advance(token)
-        mask, ll_response = mask_fut.result()
+    def _advance(self, engine_output: Optional[EngineOutput]) -> None:
+        tokens, compute_mask_future, _ = self.token_parser.advance(engine_output)
+        mask, ll_response = compute_mask_future.result()
         if ll_response.stop:
             assert mask is None
             self.token_parser.cleanup()
@@ -272,7 +281,8 @@ def consume_bytes(self, bts: bytes) -> None:
                     consumed_bytes=self.bytes[: self.pos],
                 )
             # Byte was good, have ll_parser consume it so we can advance further
-            self._advance(b)
+            fake_engine_output = self.fake_engine_output(b)
+            self._advance(fake_engine_output)
 
             # Run consume_bytes to advance ll_parser and consume the next byte
             self.consume_bytes(bts)
@@ -283,7 +293,8 @@ def force_done(self):
         if self.token_parser.done():
             return
 
-        self._advance(self.tokenizer.eos_token_id)
+        fake_engine_output = self.fake_engine_output(self.tokenizer.eos_token_id)
+        self._advance(fake_engine_output)
         if not self.token_parser.done() or not self.matched():
             raise ByteParserException("Hit end of input before reaching a valid state")
 
@@ -301,23 +312,15 @@ def _update_capture(self, response: EngineCallResponse):
                     # convert to a string if possible
                     # TODO: will need to not just always do this once we support images etc.
                     try:
-                        inner_v = (
-                            inner_v.decode("utf8")
-                            if isinstance(inner_v, bytes)
-                            else inner_v
-                        )
+                        inner_v = inner_v.decode("utf8") if isinstance(inner_v, bytes) else inner_v
                     except UnicodeDecodeError:
                         pass
 
-                    if k not in self._variables or not isinstance(
-                        self._variables[k], list
-                    ):
+                    if k not in self._variables or not isinstance(self._variables[k], list):
                         self._variables[k] = []
                         self._variables_log_probs[k] = []
                     self._variables[k].append(inner_v)
-                    self._variables_log_probs[k].append(
-                        response.capture_group_log_probs[k][i]
-                    )
+                    self._variables_log_probs[k].append(response.capture_group_log_probs[k][i])
 
             # ...or standard assignment mode
             else:
@@ -329,3 +332,18 @@ def _update_capture(self, response: EngineCallResponse):
                     pass
                 self._variables[k] = v
                 self._variables_log_probs[k] = response.capture_group_log_probs[k]
+
+    def fake_engine_output(self, token_id: int) -> EngineOutput:
+        fake_issued_token = GenToken(
+            token_id=token_id,
+            prob=1.0,
+            text=self.tokenizer.decode([token_id]).decode("utf-8"),
+            latency_ms=0,
+            is_generated=True,
+        )
+        fake_engine_output = EngineOutput(
+            issued_token=fake_issued_token,
+            top_k=None,
+            masked_top_k=None,
+        )
+        return fake_engine_output
diff --git a/guidance/_schema.py b/guidance/_schema.py
index e5c9d15e8..b4b4d342e 100644
--- a/guidance/_schema.py
+++ b/guidance/_schema.py
@@ -1,4 +1,4 @@
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal, Optional, Union, Dict
 
 from pydantic import BaseModel, Field, NonNegativeInt, RootModel, model_validator, computed_field
 from typing_extensions import Annotated
@@ -8,6 +8,7 @@
 class GuidanceEngineMetrics(BaseModel):
     engine_input_tokens: NonNegativeInt = 0
     engine_output_tokens: NonNegativeInt = 0
+    engine_backtrack_tokens: NonNegativeInt = 0
 
 
 class EngineCallResponse(BaseModel):
@@ -17,6 +18,48 @@ class EngineCallResponse(BaseModel):
     capture_groups: dict
     capture_group_log_probs: dict
     new_token_count: NonNegativeInt
+    backtrack: NonNegativeInt = 0  # number of tokens was backtracked by the parser
+    latency_ms: NonNegativeInt = 0  # time taken by the engine to generate the output chunk
+    engine_outputs: list["EngineOutput"] = []  # list of tokens generated by the engine
+    generated_bytes: bytes = b""  # bytes generated by the engine
+    generated_tokens: list["GenToken"] = []  # tokens associated with the generated bytes
+    force_forwarded_bytes: bytes = b""  # bytes that were forced forwards by the parser
+    force_forwarded_tokens: list["GenToken"] = (
+        []
+    )  # tokens associated with the forced forwarded bytes
+
+
+class GenToken(BaseModel):
+    token_id: int
+    prob: float
+    text: str = ""
+    latency_ms: float = 0.0
+    is_masked: bool = False # true if this token was ignored by the parser
+    is_generated: bool = False # true if this token was generated by the engine
+    is_force_forwarded: bool = False # true if this token was forced forwarded by the parser
+    is_input: bool = False # true if this token was part of the input
+
+
+class GenTokenExtra(GenToken):
+    top_k: list["GenToken"] = []
+
+
+class EngineOutput(BaseModel):
+    # real token that was issued by the engine
+    issued_token: GenToken
+    top_k: Optional[list[GenToken]]
+    masked_top_k: Optional[list[GenToken]]
+    is_backtracked: bool = False  # true if this token was backtracked by the parser
+
+
+class VisBytesChunk(BaseModel):
+    bytes: bytes
+    is_input: bool = False
+    input_tokens: list[GenToken] = []
+    generated_tokens: list[GenToken] = []
+    force_forwarded_tokens: list["GenToken"] = []
+    backtrack: NonNegativeInt = 0
+    engine_outputs: list[EngineOutput] = []
 
 
 class GenData(BaseModel):
@@ -84,9 +127,7 @@ def to_engine_call_response(self) -> EngineCallResponse:
                 cname = j.name
                 data = bytes.fromhex(j.hex)
                 if j.list_append:
-                    if cname not in capture_groups or not isinstance(
-                        capture_groups[cname], list
-                    ):
+                    if cname not in capture_groups or not isinstance(capture_groups[cname], list):
                         capture_groups[cname] = []
                         capture_group_log_probs[cname] = []
                     capture_groups[cname].append(data)
diff --git a/guidance/_utils.py b/guidance/_utils.py
index 623c81771..ac24e257b 100644
--- a/guidance/_utils.py
+++ b/guidance/_utils.py
@@ -8,8 +8,11 @@
 import types
 import weakref
 import functools
-
 import numpy as np
+import logging
+
+logger = logging.getLogger(__name__)
+
 
 class _Rewrite(ast.NodeTransformer):
     def __init__(self, source_lines):
@@ -258,3 +261,73 @@ def softmax(array: np.ndarray, axis: int = -1) -> np.ndarray:
     array_maxs = np.amax(array, axis=axis, keepdims=True)
     exp_x_shifted = np.exp(array - array_maxs)
     return exp_x_shifted / np.sum(exp_x_shifted, axis=axis, keepdims=True)
+
+
+def pydantic_no_default_repr(obj, target_fields=None):
+    if target_fields is None:
+        records = (
+            f'{getattr(obj, name)!r}'
+            for name, field in obj.model_fields.items()
+            if getattr(obj, name) != field.default and not field.exclude
+        )
+    else:
+        records = (
+            f'{getattr(obj, name)!r}'
+            for name, field in obj.model_fields.items()
+            if getattr(obj, name) != field.default and not field.exclude and name in target_fields
+        )
+    out = f'{type(obj).__name__}:{":".join(records)}'
+    return out
+
+
+def pydantic_no_default_str(obj, target_fields=None):
+    if target_fields is None:
+        records = (
+            f'{getattr(obj, name)!s}'
+            for name, field in obj.model_fields.items()
+            if getattr(obj, name) != field.default and not field.exclude
+        )
+    else:
+        records = (
+            f'{getattr(obj, name)!s}'
+            for name, field in obj.model_fields.items()
+            if getattr(obj, name) != field.default and not field.exclude and name in target_fields
+        )
+    out = "\n".join(records)
+    return out
+
+
+def log_init(s: str):
+    logger.debug(f"INIT:{s}")
+    pass
+
+
+def log_copy(s: str):
+    logger.debug(f"COPY:{s}")
+    pass
+
+
+def log_cleanup(s: str):
+    logger.debug(f"CLEANUP:{s}")
+    pass
+
+def to_utf8_or_bytes_string(_bytes: bytes) -> str:
+    """
+    Converts a byte sequence to a UTF-8 string if possible. If the byte sequence
+    cannot be decoded as UTF-8, it returns the string representation of the byte sequence.
+
+    Parameters
+    ----------
+    _bytes : bytes
+        The byte sequence to be converted.
+
+    Returns
+    -------
+    str
+        The decoded UTF-8 string or the string representation of the byte sequence
+        if UTF-8 decoding fails.
+    """
+    try:
+        return _bytes.decode("utf-8")
+    except UnicodeDecodeError:
+        return str(_bytes)
\ No newline at end of file
diff --git a/guidance/library/_block.py b/guidance/library/_block.py
index 753e34e36..0fc559f0c 100644
--- a/guidance/library/_block.py
+++ b/guidance/library/_block.py
@@ -8,10 +8,10 @@ def __init__(self, opener, closer, name=None):
         self.name = name
 
     def __enter__(self):
-        models.Model.open_blocks[self] = None
+        models.Model.global_active_blocks.append(self)
 
     def __exit__(self, exc_type, exc_value, traceback):
-        del models.Model.open_blocks[self]
+        models.Model.global_active_blocks.remove(self)
 
 
 def block(name=None, opener="", closer=""):
diff --git a/guidance/library/_role.py b/guidance/library/_role.py
index 843ed904e..3ecc8a03a 100644
--- a/guidance/library/_role.py
+++ b/guidance/library/_role.py
@@ -2,78 +2,24 @@
 from ._block import block
 from ._set_attribute import set_attribute
 
-nodisp_start = "<||_#NODISP_||>"
-nodisp_end = "<||_/NODISP_||>"
-span_start = "<||_html:<span style='background-color: rgba(255, 180, 0, 0.3); border-radius: 3px;'>_||>"
-span_end = "<||_html:</span>_||>"
 
 @guidance
 def role_opener(lm, role_name, **kwargs):
-    indent = getattr(lm, "indent_roles", True)
-
-
-    # Block start container (centers elements)
-    if indent:
-        lm += f"<||_html:<div style='display: flex; border-bottom: 1px solid rgba(127, 127, 127, 0.2);  justify-content: center; align-items: center;'><div style='flex: 0 0 80px; opacity: 0.5;'>{role_name.lower()}</div><div style='flex-grow: 1; padding: 5px; padding-top: 10px; padding-bottom: 10px; margin-top: 0px; white-space: pre-wrap; margin-bottom: 0px;'>_||>"
-
-    # Start of either debug or HTML no disp block
-    if indent:
-        lm += nodisp_start
-    else:
-        lm += span_start
-    
-    # TODO [HN]: Temporary change while I instrument chat_template in transformers only.
-    # Eventually have all models use chat_template.
-    if hasattr(lm, "get_role_start"):
-        lm += lm.get_role_start(role_name, **kwargs)
-    elif hasattr(lm, "chat_template"):
-        lm += lm.chat_template.get_role_start(role_name)
-    else:
-        raise Exception(
-            f"You need to use a chat model in order the use role blocks like `with {role_name}():`! Perhaps you meant to use the {type(lm).__name__}Chat class?"
-        )
-
-    # End of either debug or HTML no disp block
-    if indent:
-        lm += nodisp_end
-    else:
-        lm += span_end
-
+    lm += lm.role_opener(role_name, **kwargs)
     return lm
 
 
 @guidance
 def role_closer(lm, role_name, **kwargs):
-    indent = getattr(lm, "indent_roles", True)
-    # Start of either debug or HTML no disp block
-    if indent:
-        lm += nodisp_start
-    else:
-        lm += span_start
-
-    # TODO [HN]: Temporary change while I instrument chat_template in transformers only.
-    # Eventually have all models use chat_template.
-    if hasattr(lm, "get_role_end"):
-        lm += lm.get_role_end(role_name)
-    elif hasattr(lm, "chat_template"):
-        lm += lm.chat_template.get_role_end(role_name)
-
-    # End of either debug or HTML no disp block
-    if indent:
-        lm += nodisp_end
-    else:
-        lm += span_end
-
-    # End of top container
-    if indent:
-        lm += "<||_html:</div></div>_||>"
-
+    lm += lm.role_closer(role_name, **kwargs)
     return lm
 
+
 # TODO HN: Add a docstring to better describe arbitrary role functions
 def role(role_name, text=None, **kwargs):
     if text is None:
         return block(
+            name=role_name,
             opener=role_opener(role_name, **kwargs),
             closer=role_closer(role_name, **kwargs),
         )
diff --git a/guidance/models/_mock.py b/guidance/models/_mock.py
index a2ae59a3a..1d80a0e73 100644
--- a/guidance/models/_mock.py
+++ b/guidance/models/_mock.py
@@ -2,21 +2,27 @@
 import numpy as np
 import logging
 
+from .._utils import softmax
+
+from guidance._schema import EngineOutput, GenToken, GenTokenExtra
+
 from ._model import Engine, Model, Chat
 from ._remote import RemoteEngine
 from ._tokenizer import Tokenizer
 
+from ..visual._renderer import DoNothingRenderer
+from ..trace import TraceHandler
+
 logger = logging.getLogger(__name__)
 
 # TODO: this import pattern happens in a few places, should be cleaned up
 try:
     from .. import cpp  # type: ignore[attr-defined]
 except ImportError:
-    logger.warn(
-        "Failed to load guidance.cpp, falling back to Python mirror implementations..."
-    )
+    logger.warn("Failed to load guidance.cpp, falling back to Python mirror implementations...")
     from .. import _cpp as cpp
 
+
 class MockTokenizer(Tokenizer):
     def __init__(self, tokens: Sequence[bytes]):
         super().__init__(tokens, chat_template=None, bos_token_id=0, eos_token_id=0)
@@ -33,7 +39,9 @@ def encode(self, byte_string: bytes) -> list[int]:
             last_match = None
             match_pos = pos
 
-            while match_pos < len(byte_string) and current_node.has_child(byte_string[match_pos : match_pos + 1]):
+            while match_pos < len(byte_string) and current_node.has_child(
+                byte_string[match_pos : match_pos + 1]
+            ):
                 current_node = current_node.child(byte_string[match_pos : match_pos + 1])
                 if current_node.value >= 0:
                     last_match = (current_node.value, match_pos + 1)
@@ -43,7 +51,9 @@ def encode(self, byte_string: bytes) -> list[int]:
                 tokens.append(last_match[0])
                 pos = last_match[1]
             else:
-                raise ValueError(f"Could not find a match for byte {byte_string[pos]} at position {pos}")
+                raise ValueError(
+                    f"Could not find a match for byte {byte_string[pos]} at position {pos}"
+                )
 
         return tokens
 
@@ -54,7 +64,8 @@ def recode(self, tokens: Sequence[int]) -> list[int]:
 
 class MockEngine(Engine):
     def __init__(self, tokenizer, byte_patterns, compute_log_probs, force):
-        super().__init__(tokenizer, compute_log_probs=compute_log_probs)
+        renderer = DoNothingRenderer(trace_handler=TraceHandler())
+        super().__init__(tokenizer, compute_log_probs=compute_log_probs, enable_monitoring=False, renderer=renderer)
 
         self._valid_mask = np.zeros(len(tokenizer.tokens))
         for i, t in enumerate(tokenizer.tokens):
@@ -84,6 +95,19 @@ def sample_with_temperature(self, logits, mask, temperature):
         self.called_temperatures.append(temperature)
         return super().sample_with_temperature(logits, mask, temperature)
 
+    def get_next_token_with_top_k(
+        self,
+        logits: Optional[np.ndarray],
+        logits_lat_ms: Optional[float],
+        token_ids: list[int],
+        mask: Optional[bytes],
+        temperature: float,
+        k: int = 1,
+        force_return_unmasked_probs: bool = False,
+    ) -> EngineOutput:
+        self.called_temperatures.append(temperature)
+        return super().get_next_token_with_top_k(logits, logits_lat_ms, token_ids, mask, temperature, k, force_return_unmasked_probs)
+
     def get_logits(self, token_ids: list[int]) -> np.ndarray:
         """Pretends to compute the logits for the given token state."""
         # build the byte strings
@@ -96,8 +120,7 @@ def get_logits(self, token_ids: list[int]) -> np.ndarray:
         # otherwise we randomly generate valid unicode bytes
         else:
             logits = (
-                self._rand_generator.standard_normal(len(self.tokenizer.tokens))
-                * self._valid_mask
+                self._rand_generator.standard_normal(len(self.tokenizer.tokens)) * self._valid_mask
             )
 
         # if we have a pattern that matches then force the next token
@@ -112,10 +135,70 @@ def get_logits(self, token_ids: list[int]) -> np.ndarray:
 
         return logits
 
+    def get_per_token_topk_probs(self, token_ids: list[int], top_k: int = 5) -> list[GenTokenExtra]:
+        result_list = []
+        if len(token_ids) == 0:
+            return result_list
+        
+        added_bos = False
+        if self.tokenizer.bos_token is not None and token_ids[0] != self.tokenizer.bos_token_id:
+            token_ids = [self.tokenizer.bos_token_id] + token_ids
+            added_bos = True
+
+        # assume the first token has probability 1.0 because it is the input token
+        result_list.append(
+            GenTokenExtra(
+                token_id=token_ids[0],
+                prob=1.0,
+                text=self.tokenizer.decode([token_ids[0]]).decode("utf8"),
+                top_k=[
+                    GenToken(
+                        token_id=token_ids[0],
+                        prob=1.0,
+                        text=self.tokenizer.decode([token_ids[0]]).decode("utf8"),
+                    )
+                ],
+            )
+        )
+
+        for i in range(1, len(token_ids)):
+            token_id = token_ids[i]
+            _logits = self.get_logits(token_ids[:i])
+            _probs = softmax(_logits)
+            top_k_indices = np.argsort(_logits)[-top_k:][::-1]
+
+            top_k_indices = top_k_indices.tolist()
+            if token_ids[i] not in top_k_indices:
+                top_k_indices.append(token_id)
+
+            top_k_result = []
+            for token_id in top_k_indices:
+                top_k_result.append(
+                    GenToken(
+                        token_id=token_id,
+                        prob=_probs[token_id],
+                        text=self.tokenizer.decode([token_id]).decode("utf8"),
+                    )
+                )
+
+            result_list.append(
+                GenTokenExtra(
+                    token_id=token_id,
+                    prob=_probs[token_id],
+                    text=self.tokenizer.decode([token_id]).decode("utf-8"),
+                    top_k=top_k_result,
+                )
+            )
+
+        if added_bos:
+            result_list = result_list[1:]
+
+        return result_list
+
     def _get_next_tokens(self, byte_string):
         special_tokens = [
             (self.tokenizer.bos_token_id, self.tokenizer.bos_token),
-            (self.tokenizer.eos_token_id, self.tokenizer.eos_token)
+            (self.tokenizer.eos_token_id, self.tokenizer.eos_token),
         ]
         for i, t in special_tokens:
             # if the byte string starts with a special token then make sure we don't yield any other tokens
@@ -131,7 +214,7 @@ class Mock(Model):
     def __init__(
         self,
         byte_patterns=[],
-        echo=True,
+        echo=False,
         compute_log_probs=False,
         force=False,
         **kwargs,
@@ -143,9 +226,7 @@ def __init__(
         else:
             # Our tokens are all bytes and all lowercase letter pairs
             all_lc_pairs = [
-                bytes([i, j])
-                for i in range(ord("a"), ord("z"))
-                for j in range(ord("a"), ord("z"))
+                bytes([i, j]) for i in range(ord("a"), ord("z")) for j in range(ord("a"), ord("z"))
             ]
             all_bytes = [bytes([i]) for i in range(256)]
             tokens = [b"<s>"] + all_lc_pairs + all_bytes
diff --git a/guidance/models/_model.py b/guidance/models/_model.py
index 81b1cd4b2..da02a3ce7 100644
--- a/guidance/models/_model.py
+++ b/guidance/models/_model.py
@@ -1,21 +1,49 @@
-import base64
+# TODO(nopdive): This module requires a memory review.
+
 import copy
-import html
 import logging
 import queue
 import re
-import textwrap
 import threading
-import time
-import warnings
-
-from pprint import pprint
-from typing import Any, Dict, Iterator, List, Optional, Union, TYPE_CHECKING
+import weakref
 
+import time
+from asyncio import CancelledError
+from typing import Iterator, Optional, TYPE_CHECKING, Callable
+from multiprocessing import Manager, Process
+from typing import Any, Union
+from enum import Enum
+import psutil
 
 import numpy as np
 
-from ..visual import Environment
+from ..trace import (
+    NodeAttr,
+    StatelessGuidanceInput,
+    StatefulGuidanceInput,
+    LiteralInput,
+    EmbeddedInput,
+    RoleOpenerInput,
+    RoleCloserInput,
+    TextOutput,
+    CaptureOutput,
+    TraceHandler,
+)
+from ..visual import (
+    TraceMessage,
+    AutoRenderer,
+    trace_node_to_str,
+    trace_node_to_html,
+    GuidanceMessage,
+    Renderer,
+    ExecutionStartedMessage,
+    ExecutionCompletedMessage,
+    TokensMessage,
+    MetricMessage,
+    OutputRequestMessage,
+    JupyterWidgetRenderer,
+)
+from ..visual._async import run_async_coroutine, async_task
 
 try:
     from IPython.display import clear_output, display, HTML
@@ -26,8 +54,15 @@
 
 logger = logging.getLogger(__name__)
 
-from .._schema import EngineCallResponse, GuidanceEngineMetrics
-from .._utils import softmax, CaptureEvents
+from .._schema import (
+    EngineCallResponse,
+    EngineOutput,
+    GenToken,
+    GuidanceEngineMetrics,
+    VisBytesChunk,
+    GenTokenExtra,
+)
+from .._utils import softmax, CaptureEvents, log_cleanup, log_init, log_copy, to_utf8_or_bytes_string
 from .._parser import TokenParser
 from .._grammar import (
     Function, # for da types, just for you Hudson <3 
@@ -48,11 +83,210 @@
 # define some constants we will reuse many times
 _null_grammar = string("")
 format_pattern = re.compile(r"<\|\|_.*?_\|\|>", flags=re.DOTALL)
-nodisp_pattern = re.compile(
-    r"&lt;\|\|_#NODISP_\|\|&gt;.*?&lt;\|\|_/NODISP_\|\|&gt;", flags=re.DOTALL
-)
-html_pattern = re.compile(r"&lt;\|\|_html:(.*?)_\|\|&gt;", flags=re.DOTALL)
-image_pattern = re.compile(r"&lt;\|_image:(.*?)\|&gt;")
+
+
+class PeriodicMetricsGenerator:
+    def __init__(self, renderer: Renderer, monitor: "Monitor", sleep_sec=0.5):
+        self._renderer = renderer
+        self._monitor = monitor
+        self._sleep_sec = sleep_sec
+        self._task = None
+        self._task_cancelled = False
+        self._is_paused = False
+        run_async_coroutine(self._emit())
+
+    def start(self):
+        self._task = run_async_coroutine(async_task(self._emit())).result()
+
+    def stop(self):
+        if self._task is not None:
+            self._task.cancel()
+            # TODO: it seems _task.cancel() is not working, use a flag to stop the task
+            self._task_cancelled = True
+
+    def pause(self):
+        """
+        Pauses the model by setting the internal _is_paused flag to True.
+        
+        This method can be used to temporarily halt the model's operations.
+        """
+        self._is_paused = True
+
+    def resume(self):
+        """
+        Resume the model's operation by setting the paused state to False.
+
+        This method changes the internal state of the model to indicate that it is no longer paused.
+        """
+        self._is_paused = False
+
+    async def _emit(self):
+        import asyncio
+        import time
+
+        time_start = time.time()
+        while not self._task_cancelled:
+            try:
+                await asyncio.sleep(self._sleep_sec)
+
+                cpu_percent = self._monitor.get_metric(MonitoringMetric.CPU_USAGE)
+                mem_percent = self._monitor.get_metric(MonitoringMetric.MEM_USAGE)
+                gpu_percent = self._monitor.get_metric(MonitoringMetric.GPU_USAGE)
+                gpu_used_vram = self._monitor.get_metric(MonitoringMetric.GPU_USED_MEM)
+
+                if gpu_percent:
+                    gpu_percent = max(gpu_percent)
+                else:
+                    gpu_percent = 0
+
+                if gpu_used_vram:
+                    gpu_used_vram = max(gpu_used_vram)
+                else:
+                    gpu_used_vram = 0
+
+                if not cpu_percent:
+                    cpu_percent = 0
+
+                if not mem_percent:
+                    mem_percent = 0
+
+                time_end = time.time()
+                time_elapsed = time_end - time_start
+
+                if not self._is_paused:
+                    self._renderer.update(MetricMessage(name="wall time", value=time_elapsed))
+                    self._renderer.update(MetricMessage(name="cpu", value=cpu_percent))
+                    self._renderer.update(MetricMessage(name="ram", value=mem_percent))
+                    self._renderer.update(MetricMessage(name="gpu", value=gpu_percent))
+                    self._renderer.update(MetricMessage(name="vram", value=gpu_used_vram))
+            except CancelledError:
+                logger.debug("METRICGEN:canceling")
+                break
+            except Exception as e:
+                logger.debug(f"METRICGEN: {repr(e)}")
+                break
+
+        logger.debug("METRICGEN:exiting")
+
+
+class PostExecMetrics:
+    def __init__(self, renderer: Renderer, monitor: "Monitor"):
+        self._renderer = renderer
+        self._monitor = monitor
+
+    def emit_messages(self, lm: "Model"):
+        token_reduction = self._monitor.get_metric(MonitoringMetric.TOKEN_REDUCTION, lm)
+        if token_reduction is not None:
+            self._renderer.update(
+                MetricMessage(
+                    name="token reduction",
+                    value=token_reduction * 100,
+                )
+            )
+
+        output_tokens = self._monitor.get_metric(MonitoringMetric.OUTPUT_TOKENS, lm)
+        if output_tokens is not None:
+            self._renderer.update(MetricMessage(name="consumed", value=output_tokens))
+
+        avg_latency = self._monitor.get_metric(MonitoringMetric.AVG_LATENCY, lm)
+        if avg_latency is not None:
+            self._renderer.update(MetricMessage(name="avg latency", value=avg_latency))
+
+
+def _engine_cleanup(renderer: Renderer, msg_recv: Callable[[GuidanceMessage], None], 
+                    monitor: Optional['Monitor'],  
+                    periodic_metrics_generator: Optional[PeriodicMetricsGenerator],
+                    log_msg: str):
+    renderer.unsubscribe(msg_recv)
+
+    try:
+        # force renderer cleanup
+        # TODO: figure out why in some cases _recv_task and _send_task are not stopped
+        from ..visual._renderer import _cleanup
+        if isinstance(renderer, AutoRenderer) and isinstance(renderer._renderer, JupyterWidgetRenderer):
+            _cleanup(renderer._renderer._recv_queue, renderer._renderer._send_queue, f"renderer({id(renderer)})")
+    except Exception as e:
+        logger.error(f"Failed to force-cleanup renderer: {e}")
+
+    if periodic_metrics_generator is not None:
+        try:
+            periodic_metrics_generator.stop()
+        except Exception as e:
+            logger.error(f"Failed to stop periodic metrics generator: {e}")
+
+    if monitor is not None:
+        try:
+            monitor.stop()
+        except Exception as e:
+            logger.error(f"Failed to stop monitor: {e}")
+
+    log_cleanup(log_msg)
+
+
+def _wrapped_msg_recv(engine_weak_ref: weakref.ref) -> Callable[[GuidanceMessage], None]:
+    def closure(message):
+        return _msg_recv(engine_weak_ref, message)
+
+    return closure
+
+
+def _msg_recv(engine_weakref: weakref.ReferenceType, message: GuidanceMessage) -> None:
+    engine = engine_weakref()
+    if engine is None:
+        return
+
+    # NOTE(nopdive): This is usually run on a background thread.
+    logger.debug(f"ENGINE:msg_recv:{message}")
+    if isinstance(message, ExecutionStartedMessage):
+        # TODO(nopdive): Start execution logic here.
+        logger.debug(f"ENGINE:msg_recv:START STUB")
+        if engine.periodic_metrics_generator is not None:
+            engine.periodic_metrics_generator.resume()
+    elif isinstance(message, ExecutionCompletedMessage) and message.is_err:
+        pass
+    elif isinstance(message, (ExecutionCompletedMessage, OutputRequestMessage)):
+        # print("last_state")
+        if isinstance(message, TokensMessage):
+            last_model: "Model" = engine.model_dict[message.last_trace_id]
+            last_trace_id = message.last_trace_id
+        else:
+            last_model = list(engine.model_dict.values())[-1]
+            last_trace_id = last_model._id
+
+        failed = False
+        processed_gen_tokens: list[GenTokenExtra] = []  # suppress IDE warnings by definition
+        try:
+            processed_gen_tokens = last_model.get_per_token_stats()
+        except Exception as e:
+            logger.error(f"Failed to get per token stats: {e}")
+            failed = True
+
+        if not failed:
+            final_text = "".join([gen_token.text for gen_token in processed_gen_tokens])
+            logger.debug(f"ENGINE:final_text:{final_text}")
+            logger.debug(f"ENGINE:model_state:{last_model._state}")
+            logger.debug(f"ENGINE:final_text == _state:{final_text == last_model._state}")
+
+            tokens = [gen_token.token_id for gen_token in processed_gen_tokens]
+            engine.renderer.update(
+                TokensMessage(
+                    trace_id=last_trace_id,
+                    text=engine.tokenizer.decode(tokens).decode("utf-8"),
+                    tokens=processed_gen_tokens,
+                )
+            )
+            engine.renderer.update(MetricMessage(name="status", value="✓"))
+        else:
+            engine.renderer.update(MetricMessage(name="status", value="⚠"))
+
+        if engine.periodic_metrics_generator is not None:
+            engine.periodic_metrics_generator.pause()
+
+        try:
+            # send stats to the renderer
+            engine.post_exec_metrics.emit_messages(last_model)
+        except:
+            pass
 
 
 class Engine:
@@ -64,13 +298,49 @@ class Engine:
     Server so a single server can serve many clients' model objects through a single Engine object.
     """
 
-    def __init__(self, tokenizer: Tokenizer, compute_log_probs=False, enable_backtrack=True, enable_ff_tokens=True):
+    def __init__(self, tokenizer: Tokenizer, 
+                 compute_log_probs=False, 
+                 enable_backtrack=True, 
+                 enable_ff_tokens=True, 
+                 renderer=None, 
+                 enable_monitoring=True,
+                 **kwargs):
+        # TODO(nopdive): Hook up renderer keyword to all engines.
         self.tokenizer = tokenizer
         self.compute_log_probs = compute_log_probs
         self._enable_backtrack = enable_backtrack
         self._enable_ff_tokens = enable_ff_tokens
+        self._enable_monitoring = enable_monitoring
+        self._top_k = kwargs.get("top_k", 5)
         self.metrics = GuidanceEngineMetrics()
 
+        if renderer is None:
+            self.trace_handler = TraceHandler()
+            self.renderer = AutoRenderer(self.trace_handler)
+            # self.renderer = JupyterWidgetRenderer(self.trace_handler)
+        else:
+            self.renderer = renderer
+            self.trace_handler = renderer._trace_handler
+
+        msg_recv = _wrapped_msg_recv(weakref.ref(self))
+        self.renderer.subscribe(msg_recv)
+
+        self.model_dict: weakref.WeakValueDictionary[int, Model] = weakref.WeakValueDictionary()
+
+        self.monitor = None
+        self.periodic_metrics_generator = None
+        self.post_exec_metrics = None
+        if self._enable_monitoring:
+            self.monitor = Monitor(self.metrics)
+            self.monitor.start()
+
+            self.periodic_metrics_generator = PeriodicMetricsGenerator(self.renderer, self.monitor)
+            self.periodic_metrics_generator.start()
+            self.post_exec_metrics = PostExecMetrics(self.renderer, self.monitor)
+
+        weakref.finalize(self, _engine_cleanup, self.renderer, msg_recv, self.monitor, self.periodic_metrics_generator, f"engine({id(self)})")
+        log_init(f"engine({id(self)})")
+
     # These need to be properties because once an Engine is started, you can't change their behavior.
     @property
     def enable_backtrack(self):
@@ -79,10 +349,18 @@ def enable_backtrack(self):
     @property
     def enable_ff_tokens(self):
         return self._enable_ff_tokens
-
-    def get_chat_template(self): # TODO [HN]: Add more logic here...should we instantiate class here? do we even need to?
-        return self.tokenizer.chat_template() # Instantiate the class before returning to client for now
     
+    @property
+    def enable_monitoring(self):
+        return self._enable_monitoring
+
+    def get_chat_template(
+        self,
+    ):  # TODO [HN]: Add more logic here...should we instantiate class here? do we even need to?
+        return (
+            self.tokenizer.chat_template()
+        )  # Instantiate the class before returning to client for now
+
     def reset_metrics(self):
         self.metrics = GuidanceEngineMetrics()
 
@@ -103,7 +381,7 @@ def start(self, prompt, grammar, ensure_bos_token=True) -> TokenParser:
             prompt = bytes(prompt, encoding="utf8")
         elif isinstance(prompt, TokenParser):
             raise NotImplementedError(
-                "Still need to implement support for extending a full Parser state."
+                "Still need to implement support for extending a full Parser trace."
             )
         else:
             raise Exception("The passed prompt is of an unknown type!")
@@ -121,7 +399,8 @@ def __call__(
             self, 
             prompt: Union[str, TokenParser], 
             grammar: Function,
-            ensure_bos_token: bool = True, 
+            ensure_bos_token: bool = True,
+            echo: bool = True,
         ) -> Iterator[EngineCallResponse]:
         """Main entry point for the inference-parser loop. Yields EngineCallResponse objects as
         the parser advances through the grammar.
@@ -142,9 +421,14 @@ def __call__(
         parser = self.start(prompt, grammar, ensure_bos_token)
 
         has_get_logits = True
-        token = None
-        while True:
-            tokens, mask_fut = parser.advance(token)
+        engine_output = None
+        logits_lat_ms = 0
+        delayed_bytes = b""
+        delayed_engine_outputs: list[EngineOutput] = []
+        while not parser.done():
+            t0 = time.time()
+
+            tokens, mask_fut, backtrack = parser.advance(engine_output)
 
             # Note that has_pending_stop implies that the response is a stop response,
             # but the converse is not true. We can therefore avoid some (but not all)
@@ -153,11 +437,14 @@ def __call__(
 
             if has_get_logits and not has_pending_stop:
                 try:
+                    t0 = time.time()
                     logits = self.get_logits(token_ids=tokens)
+                    logits_lat_ms = (time.time() - t0) * 1000
                 except NotImplementedError:
                     # Permanently fall-back to get_next_token if get_logits is not implemented
                     has_get_logits = False
                     logits = None
+                    logits_lat_ms = 0
             else:
                 logits = None
 
@@ -166,6 +453,102 @@ def __call__(
             mask, ll_response = mask_fut.result()
 
             engine_response = ll_response.progress.to_engine_call_response()
+            engine_response.backtrack = backtrack
+            if engine_output:
+                engine_response.engine_outputs.append(engine_output)
+
+            # NOTE (loc): Temporary solution to quickly check which segments are generated and which are force-forwarded to animate visualizations on the UI
+            # These tokens in chunk will not be used for final visualization
+            # TODO: This should be handled by the interpreter
+            if echo and engine_response.new_bytes:
+                try:
+                    _new_bytes = delayed_bytes + engine_response.new_bytes
+                    _tokens = parser.tokenizer.encode(_new_bytes)
+                    delayed_bytes = b""
+                except UnicodeDecodeError:
+                    # similar to what we did in _run_stateless function, if we could not decode current bytes
+                    # we will delay until we can decode them
+                    delayed_bytes += engine_response.new_bytes
+                    if engine_output:
+                        engine_response.engine_outputs.pop()
+                        delayed_engine_outputs.append(engine_output)
+
+                if not delayed_bytes:
+                    ff_token_start_idx = 1
+                    if engine_output is None and len(delayed_engine_outputs) == 0:
+                        ff_token_start_idx = 0
+                    elif engine_output.issued_token.token_id == _tokens[0] and len(delayed_engine_outputs) == 0:
+                        # this is generated
+                        engine_response.generated_bytes = parser.tokenizer.decode([_tokens[0]])
+                        engine_output.issued_token.is_generated = True
+                        engine_response.generated_tokens.append(engine_output.issued_token)
+                    else:
+                        # handle delayed bytes
+                        engine_outputs = delayed_engine_outputs + [engine_output] if engine_output else []
+                        engine_output_tokens = [e.issued_token.token_id for e in engine_outputs]
+
+                        generated = to_utf8_or_bytes_string(parser.tokenizer.decode(engine_output_tokens))
+                        force_forwarded = _new_bytes.decode("utf-8")
+
+                        if force_forwarded.startswith(generated):
+                            engine_output_tokens = np.array(engine_output_tokens)
+                            ff_tokens = np.array(_tokens)
+
+                            # check if engine_output_tokens in ff_tokens
+                            _idx = -1
+                            for _i in range(0, len(ff_tokens) - len(engine_output_tokens) + 1):
+                                if np.array_equal(engine_output_tokens, ff_tokens[_i:_i+len(engine_output_tokens)]):
+                                    _idx = _i + len(engine_output_tokens)
+                                    break
+
+                            if _idx < 0:
+                                ff_token_start_idx = 0
+                            else:
+                                # all previous tokens before _idx are generated
+                                engine_response.generated_bytes = parser.tokenizer.decode(ff_tokens[:_idx])
+                                idx_in_engine_output_tokens = 0
+                                for _i in range(_idx):
+                                    matching_engine_output = None
+                                    if _tokens[_i] == engine_output_tokens[idx_in_engine_output_tokens]:
+                                        matching_engine_output = engine_outputs[idx_in_engine_output_tokens]
+                                        idx_in_engine_output_tokens += 1
+                                    engine_response.generated_tokens.append(
+                                        GenToken(
+                                            token_id=_tokens[_i],
+                                            prob=1.0 if not matching_engine_output else matching_engine_output.issued_token.prob,
+                                            text=parser.tokenizer.decode([_tokens[_i]]) if not matching_engine_output else matching_engine_output.issued_token.text,
+                                            latency_ms=0.0 if not matching_engine_output else matching_engine_output.issued_token.latency_ms,
+                                            is_generated=True,
+                                        )
+                                    )
+                                ff_token_start_idx = _idx
+                        else:
+                            ff_token_start_idx = 0
+
+                    if len(_tokens[ff_token_start_idx:]):
+                        engine_response.force_forwarded_bytes = parser.tokenizer.decode(
+                            _tokens[ff_token_start_idx:]
+                        )
+                        for _token in _tokens[ff_token_start_idx:]:
+                            engine_response.force_forwarded_tokens.append(
+                                GenToken(
+                                    token_id=_token,
+                                    prob=1.0,
+                                    text=to_utf8_or_bytes_string(parser.tokenizer.decode([_token])),
+                                    latency_ms=0,
+                                    is_force_forwarded=True,
+                                )
+                            )
+
+                    delayed_engine_outputs = []
+            elif not echo and engine_response.new_bytes:
+                # do not collect tokens-metrics if echo is disabled
+                engine_response.generated_bytes = engine_response.new_bytes
+                engine_response.generated_tokens.clear()
+
+            # process engine_response
+            # NOTE (loc): We should not yield the engine_response if new_bytes are invalid utf-8 bytes
+            # delayed bytes should be handled here in the engine
             yield engine_response
 
             if ll_response.stop:
@@ -196,26 +579,164 @@ def __call__(
             else:
                 mask_for_sampling = mask
 
-            if logits is not None:
-                token = self.sample_with_temperature(
-                    logits=logits,
-                    mask=mask_for_sampling,
-                    temperature=ll_response.temperature,
-                )
-            else:
-                token = self.get_next_token(
-                    tokens,
-                    mask_for_sampling,
-                    ll_response.temperature
-                )
+            engine_output = self.get_next_token_with_top_k(
+                logits=logits,
+                logits_lat_ms=logits_lat_ms,
+                token_ids=tokens,
+                mask=mask_for_sampling,
+                temperature=ll_response.temperature,
+                k=self._top_k,
+                force_return_unmasked_probs=echo
+            )
 
-            if can_finish_early and not mask[token]:
+            if can_finish_early and not mask[engine_output.issued_token.token_id]:
                 # Type checker needs some help
                 assert self.tokenizer.eos_token_id is not None
-                token = self.tokenizer.eos_token_id
+                engine_output.issued_token.token_id = self.tokenizer.eos_token_id
+
+    def get_next_token_with_top_k(
+        self,
+        logits: Optional[np.ndarray],
+        logits_lat_ms: Optional[float],
+        token_ids: list[int],
+        mask: Optional[bytes],
+        temperature: float,
+        k: int = 5,
+        force_return_unmasked_probs: bool = False,
+    ) -> EngineOutput:
+        """Get the next token and associated top-k tokens from the engine.
+
+        Parameters
+        -------
+        logits : Optional[np.ndarray]
+            The logits for the current token ids in the sequence.
+            If None, the model will call get_logits to get the logits.
+        logits_lat_ms: Optional[float]
+            The time taken to compute the logits.
+            If logits is None, the model will call get_logits to measure the time.
+        token_ids : list[int]
+            The current token ids in the sequence.
+        mask : Optional[bytes]
+            The mask to apply to the logits.
+        temperature : float
+            The temperature to apply to the logits.
+        k : int
+            The number of top-k tokens to return.
+        force_return_unmasked_probs: bool
+            If True, the top-k unmasked probabilities will be returned.
+
+        Returns
+        -------
+        EngineOutput
+            The output from the model.
+        """
+
+        if logits is None:
+            t0 = time.time()
+            try:
+                logits = self.get_logits(token_ids)
+            except NotImplementedError:
+                # fallback to orignal get_next_token method
+                _t0 = time.time()
+                token_id = self.get_next_token(
+                    token_ids=token_ids,
+                    mask=mask,
+                    temperature=temperature,
+                )
+                _lat = (time.time() - _t0) * 1000
+
+                _issued_token = GenToken(
+                    token_id=token_id,
+                    prob=1.0,
+                    text=to_utf8_or_bytes_string(self.tokenizer.decode([token_id])),
+                    latency_ms=_lat,
+                    is_generated=True,
+                )
+
+                return EngineOutput(
+                    issued_token=_issued_token,
+                    top_k=[_issued_token],
+                    masked_top_k=[_issued_token] if mask is not None else None,
+                )
+            lat_ms = (time.time() - t0) * 1000
+        else:
+            lat_ms = logits_lat_ms
+
+        def get_top_k(_probs: np.ndarray, _k: int = 5) -> list[GenToken]:
+            top_k_indices = np.argsort(_probs)[::-1][:_k]
+            top_k_probs = _probs[top_k_indices]
+
+            return [
+                GenToken(
+                    token_id=token,
+                    prob=prob,
+                    text=to_utf8_or_bytes_string(self.tokenizer.decode([token])),
+                    latency_ms=lat_ms,
+                    is_generated=True,
+                )
+                for token, prob in zip(top_k_indices, top_k_probs)
+                if prob > 0
+            ]
+
+        # compute top-k without masking
+        probs = (
+            softmax(np.array(logits))
+            if temperature < 0.0001
+            else softmax(np.array(logits) / temperature)
+        )
 
+        top_k: list[GenToken] = []
+        if force_return_unmasked_probs:
+            top_k = get_top_k(probs, k)
 
-    def get_next_token(self, token_ids: list[int], mask: Optional[bytes], temperature: float) -> int:
+        # compute top-k with masking
+        masked_top_k: list[GenToken] = []
+        if mask is not None:
+            # shift logits to [0 - max] range first and apply mask
+            masked_logits = (logits - np.min(logits)) * np.frombuffer(mask, dtype=np.uint8)
+            masked_probs = (
+                softmax(masked_logits)
+                if temperature < 0.0001
+                else softmax(masked_logits / temperature)
+            )
+            masked_top_k = get_top_k(masked_probs, k)
+
+        if temperature < 0.0001:
+            if len(masked_top_k) > 0:
+                issued_token = masked_top_k[0]
+            else:
+                if len(top_k) == 0:
+                    top_k = get_top_k(probs, k)
+                issued_token = top_k[0]
+        else:
+            # we need to sample from the probabilities
+            if mask is None:
+                sampled_index = np.random.choice(len(probs), p=probs)
+                sampled_prob = probs[sampled_index]
+            else:
+                sampled_index = np.random.choice(len(masked_probs), p=masked_probs)
+                sampled_prob = masked_probs[sampled_index]
+
+            issued_token = GenToken(
+                token_id=sampled_index,
+                prob=sampled_prob,
+                text=to_utf8_or_bytes_string(self.tokenizer.decode([sampled_index])),
+                latency_ms=lat_ms,
+                is_generated=True,
+            )
+
+        output = EngineOutput(
+            issued_token=issued_token,
+            top_k=top_k,
+            masked_top_k=None if not masked_top_k else masked_top_k,
+            is_backtracked=False,
+        )
+
+        return output
+
+    def get_next_token(
+        self, token_ids: list[int], mask: Optional[bytes], temperature: float
+    ) -> int:
         # Prefer to implement get_logits over get_next_token as it allows for concurrent mask computation
         raise NotImplementedError
 
@@ -223,13 +744,19 @@ def get_logits(self, token_ids: list[int]) -> np.ndarray:
         # Prefer to implement get_logits over get_next_token as it allows for concurrent mask computation
         raise NotImplementedError
 
-    def sample_with_temperature(self, logits: np.ndarray, mask: Optional[bytes], temperature: float) -> int:
+    def get_per_token_topk_probs(self, token_ids: list[int], top_k: int = 5) -> list[GenToken]:
+        """Get the top-k probabilities for each token in the sequence."""
+        raise NotImplementedError
+
+    def sample_with_temperature(
+        self, logits: np.ndarray, mask: Optional[bytes], temperature: float
+    ) -> int:
         if mask is not None:
             logits += np.frombuffer(mask, dtype=np.uint8)
         if temperature < 0.0001:
             return int(np.argmax(logits))
         # Get probabilities from softmax
-        probabilities = softmax(logits/temperature)
+        probabilities = softmax(logits / temperature)
         # Sample an index based on the probabilities
         sampled_index = np.random.choice(len(logits), p=probabilities)
         return sampled_index
@@ -242,6 +769,9 @@ def _report_failed_match(self, prompt):
         )
 
 
+_id_counter = 0  # Counter for identifiers, this has to be outside the model to handle child classes properly.
+
+
 class Model:
     """The base guidance model object, which represents a model in a given state.
 
@@ -253,11 +783,13 @@ class Model:
     .. automethod:: __add__
     """
 
-    open_blocks: Dict["ContextBlock", None] = {}  # track what context blocks are open
+    global_active_blocks: list["ContextBlock"] = (
+        []
+    )  # track what context blocks are globally active
+
     _grammar_only = 0  # a flag that tracks when we are forced to be executing only compiled grammars (like when we are inside a select)
-    _throttle_refresh = 0  # a flag that tracks when we can throttle our display since we know future display calls are going to happen
 
-    def __init__(self, engine, echo=True, **kwargs):
+    def __init__(self, engine, echo=True, parent_id=None, **kwargs):
         """Build a new model object that represents a model in a given state.
 
         Note that this constructor is not meant to be used directly, since there
@@ -268,6 +800,8 @@ def __init__(self, engine, echo=True, **kwargs):
             The inference engine to use for this model.
         echo : bool
             If true the final result of creating this model state will be displayed (as HTML in a notebook).
+        parent_id : int
+            Parent model's identifier.
         """
         if isinstance(engine, str) and engine.startswith("http"):
             from ._remote import RemoteEngine
@@ -279,29 +813,63 @@ def __init__(self, engine, echo=True, **kwargs):
         #     tokenizer = Tokenizer(tokenizer)
 
         self.engine = engine
-        self.chat_template = engine.get_chat_template() # TODO [HN]: Should this be a method or attr?
-
-        # HOTFIX(nopdive): Temporary until visualization overhaul is merged.
-        environment = Environment()
-        if environment.is_terminal():
-            self.echo = False
-        else:
-            self.echo = echo
-
+        self.chat_template = (
+            engine.get_chat_template()
+        )  # TODO [HN]: Should this be a method or attr?
+        # NOTE(nopdive): `echo` seems to be better on the engine, when is there an opportunity to turn echo off midway?
+        self.echo = echo
         self.token_count = 0  # tracks how many tokens our byte state represents
-        self.max_display_rate = 0.2  # this controls how frequently we are allowed to redraw the display (in seconds)
+        self.max_display_rate = (
+            0.2  # this controls how frequently we are allowed to redraw the display (in seconds)
+        )
         self.opened_blocks = {}  # what context blocks have been opened but not closed
         # self.compute_log_probs = compute_log_probs
 
         # private attributes
         self._variables = {}  # these are the state variables stored with the model
         self._variables_log_probs = {}  # these are the state variables stored with the model
+        self._variables_positions = {}  # these are the state variables stored with the model
         self._cache_state = {}  # mutable caching state used to save computation
         self._state = ""  # the current bytes that represent the state of the model
-        self._event_queue = None  # TODO: these are for streaming results in code, but that needs implemented
+        self._trace_nodes = set()  # keep trace node reference for pinning
+        self._event_queue = (
+            None  # TODO: these are for streaming results in code, but that needs implemented
+        )
         self._event_parent = None
         self._last_display = 0  # used to track the last display call to enable throttling
-        self._last_event_stream = 0  # used to track the last event streaming call to enable throttling
+        self._last_event_stream = (
+            0  # used to track the last event streaming call to enable throttling
+        )
+        self._last_event_stream = (
+            0  # used to track the last event streaming call to enable throttling
+        )
+
+        self._id = self.__class__.gen_id()  # model id needed for tracking state
+        self._parent_id = parent_id
+        self._parent: "Model" = None
+        self._update_trace_node(self._id, self._parent_id, None)
+
+        self.vis_chunk: VisBytesChunk = None
+        self.engine.model_dict[self._id] = self
+        self.metrics = GuidanceEngineMetrics()
+
+        weakref.finalize(self, log_cleanup, f"model({id(self)})")
+        log_init(f"model({id(self)})")
+
+    @property
+    def renderer(self):
+        if self.echo:
+            return self.engine.renderer
+        else:
+            return None
+
+    @classmethod
+    def gen_id(cls):
+        global _id_counter
+
+        _id = _id_counter
+        _id_counter += 1
+        return _id
 
     @property
     def active_role_end(self):
@@ -321,26 +889,18 @@ def active_role_end(self):
 
         return select(parts)
 
-    def _html(self):
-        """Generate HTML that displays the model object."""
-        display_out = self._state
-        for context in reversed(self.opened_blocks):
-            display_out += self.opened_blocks[context][1]
-        display_out = html.escape(display_out)
-        display_out = nodisp_pattern.sub("", display_out)
-        display_out = html_pattern.sub(lambda x: html.unescape(x.group(1)), display_out)
-        display_out = image_pattern.sub(
-            lambda x: '<img src="data:image/png;base64,'
-            + base64.b64encode(self[x.groups(1)[0]]).decode()
-            + '" style="max-width: 400px; vertical-align: middle; margin: 4px;">',
-            display_out,
-        )
-        display_out = (
-            "<pre style='margin: 0px; padding: 0px; vertical-align: middle; padding-left: 8px; margin-left: -8px; border-radius: 0px; border-left: 1px solid rgba(127, 127, 127, 0.2); white-space: pre-wrap; font-family: ColfaxAI, Arial; font-size: 15px; line-height: 23px;'>"
-            + display_out
-            + "</pre>"
+    def html(self):
+        """Displays model as HTML."""
+        # NOTE(nopdive): Have this public for now until all widget related issues are sorted out.
+        clear_output(wait=True)
+        display(HTML(self._html()))
+
+    def _html(self) -> str:
+        """Returns HTML string that displays the model object."""
+
+        return trace_node_to_html(
+            self.engine.trace_handler.id_node_map[self._id], hasattr(self, "indent_roles")
         )
-        return display_out
 
     def _send_to_event_queue(self, value):
         """For streaming in code.
@@ -363,10 +923,13 @@ def copy(self):
         # then copy a few things we need deeper copies of
         new_lm._variables = self._variables.copy()
         new_lm._variables_log_probs = self._variables_log_probs.copy()
+        new_lm._variables_positions = self._variables_positions.copy()
         new_lm.opened_blocks = self.opened_blocks.copy()
 
         # create a new clean event queue
-        new_lm._event_queue = None  # we start with no event queue because nobody is listening to us yet
+        new_lm._event_queue = (
+            None  # we start with no event queue because nobody is listening to us yet
+        )
 
         if self._event_queue is not None:
             # if the current lm has an event queue, we make it our parent
@@ -374,8 +937,19 @@ def copy(self):
 
         elif self._event_parent is not None:
             # otherwise if the current event que has an event parent then that is also our parent
-            new_lm._event_parent = self._event_parent  
-
+            new_lm._event_parent = self._event_parent
+
+        new_lm._id = self.__class__.gen_id()
+        new_lm._parent_id = self._id
+        new_lm._trace_nodes = set()
+        new_lm._update_trace_node(new_lm._id, new_lm._parent_id, None)
+        self.engine.model_dict[new_lm._id] = new_lm
+        new_lm.vis_chunk = None
+        new_lm._parent = self
+        new_lm.metrics = self.metrics.model_copy(deep=True)
+
+        weakref.finalize(new_lm, log_cleanup, f"model({id(self)})")
+        log_copy(f"model({id(self)})")
         return new_lm
 
     def _inplace_append(self, value, force_silent=False):
@@ -386,40 +960,18 @@ def _inplace_append(self, value, force_silent=False):
 
         Parameters
         ----------
-        value : bytes
+        value : bytes | str
             The bytes we should append to our current state.
         """
 
         # update the byte state
-        self._state += str(value)  # TODO: make _state to be bytes not a string
-
-        # see if we should update the display
-        if not force_silent:
-            self._update_display()
+        v = value
+        if not isinstance(v, str):
+            v = str(value)
+        self._state += v
 
         # this is for programmatic streaming among other things
-        if Model._throttle_refresh > 0:
-            curr_time = time.time()
-            if curr_time - self._last_event_stream >= self.max_display_rate:
-                self._last_event_stream = curr_time
-                self._send_to_event_queue(self)
-        else:
-            self._send_to_event_queue(self)
-
-    def _update_display(self, throttle=True):
-        if self.echo:
-            if Model._throttle_refresh > 0:
-                curr_time = time.time()
-                if throttle and curr_time - self._last_display < self.max_display_rate:
-                    return  # we are throttling the update
-                else:
-                    self._last_display = curr_time
-
-            if ipython_is_imported:
-                clear_output(wait=True)
-                display(HTML(self._html()))
-            else:
-                pprint(self._state)
+        self._send_to_event_queue(self)
 
     def reset(self, clear_variables=True):
         """This resets the state of the model object.
@@ -429,13 +981,40 @@ def reset(self, clear_variables=True):
         clear_variables : bool
             If we should clear all the model object's variables in addition to reseting the byte state.
         """
+        # TODO(nopdive): This violates the immutability assumption on model class for users. Remove on confirmation.
+
         self._state = self._state[:0]
         self.opened_blocks = {}
         if clear_variables:
             self._variables = {}
             self._variables_log_probs = {}
+            self._variables_positions = {}
         return self
 
+    def role_opener(self, role_name, **kwargs):
+        # TODO [HN]: Temporary change while I instrument chat_template in transformers only.
+        # Eventually have all models use chat_template.
+        if hasattr(self, "get_role_start"):
+            return self.get_role_start(role_name, **kwargs)
+        elif hasattr(self, "chat_template"):
+            return self.chat_template.get_role_start(role_name)
+        else:
+            raise Exception(
+                f"You need to use a chat model in order the use role blocks like `with {role_name}():`! Perhaps you meant to use the {type(self).__name__}Chat class?"
+            )
+
+    def role_closer(self, role_name, **kwargs):
+        # TODO [HN]: Temporary change while I instrument chat_template in transformers only.
+        # Eventually have all models use chat_template.
+        if hasattr(self, "get_role_end"):
+            return self.get_role_end(role_name, **kwargs)
+        elif hasattr(self, "chat_template"):
+            return self.chat_template.get_role_end(role_name)
+        else:
+            raise Exception(
+                f"You need to use a chat model in order the use role blocks like `with {role_name}():`! Perhaps you meant to use the {type(self).__name__}Chat class?"
+            )
+
     def _repr_html_(self):
         if ipython_is_imported:
             clear_output(wait=True)
@@ -443,14 +1022,30 @@ def _repr_html_(self):
 
     def _current_prompt(self):
         """The current prompt in bytes (which is the state without the context close tags)."""
-        return format_pattern.sub("", self._state)
+        return trace_node_to_str(self.engine.trace_handler.id_node_map[self._id])
+
+    def _update_trace_node(
+        self, identifier: int, parent_id: Optional[int], node_attr: Optional[NodeAttr]
+    ):
+        """Updates trace node that corresponds to this model."""
+
+        trace_node = self.engine.trace_handler.update_node(identifier, parent_id, node_attr)
+        self._trace_nodes.add(trace_node)
+
+        if self.renderer is not None:
+            self.renderer.update(
+                TraceMessage(
+                    trace_id=identifier,
+                    parent_trace_id=parent_id,
+                    node_attr=node_attr,
+                )
+            )
 
     def __str__(self):
         """A string representation of the current model object (that includes context closers)."""
-        out = self._current_prompt()
-        for context in reversed(self.opened_blocks):
-            out += format_pattern.sub("", self.opened_blocks[context][1])
-        return out
+
+        # TODO(nopdive): Ensure context closers or no?
+        return trace_node_to_str(self.engine.trace_handler.id_node_map[self._id])
 
     def __add__(self, value):
         """Adding is the primary mechanism for extending model state.
@@ -465,102 +1060,164 @@ def __add__(self, value):
         # (we need to do this since Model objects are immutable)
         lm = self.copy()
 
-        # inside this context we are free to drop display calls that come too close together
-        with throttle_refresh():
+        # find blocks that are now active, but haven't been opened by lm yet
+        enter_blocks = []
+        for context in Model.global_active_blocks:
+            if context not in lm.opened_blocks:
+                enter_blocks.append(context)
+                lm.opened_blocks[context] = (0, "")
+
+        # find opened blocks by lm, but are no longer active
+        exit_blocks = []
+        for context in list(reversed(lm.opened_blocks.keys())):
+            if context not in Model.global_active_blocks:
+                exit_blocks.append(context)
+
+        # finish any exiting blocks
+        for context in exit_blocks:
+            pos, close_text = lm.opened_blocks[context]
+            del lm.opened_blocks[context]
+
+            # handle variables
+            if context.name is not None:
+                # TODO(nopdive): Replace with trace traversal.
+                v = format_pattern.sub("", lm._state[pos:])
+                lm._variables[context.name] = v
+                lm._variables_positions[context.name] = pos
+                lm._update_trace_node(
+                    lm._id, lm._parent_id, CaptureOutput(name=context.name, value=v)
+                )
 
-            # find what new blocks need to be applied
-            new_blocks = []
-            for context in Model.open_blocks:
-                if context not in lm.opened_blocks:
-                    new_blocks.append(context)
+            # add closer
+            # TODO(nopdive): Consider removing context closer/opener on confirmation.
+            closer_text = context.closer if isinstance(context.closer, str) else ""
+            lm._update_trace_node(
+                lm._id, lm._parent_id, RoleCloserInput(name=context.name, text=closer_text)
+            )
+            lm += context.closer
+            lm = lm.copy()
+
+        # start any entering blocks
+        for context in enter_blocks:
+            # add opener
+            opener_text = context.opener if isinstance(context.opener, str) else ""
+            closer_text = context.closer if isinstance(context.closer, str) else ""
+
+            lm._update_trace_node(
+                lm._id,
+                lm._parent_id,
+                RoleOpenerInput(name=context.name, text=opener_text, closer_text=closer_text),
+            )
+            lm += context.opener
+            lm = lm.copy()
+
+            # store closer for state extraction later
+            # TODO(nopdive): Replace with trace traversal.
+            lm.opened_blocks[context] = (len(lm._state), closer_text)
+
+            # handle variables
+            # NOTE(nopdive): No stack for variables, this process removes shadowed variables?
+            if context.name is not None:
+                if context.name in lm._variables:
+                    del lm._variables[context.name]
+                    if context.name in lm._variables_log_probs:
+                        del lm._variables_log_probs[context.name]
+                    if context.name in lm._variables_positions:
+                        del lm._variables_positions[context.name]
+
+        if isinstance(value, TextOutput):
+            lm._inplace_append(value.value)
+            out = lm
+            out._update_trace_node(out._id, out._parent_id, value)
+        elif isinstance(value, CaptureOutput):
+            out = lm
+            out._update_trace_node(out._id, out._parent_id, value)
+        elif isinstance(value, str):
+            # wrap raw string values
 
-                    # mark this so we don't re-add when computing the opener or closer (even though we don't know the close text yet)
-                    lm.opened_blocks[context] = (0, "")
+            is_id = False
+            parts = re.split(_tag_pattern, value)
 
-            # find what old blocks need to be removed
-            old_blocks = []
-            for context in list(reversed(lm.opened_blocks)):
-                if context not in Model.open_blocks and context in lm.opened_blocks:
-                    old_blocks.append((lm.opened_blocks[context], context))
+            # we have no embedded objects
+            if len(parts) == 1:
+                lm._update_trace_node(lm._id, lm._parent_id, LiteralInput(value=value))
 
-                    # delete this so we don't re-close when computing the opener or closer
-                    del lm.opened_blocks[context]
+                lm._inplace_append(value)
+                out = lm
 
-            # close any newly closed contexts
-            for (pos, close_text), context in old_blocks:
-                if context.name is not None:
-                    lm._variables[context.name] = format_pattern.sub(
-                        "", lm._state[pos:]
+                # generate VisBytesChunk so we know this chunk is input
+                input_tokens = []
+                if self.echo:
+                    _bytes = value.encode("utf-8")
+                    _tokens = out.engine.tokenizer.encode(_bytes)
+                    out.vis_chunk = VisBytesChunk(
+                        bytes=_bytes,
+                        is_input=True,
+                        input_tokens=[
+                            GenToken(
+                                token_id=_token,
+                                prob=1.0,
+                                text=to_utf8_or_bytes_string(out.engine.tokenizer.decode([_token])),
+                                latency_ms=0,
+                                is_generated=False,
+                                is_force_forwarded=False,
+                                is_input=True,
+                            )
+                            for _token in _tokens
+                        ],
                     )
-                lm += context.closer
-
-            # apply any newly opened contexts (new from this object's perspective)
-            for context in new_blocks:
-                lm += context.opener
-                with grammar_only():
-                    tmp = lm + context.closer
-                close_text = tmp._state[len(lm._state):]  # get the new state added by calling the closer
-                lm.opened_blocks[context] = (len(lm._state), close_text)
-
-                # clear out names that we override
-                if context.name is not None:
-                    if context.name in lm._variables:
-                        del lm._variables[context.name]
-                        if context.name in lm._variables_log_probs:
-                            del lm._variables_log_probs[context.name]
+                    input_tokens = out.vis_chunk.input_tokens
 
-            # wrap raw string values
-            if isinstance(value, str):
-                is_id = False
-                parts = re.split(_tag_pattern, value)
+                out._update_trace_node(
+                    out._id,
+                    out._parent_id,
+                    TextOutput(value=value, is_input=True, tokens=input_tokens),
+                )
 
-                # we have no embedded objects
-                if len(parts) == 1:
-                    lm._inplace_append(value)
-                    out = lm
+            # if we have embedded objects we have to convert the string to a grammar tree
+            else:
+                lm._update_trace_node(lm._id, lm._parent_id, EmbeddedInput(value=value))
+
+                partial_grammar = _null_grammar
+                lm.suffix = ""
+                for i, part in enumerate(parts):
+                    if i < len(parts) - 1:
+                        lm.suffix = parts[i + 1]
+                    if is_id:
+                        call = _call_pool[part]
+                        if isinstance(call, GrammarFunction):
+                            partial_grammar += _call_pool[part]
+                        else:
+                            lm += partial_grammar
+                            lm = _call_pool[part](lm)
+                            partial_grammar = _null_grammar
+                    elif part != "":
+                        partial_grammar += string(part)
+                    is_id = not is_id
 
-                # if we have embedded objects we have to convert the string to a grammar tree
-                else:
-                    partial_grammar = _null_grammar
-                    lm.suffix = ""
-                    for i, part in enumerate(parts):
-                        if i < len(parts) - 1:
-                            lm.suffix = parts[i + 1]
-                        if is_id:
-                            call = _call_pool[part]
-                            if isinstance(call, GrammarFunction):
-                                partial_grammar += _call_pool[part]
-                            else:
-                                lm += partial_grammar
-                                lm = _call_pool[part](lm)
-                                partial_grammar = _null_grammar
-                        elif part != "":
-                            partial_grammar += string(part)
-                        is_id = not is_id
-                    out = lm + partial_grammar
-
-            # if we find a null value we do nothing
-            elif isinstance(value, Null):
-                out = lm
+                out = lm + partial_grammar
 
-            # run stateless functions (grammar nodes)
-            elif isinstance(value, GrammarFunction):
-                out = lm._run_stateless(value)
+        # if we find a null value we do nothing
+        elif isinstance(value, Null):
+            out = lm
 
-            # run stateful functions
-            else:
-                out = value(lm)
-                if out is None:
-                    raise Exception(
-                        f"A guidance function returned `None`, not a model object! Did you forget to return the new lm at the end of your function?"
-                    )
-                if not isinstance(out, Model):
-                    raise Exception(
-                        f"A guidance function did not return a model object! Did you try to add a function to a model without calling the function? For example `model + guidance_function()` is correct, while `model + guidance_function` will cause this error."
-                    )
+        # run stateless functions (grammar nodes)
+        elif isinstance(value, GrammarFunction):
+            lm._update_trace_node(lm._id, lm._parent_id, StatelessGuidanceInput(value=value))
+            out = lm._run_stateless(value)
 
-        # this flushes the display
-        out._inplace_append("")
+        # run stateful functions
+        else:
+            lm._update_trace_node(lm._id, lm._parent_id, StatefulGuidanceInput(value=value))
+            out = value(lm)
+            if out is None:
+                raise Exception(
+                    f"A guidance function returned `None`, not a model object! Did you forget to return the new lm at the end of your function?"
+                )
+            if not isinstance(out, Model):
+                raise Exception(
+                    f"A guidance function did not return a model object! Did you try to add a function to a model without calling the function? For example `model + guidance_function()` is correct, while `model + guidance_function` will cause this error."
+                )
 
         return out
 
@@ -588,9 +1245,7 @@ def __getitem__(self, key):
         else:
             for context in list(reversed(self.opened_blocks)):
                 if context.name == key:
-                    return format_pattern.sub(
-                        "", self._state[self.opened_blocks[context][0] :]
-                    )
+                    return format_pattern.sub("", self._state[self.opened_blocks[context][0] :])
 
         raise KeyError(f"Model does not contain the variable '{key}'")
 
@@ -739,10 +1394,13 @@ def _run_stateless(self, stateless_function, temperature=0.0, top_p=1.0, n=1):
         replacements = replace_model_variables(stateless_function, self)
 
         # start the generation stream
-        gen_obj = self.engine(self._current_prompt(), stateless_function)
+        gen_obj = self.engine(self._current_prompt(), stateless_function, echo=self.echo)
 
         # we will return a new extended version of ourselves, which we track as `lm`
         lm = self
+        lm.engine.metrics.engine_backtrack_tokens = lm.metrics.engine_backtrack_tokens
+        lm.engine.metrics.engine_input_tokens = lm.metrics.engine_input_tokens
+        lm.engine.metrics.engine_output_tokens = lm.metrics.engine_output_tokens
 
         # single generation
         if n == 1:
@@ -751,6 +1409,7 @@ def _run_stateless(self, stateless_function, temperature=0.0, top_p=1.0, n=1):
 
             delayed_bytes = b""
             # last_is_generated = False
+
             for chunk in gen_obj:
 
                 # we make everything full probability if we are not computing uncertainty
@@ -767,16 +1426,43 @@ def _run_stateless(self, stateless_function, temperature=0.0, top_p=1.0, n=1):
                     continue
                 delayed_bytes = b""
 
+                if chunk.backtrack:
+                    lm.engine.metrics.engine_backtrack_tokens += chunk.backtrack
+
                 if len(chunk.new_bytes) > 0:
                     generated_value += new_text
-                    if chunk.is_generated:
-                        lm += f"<||_html:<span style='background-color: rgba({165*(1-chunk.new_bytes_prob) + 0}, {165*chunk.new_bytes_prob + 0}, 0, {0.15}); border-radius: 3px;' title='{chunk.new_bytes_prob}'>_||>"
-                    lm += new_text
-                    if chunk.is_generated:
-                        lm += "<||_html:</span>_||>"
 
-                # last_is_generated = chunk.is_generated
+                    # split chunk into generated and force_forwarded parts for better animated visualization
+                    if chunk.generated_bytes:
+                        lm += TextOutput(
+                            value=chunk.generated_bytes.decode("utf8"),
+                            is_generated=True,
+                            token_count=0,
+                            prob=0.0,
+                            tokens=chunk.generated_tokens,
+                        )
+
+                    if chunk.force_forwarded_bytes:
+                        lm += TextOutput(
+                            value=chunk.force_forwarded_bytes.decode("utf8"),
+                            is_force_forwarded=True,
+                            token_count=0,
+                            prob=0.0,
+                            tokens=chunk.force_forwarded_tokens,
+                        )
+
+                if self.echo:
+                    lm.vis_chunk = VisBytesChunk(
+                        bytes=chunk.new_bytes,
+                        is_input=False,
+                        # generated_bytes=chunk.generated_bytes,
+                        generated_tokens=chunk.generated_tokens,
+                        force_forwarded_tokens=chunk.force_forwarded_tokens,
+                        backtrack=chunk.backtrack,
+                        engine_outputs=chunk.engine_outputs,
+                    )
 
+                # last_is_generated = chunk.is_generated
                 if len(chunk.capture_groups) > 0:
                     for k in chunk.capture_groups:
                         v = chunk.capture_groups[k]
@@ -797,13 +1483,24 @@ def _run_stateless(self, stateless_function, temperature=0.0, top_p=1.0, n=1):
 
                                 if k not in lm or not isinstance(lm._variables[k], list):
                                     lm._variables[k] = []
-                                if k not in lm._variables_log_probs or not isinstance(lm._variables_log_probs[k], list):
+                                    lm += CaptureOutput(name=k)
+                                if k not in lm._variables_log_probs or not isinstance(
+                                    lm._variables_log_probs[k], list
+                                ):
                                     lm._variables_log_probs[k] = []
-                                    
+                                if k not in lm._variables_positions:
+                                    lm._variables_positions[k] = len(lm._state)
+
                                 lm._variables[k].append(inner_v)
                                 lm._variables_log_probs[k].append(
                                     chunk.capture_group_log_probs[k][i]
                                 )
+                                lm += CaptureOutput(
+                                    name=k,
+                                    value=inner_v,
+                                    is_append=True,
+                                    log_probs=lm._variables_log_probs[k][i],
+                                )
 
                         # ...or standard assignment mode
                         else:
@@ -813,8 +1510,15 @@ def _run_stateless(self, stateless_function, temperature=0.0, top_p=1.0, n=1):
                                 v = v.decode("utf8") if isinstance(v, bytes) else v
                             except UnicodeDecodeError:
                                 pass
+
                             lm._variables[k] = v
+                            lm._variables_positions[k] = len(lm._state) - len(v)
                             lm._variables_log_probs[k] = chunk.capture_group_log_probs[k]
+                            lm += CaptureOutput(
+                                name=k,
+                                value=v,
+                                log_probs=chunk.capture_group_log_probs[k],
+                            )
 
             # if len(chunk.capture_groups) > 0:
             #     for k in chunk.capture_groups:
@@ -825,8 +1529,346 @@ def _run_stateless(self, stateless_function, temperature=0.0, top_p=1.0, n=1):
 
         logger.debug("finish Model._run_stateless")
 
+        lm.metrics = lm.engine.metrics.model_copy(deep=True)
+
         return lm
 
+    def get_per_token_stats(self) -> list[GenTokenExtra]:
+        """Get the per token stats (prob, top-k, latency, etc.) for the model.
+
+        Returns
+            List[GenTokenExtra]: a list of GenToken objects.
+        """
+
+        paths = []
+        model = self
+        while model is not None:
+            paths.append(model)
+            if model._parent_id is None:
+                break
+            model: "Model" = self.engine.model_dict[model._parent_id]
+        paths.reverse()
+
+        vis_chunks: list[VisBytesChunk] = [
+            path.vis_chunk for path in paths if path.vis_chunk is not None
+        ]
+
+        gen_tokens_infos: list[tuple[int, float, list[GenToken]]] = []
+        gen_tokens_indices: list[int] = []
+        for vis_chunk in vis_chunks:
+            for engine_output in vis_chunk.engine_outputs:
+                gen_tokens_infos.append(
+                    (
+                        engine_output.issued_token.token_id,
+                        engine_output.issued_token.latency_ms,
+                        engine_output.masked_top_k,
+                    )
+                )
+            gen_tokens_indices.append(len(gen_tokens_infos) - 1)
+
+        text = self._state
+        token_ids = self.engine.tokenizer.encode(text.encode("utf-8"))
+
+        # verify if text == encode(decode(text))
+        # decoded_text = self.engine.tokenizer.decode(token_ids).decode("utf-8")
+        decoded_text = "".join(self.engine.tokenizer.decode([_token]).decode("utf-8") for _token in token_ids)
+
+        token_texts: list[str] = []
+        if text == decoded_text:
+            for idx, token_id in enumerate(token_ids):
+                token_texts.append(self.engine.tokenizer.decode([token_id]).decode("utf-8"))
+        else:
+            # Some models like phi-3 removes spaces and line breaks
+            # Scan through the text and find the missing chunks so we can map the token back into generated chunks by the parser later on
+            ptr_idx = 0
+            for _idx, token_id in enumerate(token_ids):
+                missing_chunk = ""
+                decoded = self.engine.tokenizer.decode([token_id]).decode("utf-8")
+                if not text[ptr_idx:].startswith(decoded):
+                    _next_idx = ptr_idx
+                    found = False
+                    while _next_idx < len(text):
+                        if text[_next_idx:].startswith(decoded):
+                            found = True
+                            break
+                        _next_idx += 1
+
+                    assert found, f"Failed to find the token {decoded} in the text {text}"
+                    missing_chunk = text[ptr_idx:_next_idx]
+
+                token_texts.append(missing_chunk + decoded)
+                ptr_idx += len(missing_chunk + decoded)
+
+            # verify
+            _decoded_text = "".join(token_texts)
+            assert _decoded_text in text, f"Failed to decode the text {text} into {_decoded_text}"
+            if _decoded_text in text and len(_decoded_text) < len(text):
+                # there are some missing chunks (probably empty spaces/ end lines removed by the tokenizer)
+                missing_chunk = text[len(_decoded_text):]
+                token_texts[-1] += missing_chunk
+
+        # NOTE (loc): Not all engines support the get_logits method
+        try:
+            # make sure token_ids start with BOS token if needed
+            prev_token_ids_len = len(token_ids)
+            if (
+                len(token_ids) > 0
+                and self.engine.tokenizer.bos_token_id != None
+                and token_ids[0] != self.engine.tokenizer.bos_token_id
+            ):
+                token_ids = [self.engine.tokenizer.bos_token_id] + token_ids
+
+            tokens_with_topk = self.engine.get_per_token_topk_probs(token_ids, top_k=self.engine._top_k)
+
+            # remove the BOS token
+            if prev_token_ids_len != len(token_ids):
+                token_ids = token_ids[1:]
+                tokens_with_topk = tokens_with_topk[1:]
+
+        except Exception as e:
+            logger.warning(
+                f"Failed to get the top k probabilities for the tokens {token_ids}. Error: {e}"
+            )
+            # FIXME (loc): assume prob 1.0 for all tokens
+            tokens_with_topk = []
+            for token_id, token_text in zip(token_ids, token_texts):
+                tokens_with_topk.append(
+                    GenTokenExtra(
+                        token_id=token_id,
+                        prob=1.0,
+                        text=token_text,
+                        top_k=[
+                            GenToken(token_id=token_id, prob=1.0, text=token_text),
+                        ],
+                    )
+                )
+
+        start_idx = 0
+        end_idx = 1
+        start_pos = 0
+        remainder = ""
+
+        processed_gen_tokens: list[GenTokenExtra] = []
+        # Map token back to generated chunk to extract correct info (is_generated, latency, etc.)
+        for vis_chunk_idx, vis_chunk in enumerate(vis_chunks):
+            vis_text = vis_chunk.bytes.decode("utf-8")
+
+            if not vis_text:
+                continue
+
+            # Find the chunk starting at start_idx that contains the vis_text
+            end_idx = start_idx
+            _chunk = "".join(token_texts[start_idx : end_idx + 1])
+            while vis_text not in _chunk and end_idx < len(token_texts):
+                # expand the chunk
+                end_idx += 1
+                _chunk = "".join(token_texts[start_idx : end_idx + 1])
+
+            if vis_text not in _chunk and end_idx >= len(token_texts):
+                # failed = True
+                # break
+                raise Exception(f"Failed to find the {vis_text} in the tokens chunk {_chunk}")
+
+            if vis_text == _chunk:
+                # perfect match
+                pass
+            else:
+                start_pos = _chunk.index(vis_text)
+                remainder = _chunk[start_pos + len(vis_text) :]
+
+            if remainder:
+                # we have a current chunk that is larger than the vis_text
+                # probably the last token is a partial token that spans across two chunks due to backtracking
+                # we should not issue that token for now
+                end_idx -= 1
+
+            _chunk_token_ids = token_ids[start_idx : end_idx + 1]
+            _chunk_tokens_with_topk = tokens_with_topk[start_idx : end_idx + 1]
+            _chunk_token_texts = token_texts[start_idx : end_idx + 1]
+
+            is_input = len(vis_chunk.input_tokens) > 0
+            is_force_forwarded = len(vis_chunk.force_forwarded_tokens) > 0
+
+            _gen_tokens: list[GenTokenExtra] = []
+            for token_id, token_info_with_topk, token_text in zip(
+                _chunk_token_ids, _chunk_tokens_with_topk, _chunk_token_texts
+            ):
+                prob = -1
+                for _token in token_info_with_topk.top_k:
+                    if _token.token_id == token_id:
+                        prob = _token.prob
+                        break
+
+                _gen_token = GenTokenExtra(
+                    token_id=token_id,
+                    prob=prob,
+                    text=token_text,
+                    latency_ms=0,
+                    is_input=is_input,
+                    is_generated=False,
+                    is_force_forwarded=False,
+                )
+                _gen_token.top_k = token_info_with_topk.top_k
+                _gen_tokens.append(_gen_token)
+
+            for i, _gen_token in enumerate(_gen_tokens):
+                if not is_input:
+                    if i < len(vis_chunk.generated_tokens):
+                        _gen_token.is_generated = True
+                    else:
+                        if is_force_forwarded:
+                            _gen_token.is_force_forwarded = True
+
+                    # Start from the end of current chunk
+                    # go backwards to find the match between token and associated text string
+                    found_perfect_match = False
+                    max_idx = gen_tokens_indices[vis_chunk_idx]
+                    for idx in range(max_idx, -1, -1):
+                        if _gen_token.token_id == gen_tokens_infos[idx][0]:
+                            _gen_token.latency_ms = gen_tokens_infos[idx][1]
+                            _masked_top_k = gen_tokens_infos[idx][2]
+
+                            # if we find a match in tokens list generated by the engine, then this token should be marked as generated
+                            _gen_token.is_generated = True
+                            _gen_token.is_force_forwarded = False
+
+                            if _masked_top_k is None:
+                                # in free accepting state, no masking
+                                for _token in _gen_token.top_k:
+                                    _token.is_masked = False
+                            else:
+                                _masked_tokens = [token.token_id for token in _masked_top_k]
+                                for _token in _gen_token.top_k:
+                                    if _token.token_id not in _masked_tokens:
+                                        _token.is_masked = True
+                                    else:
+                                        _token.is_masked = False
+
+                            found_perfect_match = True
+                            break
+
+                    # NOTE (loc): There are cases that the generated token and issued token are not matched
+                    # for example, the engine may issue token "pl" but the parser decides to generate token "plate" due to the constraints
+                    # To mitigate the issue, we narrow down the search space to find the text that may contain the generated token
+                    if not found_perfect_match:
+                        # only search within this chunk
+                        max_idx = gen_tokens_indices[vis_chunk_idx]
+                        prev_max_idx = (
+                            -1 if vis_chunk_idx == 0 else gen_tokens_indices[vis_chunk_idx - 1] - 1
+                        )
+                        for idx in range(max_idx, prev_max_idx, -1):
+                            if (
+                                self.engine.tokenizer.decode([gen_tokens_infos[idx][0]]).decode(
+                                    "utf-8"
+                                )
+                                in _gen_token.text
+                            ):
+                                _gen_token.latency_ms = gen_tokens_infos[idx][1]
+                                _masked_top_k = gen_tokens_infos[idx][2]
+
+                                # if we find a match in tokens list generated by the engine, then this token should be marked as generated
+                                _gen_token.is_generated = True
+                                _gen_token.is_force_forwarded = False
+
+                                if _masked_top_k is None:
+                                    # in free accepting state, no masking
+                                    for _token in _gen_token.top_k:
+                                        _token.is_masked = False
+                                else:
+                                    _masked_tokens = [token.token_id for token in _masked_top_k]
+                                    for _token in _gen_token.top_k:
+                                        if (
+                                            _token.token_id not in _masked_tokens
+                                            and _token.token_id != _gen_token.token_id
+                                        ):
+                                            _token.is_masked = True
+                                        else:
+                                            _token.is_masked = False
+
+                                break
+                else:
+                    # input tokens are not masked
+                    for _token in _gen_token.top_k:
+                        _token.is_masked = False
+
+            for _gen_token in _gen_tokens:
+                if _gen_token.text != "":
+                    processed_gen_tokens.append(_gen_token)
+
+            start_idx = end_idx + 1
+
+            start_pos = 0
+            remainder = ""
+
+        if not self._variables:
+            return processed_gen_tokens
+        
+        def find_start_and_end_positions(chunk: str, start_idx: int, end_idx: int) -> tuple[int, int]:
+            s = "".join(gen_token.text for gen_token in processed_gen_tokens[start_idx:end_idx+1])
+            if chunk not in s:
+                # chunk is not in the string
+                return (-1, -1)
+            
+            i = start_idx + (end_idx - start_idx) // 2
+            traversed = []
+            while True:
+                if i in traversed:
+                    break
+
+                s = "".join(gen_token.text for gen_token in processed_gen_tokens[i:end_idx+1])
+                traversed.append(i)
+
+                if chunk in s:
+                    start_idx = i
+                    # shift the start position to the right
+                    i += (end_idx - i) // 2
+                else:
+                    # shift the start position to the left
+                    i -= (i - start_idx) // 2
+
+            j = end_idx
+            traversed = []
+            while True:
+                if j in traversed:
+                    break
+
+                s = "".join(gen_token.text for gen_token in processed_gen_tokens[start_idx:j+1])
+                traversed.append(j)
+
+                if chunk in s:
+                    end_idx = j
+                    # shift the end position to the left
+                    j -= (j - start_idx) // 2
+                else:
+                    # shift the end position to the right
+                    j += (end_idx - j) // 2
+
+            return (start_idx, end_idx)
+
+        if self.engine.compute_log_probs:
+            for k in self._variables:
+                try:
+                    chunk = self._variables[k]
+                    chunk_start_pos = self._variables_positions[k]
+                    # find the start of this capture in case we have multiple similar captures
+                    _, start_idx = find_start_and_end_positions(self._state[:chunk_start_pos+1], 0, len(processed_gen_tokens)-1)
+                    start_idx, end_idx = find_start_and_end_positions(chunk, start_idx, len(processed_gen_tokens)-1)
+                    if start_idx == -1:
+                        continue
+
+                    self._variables_log_probs[k] = [
+                        {
+                            "token": token.text,
+                            "token_id": token.token_id,
+                            "logprob": np.log(token.prob).item()
+                        }
+                        for token in processed_gen_tokens[start_idx:end_idx+1]
+                    ]
+                except:
+                    pass
+
+        return processed_gen_tokens
+
 
 class ModelStream:
     def __init__(self, model, grammar=None, timeout=5):
@@ -907,10 +1949,7 @@ def get_role_start(self, role_name, **kwargs):
             This kwargs are added to the role start as arguments.
         """
         return (
-            "<|im_start|>"
-            + role_name
-            + "".join([f' {k}="{v}"' for k, v in kwargs.items()])
-            + "\n"
+            "<|im_start|>" + role_name + "".join([f' {k}="{v}"' for k, v in kwargs.items()]) + "\n"
         )
 
     def get_role_end(self, role_name=None):
@@ -951,21 +1990,206 @@ def grammar_only():
     return GrammarOnly()
 
 
-class ThrottleRefresh:
-    def __enter__(self):
-        Model._throttle_refresh += 1
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        Model._throttle_refresh -= 1
-
-
-def throttle_refresh():
-    """Returns a context manager that allows the print statement to drop display calls above the throttle rate."""
-    return ThrottleRefresh()
-
-
 class ConstraintException(Exception):
     def __init__(self, *args, **kwargs):
         self.prompt = kwargs.pop("prompt", None)
         self.data = kwargs.pop("data", None)
         super().__init__(*args, **kwargs)
+
+
+class MonitoringMetric(str, Enum):
+    CPU_USAGE = "cpu_usage"
+    MEM_USAGE = "mem_usage"
+    GPU_USAGE = "gpu_usage"
+    GPU_USED_MEM = "gpu_used_mem"
+    GPU_TOTAL_MEM = "gpu_total_mem"
+    INPUT_TOKENS = "input_tokens"
+    OUTPUT_TOKENS = "output_tokens"
+    BACKTRACK_TOKENS = "backtrack_tokens"
+    TOKEN_COUNT = "token_count"
+    TOKEN_REDUCTION = "token_reduction"
+    AVG_LATENCY = "avg_latency"
+
+
+ALL_METRICS = [
+    MonitoringMetric.CPU_USAGE,
+    MonitoringMetric.MEM_USAGE,
+    MonitoringMetric.GPU_USAGE,
+    MonitoringMetric.GPU_USED_MEM,
+    MonitoringMetric.GPU_TOTAL_MEM,
+    MonitoringMetric.INPUT_TOKENS,
+    MonitoringMetric.OUTPUT_TOKENS,
+    MonitoringMetric.BACKTRACK_TOKENS,
+    MonitoringMetric.TOKEN_COUNT,
+    MonitoringMetric.TOKEN_REDUCTION,
+    MonitoringMetric.AVG_LATENCY,
+]
+
+
+def _monitor_fn(
+    stop_flag,
+    metrics_dict: dict[MonitoringMetric, list],
+    max_size: int = 100,
+    interval_ms: float = 1000,
+):
+    # print("Monitoring started")
+
+    to_collect_gpu_stats = False
+    has_gpustat = False
+    try:
+        import gpustat
+
+        has_gpustat = True
+    except:
+        logger.warning("gpustat is not installed, run `pip install gpustat` to collect GPU stats.")
+
+    if has_gpustat:
+        try:
+            gpu_stats = gpustat.GPUStatCollection.new_query()
+            if len(gpu_stats) > 0:
+                # only collect GPU stats if there is at least one GPU
+                to_collect_gpu_stats = True
+        except:
+            logger.warning("Non-Nvidia GPU monitoring is not supported in this version.")
+
+    try:
+        while not stop_flag.value:
+            t0 = time.time()
+
+            # cpu_percent = psutil.cpu_percent(interval=1)
+            cpu_percent = psutil.cpu_percent()
+            memory_usage = psutil.virtual_memory()
+
+            metrics_dict[MonitoringMetric.CPU_USAGE].append(cpu_percent)
+            metrics_dict[MonitoringMetric.MEM_USAGE].append(memory_usage.percent)
+
+            if to_collect_gpu_stats:
+                gpu_stats = gpustat.GPUStatCollection.new_query()
+
+                usage = [gpu.utilization for gpu in gpu_stats.gpus]
+                mem_usage = [gpu.memory_used for gpu in gpu_stats.gpus]
+                mem_total = [gpu.memory_total for gpu in gpu_stats.gpus]
+
+                metrics_dict[MonitoringMetric.GPU_USAGE].append(usage)
+                metrics_dict[MonitoringMetric.GPU_USED_MEM].append(mem_usage)
+                metrics_dict[MonitoringMetric.GPU_TOTAL_MEM].append(mem_total)
+
+            for metrics in metrics_dict.values():
+                if len(metrics) > max_size:
+                    metrics.pop(0)
+
+            lat = time.time() - t0
+
+            # sleep for the remaining time of the interval
+            sleep_time = interval_ms / 1000.0 - lat
+            if sleep_time < 0:
+                time.sleep(sleep_time)
+    except Exception as e:
+        # print(f"Error in monitoring: {e}")
+        pass
+
+    # print("Monitoring stopped")
+
+
+class Monitor:
+    """Monitoring service to collect necessary metrics for visualization"""
+
+    def __init__(self, engine_metrics: GuidanceEngineMetrics, **kwargs):
+        self.engine_metrics = engine_metrics
+        self.mp_manager = Manager()
+
+        # use list instead of queue for easily accessing each item, e.g., last item
+        self.max_size = kwargs.get("max_size", 100)
+
+        self.metrics_dict = {
+            MonitoringMetric.CPU_USAGE: self.mp_manager.list(),
+            MonitoringMetric.MEM_USAGE: self.mp_manager.list(),
+            MonitoringMetric.GPU_USAGE: self.mp_manager.list(),
+            MonitoringMetric.GPU_USED_MEM: self.mp_manager.list(),
+            MonitoringMetric.GPU_TOTAL_MEM: self.mp_manager.list(),
+        }
+
+        self.stop_flag = self.mp_manager.Value("b", False)
+        self.process = None
+
+        self.per_token_metrics = []  # store metrics per token in token list
+
+    def start(self):
+        self.process = Process(
+            target=_monitor_fn, args=(self.stop_flag, self.metrics_dict, self.max_size)
+        )
+        self.process.start()
+        logger.debug("Monitor:start")
+
+    def stop(self):
+        if self.process:
+            self.stop_flag.value = True
+            self.process.terminate()
+
+            for metrics in self.metrics_dict.values():
+                metrics[:] = []  # NOTE(nopdive): ListProxy does not have .clear method.
+        logger.debug("Monitor:stop")
+
+    def reset(self):
+        self.stop()
+
+        for metrics in self.metrics_dict.values():
+            metrics.clear()
+
+        self.start()
+        logger.debug("Monitor:reset")
+
+    def get_metrics(
+        self, metrics=None, lm: Union[Model, None] = None
+    ) -> dict[MonitoringMetric, Any]:
+        if metrics is None:
+            metrics = ALL_METRICS
+        result = {}
+
+        for metric in metrics:
+            if metric in [
+                MonitoringMetric.CPU_USAGE,
+                MonitoringMetric.MEM_USAGE,
+                MonitoringMetric.GPU_USAGE,
+                MonitoringMetric.GPU_USED_MEM,
+                MonitoringMetric.GPU_TOTAL_MEM,
+            ]:
+                result[metric] = (
+                    self.metrics_dict[metric][-1] if len(self.metrics_dict[metric]) > 0 else None
+                )
+            elif metric == MonitoringMetric.INPUT_TOKENS:
+                result[metric] = self.engine_metrics.engine_input_tokens
+            elif metric == MonitoringMetric.OUTPUT_TOKENS:
+                result[metric] = self.engine_metrics.engine_output_tokens
+            elif metric == MonitoringMetric.BACKTRACK_TOKENS:
+                result[metric] = self.engine_metrics.engine_backtrack_tokens
+            elif metric == MonitoringMetric.TOKEN_COUNT:
+                result[metric] = lm.token_count if lm is not None else None
+            elif metric == MonitoringMetric.TOKEN_REDUCTION:
+                if lm is not None and lm.token_count > 0:
+                    result[metric] = 1 - min(1, (lm.metrics.engine_output_tokens / lm.token_count))
+                else:
+                    result[metric] = None
+            elif metric == MonitoringMetric.AVG_LATENCY:
+                if lm is None:
+                    result[metric] = None
+                else:
+                    lats = []
+                    model = lm
+                    while model._parent is not None:
+                        if model.vis_chunk:
+                            for token in model.vis_chunk.generated_tokens:
+                                lats.append(token.latency_ms)
+                            for token in model.vis_chunk.force_forwarded_tokens:
+                                lats.append(token.latency_ms)
+                        model = model._parent
+
+                    if len(lats) == 0:
+                        result[metric] = None
+                    else:
+                        result[metric] = np.mean(lats)
+
+        return result
+
+    def get_metric(self, metric: MonitoringMetric, lm: Union[Model, None] = None) -> Any:
+        return self.get_metrics([metric], lm)[metric]
diff --git a/guidance/models/_remote.py b/guidance/models/_remote.py
index 86db8fcc5..973e8e7b6 100644
--- a/guidance/models/_remote.py
+++ b/guidance/models/_remote.py
@@ -29,7 +29,7 @@ def __init__(self, server_url, api_key, tokenizer=None, verify=None):
         # build the Engine
         super().__init__(tokenizer=tokenizer, compute_log_probs=False)
 
-    def __call__(self, parser, grammar, ensure_bos_token=True):
+    def __call__(self, parser, grammar, ensure_bos_token=True, echo: bool = False):
         # Prepare the request data
         data = {
             "parser": parser,
diff --git a/guidance/models/llama_cpp/_llama_cpp.py b/guidance/models/llama_cpp/_llama_cpp.py
index 3e0b7aa85..d243360f8 100644
--- a/guidance/models/llama_cpp/_llama_cpp.py
+++ b/guidance/models/llama_cpp/_llama_cpp.py
@@ -11,10 +11,12 @@
 
 import numpy as np
 
+from guidance._schema import GenToken, GenTokenExtra
+
 from .._model import Engine, Model, Chat
 from .._remote import RemoteEngine
 from .._tokenizer import Tokenizer
-from ..._utils import normalize_notebook_stdout_stderr
+from ..._utils import normalize_notebook_stdout_stderr, softmax
 
 try:
     import llama_cpp
@@ -100,7 +102,14 @@ def encode(self, byte_string: bytes) -> list[int]:
 class LlamaCppEngine(Engine):
     """The core class that runs inference using llama.cpp."""
 
-    def __init__(self, model, compute_log_probs, chat_template=None, enable_backtrack=True, enable_ff_tokens=True, **kwargs):
+    def __init__(self, 
+                 model, 
+                 compute_log_probs, 
+                 chat_template=None, 
+                 enable_backtrack=True, 
+                 enable_ff_tokens=True, 
+                 enable_monitoring=True, 
+                 **kwargs):
         if not is_llama_cpp:
             raise Exception(
                 "Please install llama-cpp-python with `pip install llama-cpp-python` in order to use guidance.models.LlamaCpp!"
@@ -151,6 +160,8 @@ def __init__(self, model, compute_log_probs, chat_template=None, enable_backtrac
             compute_log_probs=compute_log_probs,
             enable_backtrack=enable_backtrack,
             enable_ff_tokens=enable_ff_tokens,
+            enable_monitoring=enable_monitoring,
+            **kwargs,
         )
 
         self._n_vocab = len(self.tokenizer.tokens)
@@ -219,6 +230,112 @@ def get_logits(self, token_ids):
 
         return logits
 
+    def get_per_token_topk_probs(self, token_ids: list[int], top_k: int = 5) -> list[GenTokenExtra]:
+        if len(token_ids) == 0:
+            return []
+
+        # clear kv-cache
+        llama_cpp.llama_kv_cache_seq_rm(self.model_obj.ctx, -1, 0, -1)
+
+        # create new context
+        context = self._context
+        n_batch = self.model_obj.n_batch
+        batch = context.batch
+
+        logits_batch = []
+        for i in range(0, len(token_ids), n_batch):
+            n_tokens = min(i + n_batch, len(token_ids)) - i
+            batch.n_tokens = n_tokens
+
+            for j in range(n_tokens):
+                batch.token[j] = token_ids[i + j]
+                batch.pos[j] = i + j
+                batch.seq_id[j][0] = 0
+                batch.n_seq_id[j] = 1
+                batch.logits[j] = True
+
+            ret = llama_cpp.llama_decode(self.model_obj.ctx, batch)
+            if ret != 0:
+                raise Exception(f"Call to llama_cpp.llama_decode returned {ret}.")
+
+            # get all the logits
+            if llama_cpp.__version__ < "0.2.58":
+                logits = llama_cpp.llama_get_logits(self.model_obj.ctx)
+                logits = logits.reshape((-1, self._n_vocab))
+                logits_batch.extend(logits)
+            else:
+                for j in range(n_tokens):
+                    logits = llama_cpp.llama_get_logits_ith(self.model_obj.ctx, j)
+                    logits = np.ctypeslib.as_array(logits, shape=(self._n_vocab,)).copy()
+                    logits_batch.append(logits)
+
+        # process each token's logits
+        text_sequence = []
+
+        # add 1st token
+        _bytes = self.tokenizer.decode([token_ids[0]])
+        try:
+            _text = _bytes.decode("utf-8")
+        except Exception as e:
+            _text = str(_bytes)
+            print(f"Failed to decode token: {token_ids[0]}, error: {e}, _bytes: {str(_bytes)}")
+        text_sequence.append(
+            GenTokenExtra(
+                token_id=token_ids[0],
+                prob=1.0,
+                text=_text,
+                top_k=[GenToken(token_id=token_ids[0], prob=1.0, text=_text)],
+            )
+        )
+
+        for token_id, logits in zip(token_ids[1:], logits_batch[:-1]):
+            _probs = softmax(logits)
+
+            # get the top k indices
+            top_k_ids, top_k_probs = self._get_top_k(_probs.copy(), top_k, ascending=False)
+            if token_id not in top_k_ids:
+                top_k_ids = np.append(top_k_ids, token_id)
+                top_k_probs = np.append(top_k_probs, _probs[token_id])
+
+            top_k_list = []
+            for _token_id, _prob in zip(top_k_ids, top_k_probs):
+                _text = ""
+                try:
+                    _text = self.tokenizer.decode([_token_id]).decode("utf-8")
+                except Exception as e:
+                    _bytes = self.tokenizer.decode([_token_id])
+                    _text = str(_bytes)
+                    print(
+                        f"Failed to decode token: {_token_id}, error: {e}, _bytes: {str(_bytes)}"
+                    )
+                top_k_list.append(GenToken(token_id=_token_id, prob=_prob, text=_text))
+
+            text_sequence.append(
+                GenTokenExtra(
+                    token_id=token_id,
+                    prob=_probs[token_id],
+                    text=self.tokenizer.decode([token_id]).decode("utf-8"),
+                    top_k=top_k_list,
+                )
+            )
+
+        return text_sequence
+
+    def _get_top_k(self, probs: np.ndarray, k: int, axis: int = None, ascending: bool = True):
+        if not ascending:
+            probs *= -1
+        ind = np.argpartition(probs, k, axis=axis)
+        ind = np.take(ind, np.arange(k), axis=axis)  # k non-sorted indices
+        probs = np.take_along_axis(probs, ind, axis=axis)  # k non-sorted values
+
+        # sort within k elements
+        ind_part = np.argsort(probs, axis=axis)
+        ind = np.take_along_axis(ind, ind_part, axis=axis)
+        if not ascending:
+            probs *= -1
+        val = np.take_along_axis(probs, ind_part, axis=axis)
+        return ind, val
+
 
 class LlamaCpp(Model):
     def __init__(
@@ -230,6 +347,7 @@ def __init__(
         chat_template=None,
         enable_backtrack=True,
         enable_ff_tokens=True,
+        enable_monitoring=True,
         **llama_cpp_kwargs,
     ):
         """Build a new LlamaCpp model object that represents a model in a given state."""
@@ -243,6 +361,7 @@ def __init__(
                 chat_template=chat_template,
                 enable_backtrack=enable_backtrack,
                 enable_ff_tokens=enable_ff_tokens,
+                enable_monitoring=enable_monitoring,
                 **llama_cpp_kwargs,
             )
 
diff --git a/guidance/models/transformers/_transformers.py b/guidance/models/transformers/_transformers.py
index 3afd0be70..19b73a038 100644
--- a/guidance/models/transformers/_transformers.py
+++ b/guidance/models/transformers/_transformers.py
@@ -5,6 +5,8 @@
 
 from typing import Sequence, Union
 
+from guidance._schema import GenToken, GenTokenExtra
+
 try:
     import torch
 except ModuleNotFoundError:
@@ -35,12 +37,15 @@
     "trust_remote_code",
 ]
 
+
 class ByteDecoderError(Exception):
     pass
 
+
 class ByteTokensError(Exception):
     pass
 
+
 class TransformersTokenizer(Tokenizer):
     def __init__(
         self,
@@ -104,10 +109,14 @@ def _tokenizer(self, model: str, **kwargs) -> tuple[
             raise
         except ByteTokensError as e:
             # Give a specific warning for ByteTokensError and fall back to fast tokenizer
-            warnings.warn(f"Falling back to fast tokenizer. Could not build byte tokens for model {model!r} due to exception {e.__class__.__name__}: {e}")
+            warnings.warn(
+                f"Falling back to fast tokenizer. Could not build byte tokens for model {model!r} due to exception {e.__class__.__name__}: {e}"
+            )
         except Exception as e:
             # Fall back for other exceptions
-            warnings.warn(f"Falling back to fast tokenizer. Could not load tokenizer for model {model!r} due to exception {e.__class__.__name__}: {e}")
+            warnings.warn(
+                f"Falling back to fast tokenizer. Could not load tokenizer for model {model!r} due to exception {e.__class__.__name__}: {e}"
+            )
         else:
             return tokenizer, byte_tokens
 
@@ -139,7 +148,9 @@ def _byte_tokens(
                 )
                 pass
             else:
-                return self._byte_tokens_from_byte_decoder(transformers_tokenizer.byte_decoder, transformers_tokenizer)
+                return self._byte_tokens_from_byte_decoder(
+                    transformers_tokenizer.byte_decoder, transformers_tokenizer
+                )
 
         if hasattr(transformers_tokenizer, "sp_model"):
             return self._byte_tokens_from_sp_model(transformers_tokenizer)
@@ -154,9 +165,7 @@ def _byte_tokens(
 
         fallback_byte_decoder = self._fallback_byte_decoder()
         try:
-            self._check_byte_decoder(
-                fallback_byte_decoder, transformers_tokenizer
-            )
+            self._check_byte_decoder(fallback_byte_decoder, transformers_tokenizer)
         except ByteDecoderError as e:
             # Should be the only exception that is raised in _byte_tokens
             raise ByteTokensError(
@@ -230,7 +239,9 @@ def _byte_tokens_by_encoding_token_strings(
                         token_str = transformers_tokenizer.convert_tokens_to_string([token])
                         encoded_str = transformers_tokenizer.encode(token_str)
                         if len(encoded_str) != 1:
-                            raise ValueError(f"Round-trip encoding of tokens [{token}] failed! Got {encoded_str}")
+                            raise ValueError(
+                                f"Round-trip encoding of tokens [{token}] failed! Got {encoded_str}"
+                            )
                         roundtrip_id = encoded_str[0]
                         if roundtrip_id == i:
                             byte_coded = token_str.encode()
@@ -246,7 +257,7 @@ def _byte_tokens_by_encoding_token_strings(
     def _fallback_byte_decoder(self) -> dict[str, int]:
         byte_decoder = transformers_package.AutoTokenizer.from_pretrained(
             "gpt2", use_fast=False
-        ).byte_decoder # fall back to gpt2 mapping
+        ).byte_decoder  # fall back to gpt2 mapping
 
         # some special tokens may not have their whitespace encoded...
         byte_decoder[" "] = 32
@@ -293,8 +304,10 @@ def check_byte_decoder_complex_round_trip() -> None:
                 # if it's at the start of the reconstructed bytes
                 # Some tokenizers add this automatically as part of the call function, so
                 # we need to remove it to compare
-                if hasattr(transformers_tokenizer, "bos_token") and transformers_tokenizer.bos_token and reconstructed.startswith(
-                    transformers_tokenizer.bos_token.encode()
+                if (
+                    hasattr(transformers_tokenizer, "bos_token")
+                    and transformers_tokenizer.bos_token
+                    and reconstructed.startswith(transformers_tokenizer.bos_token.encode())
                 ):
                     reconstructed = reconstructed[len(transformers_tokenizer.bos_token) :]
             # TODO: can we narrow this exception?
@@ -371,7 +384,15 @@ def recode(self, tokens: Sequence[int]) -> list[int]:
 
 
 class TransformersEngine(Engine):
-    def __init__(self, model, tokenizer, compute_log_probs: bool, chat_template=None, enable_backtrack=True, enable_ff_tokens=True, **kwargs):
+    def __init__(self, 
+                 model, 
+                 tokenizer, 
+                 compute_log_probs: bool, 
+                 chat_template=None, 
+                 enable_backtrack=True, 
+                 enable_ff_tokens=True, 
+                 enable_monitoring=True, 
+                 **kwargs):
         # fill in default model value
         if model is None:
             model = os.environ.get("TRANSFORMERS_MODEL", None)
@@ -414,7 +435,9 @@ def __init__(self, model, tokenizer, compute_log_probs: bool, chat_template=None
             my_tokenizer,
             compute_log_probs=compute_log_probs,
             enable_backtrack=enable_backtrack,
-            enable_ff_tokens=enable_ff_tokens
+            enable_ff_tokens=enable_ff_tokens,
+            enable_monitoring=enable_monitoring,
+            **kwargs,
         )
 
     def _model(self, model, **kwargs):
@@ -517,6 +540,62 @@ def get_logits(self, token_ids):
 
         return self._cached_logits
 
+    def get_per_token_topk_probs(self, token_ids: list[int], top_k: int = 5) -> list[GenTokenExtra]:
+        tokenizer = self.tokenizer._orig_tokenizer
+
+        # NOTE (loc) - assume batch size of 1
+        input_ids = torch.tensor(token_ids).unsqueeze(0).long().to(self.device)
+
+        outputs = self.model_obj(input_ids)
+        probs = torch.softmax(outputs.logits, dim=-1).detach()
+
+        # append "1" to probs to account for the 1st token in the input_ids
+        probs = torch.cat([torch.ones_like(probs[:, :1, :]), probs], dim=1)
+
+        # collect the probability of the generated token
+        probs = probs[:, :-1, :]
+
+        batch = []
+        for input_sentence, input_probs in zip(input_ids, probs):
+            text_sequence = []
+
+            for _token_id, _probs in zip(input_sentence, input_probs):
+                _token = tokenizer.decode(_token_id)
+
+                if len(text_sequence) == 0:
+                    token = GenTokenExtra(
+                        token_id=_token_id.item(),
+                        prob=1.0,
+                        text=tokenizer.decode([_token_id]),
+                        top_k=[
+                            GenToken(token_id=_token_id.item(), prob=1.0, text=_token),
+                        ],
+                    )
+                    text_sequence.append(token)
+                    continue
+
+                # get the top k indices
+                top_k_indices = torch.topk(_probs, top_k).indices.tolist()
+                if _token_id not in top_k_indices:
+                    top_k_indices.append(_token_id.item())
+
+                top_k_probs = [_probs[i].item() for i in top_k_indices]
+                top_k_list = []
+                for t, p in zip(top_k_indices, top_k_probs):
+                    top_k_list.append(GenToken(token_id=t, prob=p, text=tokenizer.decode([t])))
+
+                token = GenTokenExtra(
+                    token_id=_token_id.item(),
+                    prob=_probs[_token_id].item(),
+                    text=_token,
+                    top_k=top_k_list,
+                )
+                text_sequence.append(token)
+
+            batch.append(text_sequence)
+
+        return batch[0]
+
 
 class Transformers(Model):
     def __init__(
@@ -528,6 +607,7 @@ def __init__(
         chat_template=None,
         enable_backtrack=True,
         enable_ff_tokens=True,
+        enable_monitoring=True,
         **kwargs,
     ):
         """Build a new Transformers model object that represents a model in a given state."""
@@ -539,6 +619,7 @@ def __init__(
                 chat_template=chat_template,
                 enable_backtrack=enable_backtrack,
                 enable_ff_tokens=enable_ff_tokens,
+                enable_monitoring=enable_monitoring,
                 **kwargs,
             ),
             echo=echo,
diff --git a/guidance/resources/graphpaper-inline.html b/guidance/resources/graphpaper-inline.html
new file mode 100644
index 000000000..4d108f32c
--- /dev/null
+++ b/guidance/resources/graphpaper-inline.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:ital,wght@0,100..800;1,100..800&family=Roboto+Mono:ital,wght@0,100..700;1,100..700&display=swap" rel="stylesheet">
+</head>
+<body>
+<script>
+var app=function(){"use strict";function t(){}function e(t){return t()}function n(){return Object.create(null)}function r(t){t.forEach(e)}function o(t){return"function"==typeof t}function i(t,e){return t!=t?e==e:t!==e||t&&"object"==typeof t||"function"==typeof t}function a(e,n,r){e.$$.on_destroy.push(function(e,...n){if(null==e){for(const t of n)t(void 0);return t}const r=e.subscribe(...n);return r.unsubscribe?()=>r.unsubscribe():r}(n,r))}function l(e){return e&&o(e.destroy)?e.destroy:t}const s="undefined"!=typeof window?window:"undefined"!=typeof globalThis?globalThis:global;function c(t,e){t.appendChild(e)}function u(t,e,n){t.insertBefore(e,n||null)}function d(t){t.parentNode&&t.parentNode.removeChild(t)}function f(t,e){for(let n=0;n<t.length;n+=1)t[n]&&t[n].d(e)}function p(t){return document.createElement(t)}function m(t){return document.createElementNS("http://www.w3.org/2000/svg",t)}function g(t){return document.createTextNode(t)}function h(){return g(" ")}function b(){return g("")}function y(t,e,n,r){return t.addEventListener(e,n,r),()=>t.removeEventListener(e,n,r)}function w(t,e,n){null==n?t.removeAttribute(e):t.getAttribute(e)!==n&&t.setAttribute(e,n)}function x(t,e){e=""+e,t.data!==e&&(t.data=e)}function v(t,e,n,r){null==n?t.style.removeProperty(e):t.style.setProperty(e,n,"")}let k,_;function $(){if(void 0===k){k=!1;try{"undefined"!=typeof window&&window.parent&&window.parent.document}catch(t){k=!0}}return k}function E(t){_=t}function N(){if(!_)throw new Error("Function called outside component initialization");return _}function T(t){N().$$.on_mount.push(t)}function M(t){N().$$.on_destroy.push(t)}function A(){const t=N();return(e,n,{cancelable:r=!1}={})=>{const o=t.$$.callbacks[e];if(o){const i=function(t,e,{bubbles:n=!1,cancelable:r=!1}={}){return new CustomEvent(t,{detail:e,bubbles:n,cancelable:r})}(e,n,{cancelable:r});return o.slice().forEach((e=>{e.call(t,i)})),!i.defaultPrevented}return!0}}const S=[],C=[];let R=[];const L=[],O=Promise.resolve();let D=!1;function I(t){R.push(t)}const z=new Set;let F=0;function P(){if(0!==F)return;const t=_;do{try{for(;F<S.length;){const t=S[F];F++,E(t),U(t.$$)}}catch(t){throw S.length=0,F=0,t}for(E(null),S.length=0,F=0;C.length;)C.pop()();for(let t=0;t<R.length;t+=1){const e=R[t];z.has(e)||(z.add(e),e())}R.length=0}while(S.length);for(;L.length;)L.pop()();D=!1,z.clear(),E(t)}function U(t){if(null!==t.fragment){t.update(),r(t.before_update);const e=t.dirty;t.dirty=[-1],t.fragment&&t.fragment.p(t.ctx,e),t.after_update.forEach(I)}}const H=new Set;let j;function B(){j={r:0,c:[],p:j}}function W(){j.r||r(j.c),j=j.p}function q(t,e){t&&t.i&&(H.delete(t),t.i(e))}function G(t,e,n,r){if(t&&t.o){if(H.has(t))return;H.add(t),j.c.push((()=>{H.delete(t),r&&(n&&t.d(1),r())})),t.o(e)}else r&&r()}function Y(t){return void 0!==t?.length?t:Array.from(t)}function V(t){t&&t.c()}function X(t,n,i){const{fragment:a,after_update:l}=t.$$;a&&a.m(n,i),I((()=>{const n=t.$$.on_mount.map(e).filter(o);t.$$.on_destroy?t.$$.on_destroy.push(...n):r(n),t.$$.on_mount=[]})),l.forEach(I)}function Z(t,e){const n=t.$$;null!==n.fragment&&(!function(t){const e=[],n=[];R.forEach((r=>-1===t.indexOf(r)?e.push(r):n.push(r))),n.forEach((t=>t())),R=e}(n.after_update),r(n.on_destroy),n.fragment&&n.fragment.d(e),n.on_destroy=n.fragment=null,n.ctx=[])}function J(t,e){-1===t.$$.dirty[0]&&(S.push(t),D||(D=!0,O.then(P)),t.$$.dirty.fill(0)),t.$$.dirty[e/31|0]|=1<<e%31}function K(e,o,i,a,l,s,c=null,u=[-1]){const f=_;E(e);const p=e.$$={fragment:null,ctx:[],props:s,update:t,not_equal:l,bound:n(),on_mount:[],on_destroy:[],on_disconnect:[],before_update:[],after_update:[],context:new Map(o.context||(f?f.$$.context:[])),callbacks:n(),dirty:u,skip_bound:!1,root:o.target||f.$$.root};c&&c(p.root);let m=!1;if(p.ctx=i?i(e,o.props||{},((t,n,...r)=>{const o=r.length?r[0]:n;return p.ctx&&l(p.ctx[t],p.ctx[t]=o)&&(!p.skip_bound&&p.bound[t]&&p.bound[t](o),m&&J(e,t)),n})):[],p.update(),m=!0,r(p.before_update),p.fragment=!!a&&a(p.ctx),o.target){if(o.hydrate){const t=function(t){return Array.from(t.childNodes)}(o.target);p.fragment&&p.fragment.l(t),t.forEach(d)}else p.fragment&&p.fragment.c();o.intro&&q(e.$$.fragment),X(e,o.target,o.anchor),P()}E(f)}class Q{$$=void 0;$$set=void 0;$destroy(){Z(this,1),this.$destroy=t}$on(e,n){if(!o(n))return t;const r=this.$$.callbacks[e]||(this.$$.callbacks[e]=[]);return r.push(n),()=>{const t=r.indexOf(n);-1!==t&&r.splice(t,1)}}$set(t){var e;this.$$set&&(e=t,0!==Object.keys(e).length)&&(this.$$.skip_bound=!0,this.$$set(t),this.$$.skip_bound=!1)}}"undefined"!=typeof window&&(window.__svelte||(window.__svelte={v:new Set})).v.add("4");!function(t,e){void 0===e&&(e={});var n=e.insertAt;if("undefined"!=typeof document){var r=document.head||document.getElementsByTagName("head")[0],o=document.createElement("style");o.type="text/css","top"===n&&r.firstChild?r.insertBefore(o,r.firstChild):r.appendChild(o),o.styleSheet?o.styleSheet.cssText=t:o.appendChild(document.createTextNode(t))}}('/*! tailwindcss v3.4.10 | MIT License | https://tailwindcss.com*/*,:after,:before{border:0 solid #e5e7eb;box-sizing:border-box}:after,:before{--tw-content:""}:host,html{line-height:1.5;-webkit-text-size-adjust:100%;font-family:ui-sans-serif,system-ui,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-feature-settings:normal;font-variation-settings:normal;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-tap-highlight-color:transparent}body{line-height:inherit;margin:0}hr{border-top-width:1px;color:inherit;height:0}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,pre,samp{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-feature-settings:normal;font-size:1em;font-variation-settings:normal}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{border-collapse:collapse;border-color:inherit;text-indent:0}button,input,optgroup,select,textarea{color:inherit;font-family:inherit;font-feature-settings:inherit;font-size:100%;font-variation-settings:inherit;font-weight:inherit;letter-spacing:inherit;line-height:inherit;margin:0;padding:0}button,select{text-transform:none}button,input:where([type=button]),input:where([type=reset]),input:where([type=submit]){-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dd,dl,figure,h1,h2,h3,h4,h5,h6,hr,p,pre{margin:0}fieldset{margin:0}fieldset,legend{padding:0}menu,ol,ul{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,textarea::-moz-placeholder{color:#9ca3af;opacity:1}input::placeholder,textarea::placeholder{color:#9ca3af;opacity:1}[role=button],button{cursor:pointer}:disabled{cursor:default}audio,canvas,embed,iframe,img,object,svg,video{display:block;vertical-align:middle}img,video{height:auto;max-width:100%}[hidden]{display:none}*,:after,:before{--tw-border-spacing-x:0;--tw-border-spacing-y:0;--tw-translate-x:0;--tw-translate-y:0;--tw-rotate:0;--tw-skew-x:0;--tw-skew-y:0;--tw-scale-x:1;--tw-scale-y:1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness:proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:rgba(59,130,246,.5);--tw-ring-offset-shadow:0 0 #0000;--tw-ring-shadow:0 0 #0000;--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }::backdrop{--tw-border-spacing-x:0;--tw-border-spacing-y:0;--tw-translate-x:0;--tw-translate-y:0;--tw-rotate:0;--tw-skew-x:0;--tw-skew-y:0;--tw-scale-x:1;--tw-scale-y:1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness:proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:rgba(59,130,246,.5);--tw-ring-offset-shadow:0 0 #0000;--tw-ring-shadow:0 0 #0000;--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }.pointer-events-none{pointer-events:none}.absolute{position:absolute}.relative{position:relative}.sticky{position:sticky}.top-0{top:0}.z-10{z-index:10}.z-50{z-index:50}.my-2{margin-bottom:.5rem;margin-top:.5rem}.-mt-4{margin-top:-1rem}.mb-5{margin-bottom:1.25rem}.ml-4{margin-left:1rem}.mr-4{margin-right:1rem}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.block{display:block}.inline-block{display:inline-block}.flex{display:flex}.inline-flex{display:inline-flex}.table{display:table}.grid{display:grid}.size-3{height:.75rem;width:.75rem}.size-4{height:1rem;width:1rem}.h-0{height:0}.h-2{height:.5rem}.h-6{height:1.5rem}.h-full{height:100%}.min-h-72{min-height:18rem}.w-12{width:3rem}.w-full{width:100%}.min-w-12{min-width:3rem}.basis-full{flex-basis:100%}@keyframes cpulse{50%{opacity:0}}.animate-cpulse{animation:cpulse 3.5s cubic-bezier(.4,0,.6,1) infinite}.resize{resize:both}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-center{align-items:center}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.whitespace-nowrap{white-space:nowrap}.text-nowrap{text-wrap:nowrap}.border{border-width:1px}.border-b{border-bottom-width:1px}.border-b-2{border-bottom-width:2px}.border-t{border-top-width:1px}.border-dashed{border-style:dashed}.border-gray-200{--tw-border-opacity:1;border-color:rgb(229 231 235/var(--tw-border-opacity))}.border-gray-300{--tw-border-opacity:1;border-color:rgb(209 213 219/var(--tw-border-opacity))}.border-gray-400{--tw-border-opacity:1;border-color:rgb(156 163 175/var(--tw-border-opacity))}.border-white{--tw-border-opacity:1;border-color:rgb(255 255 255/var(--tw-border-opacity))}.bg-gray-100{--tw-bg-opacity:1;background-color:rgb(243 244 246/var(--tw-bg-opacity))}.bg-gray-200{--tw-bg-opacity:1;background-color:rgb(229 231 235/var(--tw-bg-opacity))}.bg-gray-400{--tw-bg-opacity:1;background-color:rgb(156 163 175/var(--tw-bg-opacity))}.bg-gray-700{--tw-bg-opacity:1;background-color:rgb(55 65 81/var(--tw-bg-opacity))}.bg-white{--tw-bg-opacity:1;background-color:rgb(255 255 255/var(--tw-bg-opacity))}.fill-gray-700{fill:#374151}.px-1{padding-left:.25rem;padding-right:.25rem}.px-4{padding-left:1rem;padding-right:1rem}.py-1{padding-top:.25rem}.pb-1,.py-1{padding-bottom:.25rem}.pb-2{padding-bottom:.5rem}.pb-3{padding-bottom:.75rem}.pb-6{padding-bottom:1.5rem}.pl-1{padding-left:.25rem}.pl-2{padding-left:.5rem}.pt-1{padding-top:.25rem}.pt-2{padding-top:.5rem}.pt-6{padding-top:1.5rem}.text-left{text-align:left}.text-center{text-align:center}.text-right{text-align:right}.font-mono{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace}.font-sans{font-family:ui-sans-serif,system-ui,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji}.font-token{font-family:JetBrains Mono}.text-2xl{font-size:1.5rem;line-height:2rem}.text-lg{font-size:1.125rem;line-height:1.75rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xs{font-size:.75rem;line-height:1rem}.font-normal{font-weight:400}.uppercase{text-transform:uppercase}.tracking-wide{letter-spacing:.025em}.tracking-wider{letter-spacing:.05em}.text-gray-300{--tw-text-opacity:1;color:rgb(209 213 219/var(--tw-text-opacity))}.text-gray-500{--tw-text-opacity:1;color:rgb(107 114 128/var(--tw-text-opacity))}.text-gray-700{--tw-text-opacity:1;color:rgb(55 65 81/var(--tw-text-opacity))}.text-gray-800{--tw-text-opacity:1;color:rgb(31 41 55/var(--tw-text-opacity))}.text-purple-800{--tw-text-opacity:1;color:rgb(107 33 168/var(--tw-text-opacity))}.text-red-700{--tw-text-opacity:1;color:rgb(185 28 28/var(--tw-text-opacity))}.underline{text-decoration-line:underline}.line-through{text-decoration-line:line-through}.decoration-2{text-decoration-thickness:2px}.opacity-90{opacity:.9}.opacity-95{opacity:.95}.shadow{--tw-shadow:0 1px 3px 0 rgba(0,0,0,.1),0 1px 2px -1px rgba(0,0,0,.1);--tw-shadow-colored:0 1px 3px 0 var(--tw-shadow-color),0 1px 2px -1px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.hover\\:bg-gray-700:hover{--tw-bg-opacity:1;background-color:rgb(55 65 81/var(--tw-bg-opacity))}.hover\\:text-white:hover{--tw-text-opacity:1;color:rgb(255 255 255/var(--tw-text-opacity))}.group:hover .group-hover\\:fill-gray-100{fill:#f3f4f6}.group:hover .group-hover\\:text-gray-100{--tw-text-opacity:1;color:rgb(243 244 246/var(--tw-text-opacity))}');const tt=[];function et(e,n=t){let r;const o=new Set;function a(t){if(i(e,t)&&(e=t,r)){const t=!tt.length;for(const t of o)t[1](),tt.push(t,e);if(t){for(let t=0;t<tt.length;t+=2)tt[t][0](tt[t+1]);tt.length=0}}}function l(t){a(t(e))}return{set:a,update:l,subscribe:function(i,s=t){const c=[i,s];return o.add(c),1===o.size&&(r=n(a,l)||t),i(e),()=>{o.delete(c),0===o.size&&r&&(r(),r=null)}}}}function nt(t){return null!=t&&"RoleOpenerInput"===t.class_name}function rt(t){return null!=t&&"TextOutput"===t.class_name}var ot=et(void 0),it=et(void 0);function at(t,e,n){const r=t.slice();return r[4]=e[n],r[6]=n,r}function lt(t){let e,n,r,o,i,a,l=t[4]+"",s=0===t[6]&&function(t){let e,n,r=t[0].role+"";return{c(){e=p("span"),n=g(r),w(e,"class","absolute text-xs uppercase -mt-4 text-purple-800 font-sans")},m(t,r){u(t,e,r),c(e,n)},p(t,e){1&e&&r!==(r=t[0].role+"")&&x(n,r)},d(t){t&&d(e)}}}(t);return{c(){e=p("span"),s&&s.c(),n=h(),r=g(l),o=h(),w(e,"data-index",t[1]),w(e,"role","tooltip"),w(e,"class",i="token-grid-item inline-block mt-2 border-b-2 "+(t[0].special?"text-gray-300":"")),w(e,"style",a=`${t[2]} ${t[3]}`)},m(t,i){u(t,e,i),s&&s.m(e,null),c(e,n),c(e,r),c(e,o)},p(t,n){0===t[6]&&s.p(t,n),1&n&&l!==(l=t[4]+"")&&x(r,l),2&n&&w(e,"data-index",t[1]),1&n&&i!==(i="token-grid-item inline-block mt-2 border-b-2 "+(t[0].special?"text-gray-300":""))&&w(e,"class",i),12&n&&a!==(a=`${t[2]} ${t[3]}`)&&w(e,"style",a)},d(t){t&&d(e),s&&s.d()}}}function st(t){let e,n,r,o,i,a=0===t[6]&&function(t){let e,n,r=t[0].role+"";return{c(){e=p("span"),n=g(r),w(e,"class","absolute text-xs uppercase -mt-4 text-purple-800 font-sans")},m(t,r){u(t,e,r),c(e,n)},p(t,e){1&e&&r!==(r=t[0].role+"")&&x(n,r)},d(t){t&&d(e)}}}(t);return{c(){e=p("span"),a&&a.c(),n=g("\n            \\n"),o=h(),i=p("div"),w(e,"data-index",t[1]),w(e,"role","tooltip"),w(e,"class","token-grid-item inline-block mt-2 border-b-2 text-gray-300"),w(e,"style",r=`${t[2]} ${t[3]}`),w(i,"class","basis-full h-full")},m(t,r){u(t,e,r),a&&a.m(e,null),c(e,n),u(t,o,r),u(t,i,r)},p(t,n){0===t[6]&&a.p(t,n),2&n&&w(e,"data-index",t[1]),12&n&&r!==(r=`${t[2]} ${t[3]}`)&&w(e,"style",r)},d(t){t&&(d(e),d(o),d(i)),a&&a.d()}}}function ct(t){let e,n,r,o=0===t[6]&&function(t){let e,n,r=t[0].role+"";return{c(){e=p("span"),n=g(r),w(e,"class","absolute text-xs uppercase -mt-4 text-purple-800 font-sans")},m(t,r){u(t,e,r),c(e,n)},p(t,e){1&e&&r!==(r=t[0].role+"")&&x(n,r)},d(t){t&&d(e)}}}(t);return{c(){e=p("span"),o&&o.c(),n=g("\n            \\t  \n        "),w(e,"data-index",t[1]),w(e,"role","tooltip"),w(e,"class","token-grid-item inline-block mt-2 border-b-2 text-gray-300"),w(e,"style",r=`${t[2]} ${t[3]}`)},m(t,r){u(t,e,r),o&&o.m(e,null),c(e,n)},p(t,n){0===t[6]&&o.p(t,n),2&n&&w(e,"data-index",t[1]),12&n&&r!==(r=`${t[2]} ${t[3]}`)&&w(e,"style",r)},d(t){t&&d(e),o&&o.d()}}}function ut(t){let e,n,r,o=0===t[6]&&function(t){let e,n,r=t[0].role+"";return{c(){e=p("span"),n=g(r),w(e,"class","absolute text-xs uppercase -mt-4 text-purple-800 font-sans")},m(t,r){u(t,e,r),c(e,n)},p(t,e){1&e&&r!==(r=t[0].role+"")&&x(n,r)},d(t){t&&d(e)}}}(t);return{c(){e=p("span"),o&&o.c(),n=g("\n             \n        "),w(e,"data-index",t[1]),w(e,"role","tooltip"),w(e,"class","token-grid-item inline-block mt-2 border-b-2 text-gray-300"),w(e,"style",r=`${t[2]} ${t[3]}`)},m(t,r){u(t,e,r),o&&o.m(e,null),c(e,n)},p(t,n){0===t[6]&&o.p(t,n),2&n&&w(e,"data-index",t[1]),12&n&&r!==(r=`${t[2]} ${t[3]}`)&&w(e,"style",r)},d(t){t&&d(e),o&&o.d()}}}function dt(t){let e;function n(t,e){return" "===t[4]?ut:"\t"===t[4]?ct:"\n"===t[4]?st:lt}let r=n(t),o=r(t);return{c(){o.c(),e=b()},m(t,n){o.m(t,n),u(t,e,n)},p(t,i){r===(r=n(t))&&o?o.p(t,i):(o.d(1),o=r(t),o&&(o.c(),o.m(e.parentNode,e)))},d(t){t&&d(e),o.d(t)}}}function ft(e){let n,r=Y(e[0].text),o=[];for(let t=0;t<r.length;t+=1)o[t]=dt(at(e,r,t));return{c(){for(let t=0;t<o.length;t+=1)o[t].c();n=b()},m(t,e){for(let n=0;n<o.length;n+=1)o[n]&&o[n].m(t,e);u(t,n,e)},p(t,[e]){if(15&e){let i;for(r=Y(t[0].text),i=0;i<r.length;i+=1){const a=at(t,r,i);o[i]?o[i].p(a,e):(o[i]=dt(a),o[i].c(),o[i].m(n.parentNode,n))}for(;i<o.length;i+=1)o[i].d(1);o.length=r.length}},i:t,o:t,d(t){t&&d(n),f(o,t)}}}function pt(t,e,n){let{token:r}=e,{index:o}=e,{underlineStyle:i=""}=e,{bgStyle:a=""}=e;return t.$$set=t=>{"token"in t&&n(0,r=t.token),"index"in t&&n(1,o=t.index),"underlineStyle"in t&&n(2,i=t.underlineStyle),"bgStyle"in t&&n(3,a=t.bgStyle)},[r,o,i,a]}class mt extends Q{constructor(t){super(),K(this,t,pt,ft,i,{token:0,index:1,underlineStyle:2,bgStyle:3})}}function gt(t,e){var n,r=function(r){n=setTimeout((function(){t.dispatchEvent(new CustomEvent("longmouseover",{detail:r}))}),e)},o=function(e){clearTimeout(n),t.dispatchEvent(new CustomEvent("longmouseout",{detail:e}))};return t.addEventListener("mouseover",r),t.addEventListener("mouseout",o),{update:function(t){e=t},destroy:function(){t.removeEventListener("mouseover",r),t.removeEventListener("mouseout",o)}}}"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self&&self;function ht(t){return t&&t.__esModule&&Object.prototype.hasOwnProperty.call(t,"default")?t.default:t}var bt={exports:{}};
+/*! @license DOMPurify 3.1.7 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.1.7/LICENSE */bt.exports=function(){const{entries:t,setPrototypeOf:e,isFrozen:n,getPrototypeOf:r,getOwnPropertyDescriptor:o}=Object;let{freeze:i,seal:a,create:l}=Object,{apply:s,construct:c}="undefined"!=typeof Reflect&&Reflect;i||(i=function(t){return t}),a||(a=function(t){return t}),s||(s=function(t,e,n){return t.apply(e,n)}),c||(c=function(t,e){return new t(...e)});const u=k(Array.prototype.forEach),d=k(Array.prototype.pop),f=k(Array.prototype.push),p=k(String.prototype.toLowerCase),m=k(String.prototype.toString),g=k(String.prototype.match),h=k(String.prototype.replace),b=k(String.prototype.indexOf),y=k(String.prototype.trim),w=k(Object.prototype.hasOwnProperty),x=k(RegExp.prototype.test),v=_(TypeError);function k(t){return function(e){for(var n=arguments.length,r=new Array(n>1?n-1:0),o=1;o<n;o++)r[o-1]=arguments[o];return s(t,e,r)}}function _(t){return function(){for(var e=arguments.length,n=new Array(e),r=0;r<e;r++)n[r]=arguments[r];return c(t,n)}}function $(t,r){let o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:p;e&&e(t,null);let i=r.length;for(;i--;){let e=r[i];if("string"==typeof e){const t=o(e);t!==e&&(n(r)||(r[i]=t),e=t)}t[e]=!0}return t}function E(t){for(let e=0;e<t.length;e++)w(t,e)||(t[e]=null);return t}function N(e){const n=l(null);for(const[r,o]of t(e))w(e,r)&&(Array.isArray(o)?n[r]=E(o):o&&"object"==typeof o&&o.constructor===Object?n[r]=N(o):n[r]=o);return n}function T(t,e){for(;null!==t;){const n=o(t,e);if(n){if(n.get)return k(n.get);if("function"==typeof n.value)return k(n.value)}t=r(t)}function n(){return null}return n}const M=i(["a","abbr","acronym","address","area","article","aside","audio","b","bdi","bdo","big","blink","blockquote","body","br","button","canvas","caption","center","cite","code","col","colgroup","content","data","datalist","dd","decorator","del","details","dfn","dialog","dir","div","dl","dt","element","em","fieldset","figcaption","figure","font","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","img","input","ins","kbd","label","legend","li","main","map","mark","marquee","menu","menuitem","meter","nav","nobr","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","section","select","shadow","small","source","spacer","span","strike","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","tr","track","tt","u","ul","var","video","wbr"]),A=i(["svg","a","altglyph","altglyphdef","altglyphitem","animatecolor","animatemotion","animatetransform","circle","clippath","defs","desc","ellipse","filter","font","g","glyph","glyphref","hkern","image","line","lineargradient","marker","mask","metadata","mpath","path","pattern","polygon","polyline","radialgradient","rect","stop","style","switch","symbol","text","textpath","title","tref","tspan","view","vkern"]),S=i(["feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feDistantLight","feDropShadow","feFlood","feFuncA","feFuncB","feFuncG","feFuncR","feGaussianBlur","feImage","feMerge","feMergeNode","feMorphology","feOffset","fePointLight","feSpecularLighting","feSpotLight","feTile","feTurbulence"]),C=i(["animate","color-profile","cursor","discard","font-face","font-face-format","font-face-name","font-face-src","font-face-uri","foreignobject","hatch","hatchpath","mesh","meshgradient","meshpatch","meshrow","missing-glyph","script","set","solidcolor","unknown","use"]),R=i(["math","menclose","merror","mfenced","mfrac","mglyph","mi","mlabeledtr","mmultiscripts","mn","mo","mover","mpadded","mphantom","mroot","mrow","ms","mspace","msqrt","mstyle","msub","msup","msubsup","mtable","mtd","mtext","mtr","munder","munderover","mprescripts"]),L=i(["maction","maligngroup","malignmark","mlongdiv","mscarries","mscarry","msgroup","mstack","msline","msrow","semantics","annotation","annotation-xml","mprescripts","none"]),O=i(["#text"]),D=i(["accept","action","align","alt","autocapitalize","autocomplete","autopictureinpicture","autoplay","background","bgcolor","border","capture","cellpadding","cellspacing","checked","cite","class","clear","color","cols","colspan","controls","controlslist","coords","crossorigin","datetime","decoding","default","dir","disabled","disablepictureinpicture","disableremoteplayback","download","draggable","enctype","enterkeyhint","face","for","headers","height","hidden","high","href","hreflang","id","inputmode","integrity","ismap","kind","label","lang","list","loading","loop","low","max","maxlength","media","method","min","minlength","multiple","muted","name","nonce","noshade","novalidate","nowrap","open","optimum","pattern","placeholder","playsinline","popover","popovertarget","popovertargetaction","poster","preload","pubdate","radiogroup","readonly","rel","required","rev","reversed","role","rows","rowspan","spellcheck","scope","selected","shape","size","sizes","span","srclang","start","src","srcset","step","style","summary","tabindex","title","translate","type","usemap","valign","value","width","wrap","xmlns","slot"]),I=i(["accent-height","accumulate","additive","alignment-baseline","amplitude","ascent","attributename","attributetype","azimuth","basefrequency","baseline-shift","begin","bias","by","class","clip","clippathunits","clip-path","clip-rule","color","color-interpolation","color-interpolation-filters","color-profile","color-rendering","cx","cy","d","dx","dy","diffuseconstant","direction","display","divisor","dur","edgemode","elevation","end","exponent","fill","fill-opacity","fill-rule","filter","filterunits","flood-color","flood-opacity","font-family","font-size","font-size-adjust","font-stretch","font-style","font-variant","font-weight","fx","fy","g1","g2","glyph-name","glyphref","gradientunits","gradienttransform","height","href","id","image-rendering","in","in2","intercept","k","k1","k2","k3","k4","kerning","keypoints","keysplines","keytimes","lang","lengthadjust","letter-spacing","kernelmatrix","kernelunitlength","lighting-color","local","marker-end","marker-mid","marker-start","markerheight","markerunits","markerwidth","maskcontentunits","maskunits","max","mask","media","method","mode","min","name","numoctaves","offset","operator","opacity","order","orient","orientation","origin","overflow","paint-order","path","pathlength","patterncontentunits","patterntransform","patternunits","points","preservealpha","preserveaspectratio","primitiveunits","r","rx","ry","radius","refx","refy","repeatcount","repeatdur","restart","result","rotate","scale","seed","shape-rendering","slope","specularconstant","specularexponent","spreadmethod","startoffset","stddeviation","stitchtiles","stop-color","stop-opacity","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke","stroke-width","style","surfacescale","systemlanguage","tabindex","tablevalues","targetx","targety","transform","transform-origin","text-anchor","text-decoration","text-rendering","textlength","type","u1","u2","unicode","values","viewbox","visibility","version","vert-adv-y","vert-origin-x","vert-origin-y","width","word-spacing","wrap","writing-mode","xchannelselector","ychannelselector","x","x1","x2","xmlns","y","y1","y2","z","zoomandpan"]),z=i(["accent","accentunder","align","bevelled","close","columnsalign","columnlines","columnspan","denomalign","depth","dir","display","displaystyle","encoding","fence","frame","height","href","id","largeop","length","linethickness","lspace","lquote","mathbackground","mathcolor","mathsize","mathvariant","maxsize","minsize","movablelimits","notation","numalign","open","rowalign","rowlines","rowspacing","rowspan","rspace","rquote","scriptlevel","scriptminsize","scriptsizemultiplier","selection","separator","separators","stretchy","subscriptshift","supscriptshift","symmetric","voffset","width","xmlns"]),F=i(["xlink:href","xml:id","xlink:title","xml:space","xmlns:xlink"]),P=a(/\{\{[\w\W]*|[\w\W]*\}\}/gm),U=a(/<%[\w\W]*|[\w\W]*%>/gm),H=a(/\${[\w\W]*}/gm),j=a(/^data-[\-\w.\u00B7-\uFFFF]/),B=a(/^aria-[\-\w]+$/),W=a(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),q=a(/^(?:\w+script|data):/i),G=a(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),Y=a(/^html$/i),V=a(/^[a-z][.\w]*(-[.\w]+)+$/i);var X=Object.freeze({__proto__:null,MUSTACHE_EXPR:P,ERB_EXPR:U,TMPLIT_EXPR:H,DATA_ATTR:j,ARIA_ATTR:B,IS_ALLOWED_URI:W,IS_SCRIPT_OR_DATA:q,ATTR_WHITESPACE:G,DOCTYPE_NAME:Y,CUSTOM_ELEMENT:V});const Z={element:1,attribute:2,text:3,cdataSection:4,entityReference:5,entityNode:6,progressingInstruction:7,comment:8,document:9,documentType:10,documentFragment:11,notation:12},J=function(){return"undefined"==typeof window?null:window},K=function(t,e){if("object"!=typeof t||"function"!=typeof t.createPolicy)return null;let n=null;const r="data-tt-policy-suffix";e&&e.hasAttribute(r)&&(n=e.getAttribute(r));const o="dompurify"+(n?"#"+n:"");try{return t.createPolicy(o,{createHTML:t=>t,createScriptURL:t=>t})}catch(t){return console.warn("TrustedTypes policy "+o+" could not be created."),null}};function Q(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:J();const n=t=>Q(t);if(n.version="3.1.7",n.removed=[],!e||!e.document||e.document.nodeType!==Z.document)return n.isSupported=!1,n;let{document:r}=e;const o=r,a=o.currentScript,{DocumentFragment:s,HTMLTemplateElement:c,Node:k,Element:_,NodeFilter:E,NamedNodeMap:P=e.NamedNodeMap||e.MozNamedAttrMap,HTMLFormElement:U,DOMParser:H,trustedTypes:j}=e,B=_.prototype,q=T(B,"cloneNode"),G=T(B,"remove"),V=T(B,"nextSibling"),tt=T(B,"childNodes"),et=T(B,"parentNode");if("function"==typeof c){const t=r.createElement("template");t.content&&t.content.ownerDocument&&(r=t.content.ownerDocument)}let nt,rt="";const{implementation:ot,createNodeIterator:it,createDocumentFragment:at,getElementsByTagName:lt}=r,{importNode:st}=o;let ct={};n.isSupported="function"==typeof t&&"function"==typeof et&&ot&&void 0!==ot.createHTMLDocument;const{MUSTACHE_EXPR:ut,ERB_EXPR:dt,TMPLIT_EXPR:ft,DATA_ATTR:pt,ARIA_ATTR:mt,IS_SCRIPT_OR_DATA:gt,ATTR_WHITESPACE:ht,CUSTOM_ELEMENT:bt}=X;let{IS_ALLOWED_URI:yt}=X,wt=null;const xt=$({},[...M,...A,...S,...R,...O]);let vt=null;const kt=$({},[...D,...I,...z,...F]);let _t=Object.seal(l(null,{tagNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},attributeNameCheck:{writable:!0,configurable:!1,enumerable:!0,value:null},allowCustomizedBuiltInElements:{writable:!0,configurable:!1,enumerable:!0,value:!1}})),$t=null,Et=null,Nt=!0,Tt=!0,Mt=!1,At=!0,St=!1,Ct=!0,Rt=!1,Lt=!1,Ot=!1,Dt=!1,It=!1,zt=!1,Ft=!0,Pt=!1;const Ut="user-content-";let Ht=!0,jt=!1,Bt={},Wt=null;const qt=$({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","style","svg","template","thead","title","video","xmp"]);let Gt=null;const Yt=$({},["audio","video","img","source","image","track"]);let Vt=null;const Xt=$({},["alt","class","for","id","label","name","pattern","placeholder","role","summary","title","value","style","xmlns"]),Zt="http://www.w3.org/1998/Math/MathML",Jt="http://www.w3.org/2000/svg",Kt="http://www.w3.org/1999/xhtml";let Qt=Kt,te=!1,ee=null;const ne=$({},[Zt,Jt,Kt],m);let re=null;const oe=["application/xhtml+xml","text/html"],ie="text/html";let ae=null,le=null;const se=r.createElement("form"),ce=function(t){return t instanceof RegExp||t instanceof Function},ue=function(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(!le||le!==t){if(t&&"object"==typeof t||(t={}),t=N(t),re=-1===oe.indexOf(t.PARSER_MEDIA_TYPE)?ie:t.PARSER_MEDIA_TYPE,ae="application/xhtml+xml"===re?m:p,wt=w(t,"ALLOWED_TAGS")?$({},t.ALLOWED_TAGS,ae):xt,vt=w(t,"ALLOWED_ATTR")?$({},t.ALLOWED_ATTR,ae):kt,ee=w(t,"ALLOWED_NAMESPACES")?$({},t.ALLOWED_NAMESPACES,m):ne,Vt=w(t,"ADD_URI_SAFE_ATTR")?$(N(Xt),t.ADD_URI_SAFE_ATTR,ae):Xt,Gt=w(t,"ADD_DATA_URI_TAGS")?$(N(Yt),t.ADD_DATA_URI_TAGS,ae):Yt,Wt=w(t,"FORBID_CONTENTS")?$({},t.FORBID_CONTENTS,ae):qt,$t=w(t,"FORBID_TAGS")?$({},t.FORBID_TAGS,ae):{},Et=w(t,"FORBID_ATTR")?$({},t.FORBID_ATTR,ae):{},Bt=!!w(t,"USE_PROFILES")&&t.USE_PROFILES,Nt=!1!==t.ALLOW_ARIA_ATTR,Tt=!1!==t.ALLOW_DATA_ATTR,Mt=t.ALLOW_UNKNOWN_PROTOCOLS||!1,At=!1!==t.ALLOW_SELF_CLOSE_IN_ATTR,St=t.SAFE_FOR_TEMPLATES||!1,Ct=!1!==t.SAFE_FOR_XML,Rt=t.WHOLE_DOCUMENT||!1,Dt=t.RETURN_DOM||!1,It=t.RETURN_DOM_FRAGMENT||!1,zt=t.RETURN_TRUSTED_TYPE||!1,Ot=t.FORCE_BODY||!1,Ft=!1!==t.SANITIZE_DOM,Pt=t.SANITIZE_NAMED_PROPS||!1,Ht=!1!==t.KEEP_CONTENT,jt=t.IN_PLACE||!1,yt=t.ALLOWED_URI_REGEXP||W,Qt=t.NAMESPACE||Kt,_t=t.CUSTOM_ELEMENT_HANDLING||{},t.CUSTOM_ELEMENT_HANDLING&&ce(t.CUSTOM_ELEMENT_HANDLING.tagNameCheck)&&(_t.tagNameCheck=t.CUSTOM_ELEMENT_HANDLING.tagNameCheck),t.CUSTOM_ELEMENT_HANDLING&&ce(t.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)&&(_t.attributeNameCheck=t.CUSTOM_ELEMENT_HANDLING.attributeNameCheck),t.CUSTOM_ELEMENT_HANDLING&&"boolean"==typeof t.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements&&(_t.allowCustomizedBuiltInElements=t.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements),St&&(Tt=!1),It&&(Dt=!0),Bt&&(wt=$({},O),vt=[],!0===Bt.html&&($(wt,M),$(vt,D)),!0===Bt.svg&&($(wt,A),$(vt,I),$(vt,F)),!0===Bt.svgFilters&&($(wt,S),$(vt,I),$(vt,F)),!0===Bt.mathMl&&($(wt,R),$(vt,z),$(vt,F))),t.ADD_TAGS&&(wt===xt&&(wt=N(wt)),$(wt,t.ADD_TAGS,ae)),t.ADD_ATTR&&(vt===kt&&(vt=N(vt)),$(vt,t.ADD_ATTR,ae)),t.ADD_URI_SAFE_ATTR&&$(Vt,t.ADD_URI_SAFE_ATTR,ae),t.FORBID_CONTENTS&&(Wt===qt&&(Wt=N(Wt)),$(Wt,t.FORBID_CONTENTS,ae)),Ht&&(wt["#text"]=!0),Rt&&$(wt,["html","head","body"]),wt.table&&($(wt,["tbody"]),delete $t.tbody),t.TRUSTED_TYPES_POLICY){if("function"!=typeof t.TRUSTED_TYPES_POLICY.createHTML)throw v('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');if("function"!=typeof t.TRUSTED_TYPES_POLICY.createScriptURL)throw v('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');nt=t.TRUSTED_TYPES_POLICY,rt=nt.createHTML("")}else void 0===nt&&(nt=K(j,a)),null!==nt&&"string"==typeof rt&&(rt=nt.createHTML(""));i&&i(t),le=t}},de=$({},["mi","mo","mn","ms","mtext"]),fe=$({},["annotation-xml"]),pe=$({},["title","style","font","a","script"]),me=$({},[...A,...S,...C]),ge=$({},[...R,...L]),he=function(t){let e=et(t);e&&e.tagName||(e={namespaceURI:Qt,tagName:"template"});const n=p(t.tagName),r=p(e.tagName);return!!ee[t.namespaceURI]&&(t.namespaceURI===Jt?e.namespaceURI===Kt?"svg"===n:e.namespaceURI===Zt?"svg"===n&&("annotation-xml"===r||de[r]):Boolean(me[n]):t.namespaceURI===Zt?e.namespaceURI===Kt?"math"===n:e.namespaceURI===Jt?"math"===n&&fe[r]:Boolean(ge[n]):t.namespaceURI===Kt?!(e.namespaceURI===Jt&&!fe[r])&&!(e.namespaceURI===Zt&&!de[r])&&!ge[n]&&(pe[n]||!me[n]):!("application/xhtml+xml"!==re||!ee[t.namespaceURI]))},be=function(t){f(n.removed,{element:t});try{et(t).removeChild(t)}catch(e){G(t)}},ye=function(t,e){try{f(n.removed,{attribute:e.getAttributeNode(t),from:e})}catch(t){f(n.removed,{attribute:null,from:e})}if(e.removeAttribute(t),"is"===t&&!vt[t])if(Dt||It)try{be(e)}catch(t){}else try{e.setAttribute(t,"")}catch(t){}},we=function(t){let e=null,n=null;if(Ot)t="<remove></remove>"+t;else{const e=g(t,/^[\r\n\t ]+/);n=e&&e[0]}"application/xhtml+xml"===re&&Qt===Kt&&(t='<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>'+t+"</body></html>");const o=nt?nt.createHTML(t):t;if(Qt===Kt)try{e=(new H).parseFromString(o,re)}catch(t){}if(!e||!e.documentElement){e=ot.createDocument(Qt,"template",null);try{e.documentElement.innerHTML=te?rt:o}catch(t){}}const i=e.body||e.documentElement;return t&&n&&i.insertBefore(r.createTextNode(n),i.childNodes[0]||null),Qt===Kt?lt.call(e,Rt?"html":"body")[0]:Rt?e.documentElement:i},xe=function(t){return it.call(t.ownerDocument||t,t,E.SHOW_ELEMENT|E.SHOW_COMMENT|E.SHOW_TEXT|E.SHOW_PROCESSING_INSTRUCTION|E.SHOW_CDATA_SECTION,null)},ve=function(t){return t instanceof U&&("string"!=typeof t.nodeName||"string"!=typeof t.textContent||"function"!=typeof t.removeChild||!(t.attributes instanceof P)||"function"!=typeof t.removeAttribute||"function"!=typeof t.setAttribute||"string"!=typeof t.namespaceURI||"function"!=typeof t.insertBefore||"function"!=typeof t.hasChildNodes)},ke=function(t){return"function"==typeof k&&t instanceof k},_e=function(t,e,r){ct[t]&&u(ct[t],(t=>{t.call(n,e,r,le)}))},$e=function(t){let e=null;if(_e("beforeSanitizeElements",t,null),ve(t))return be(t),!0;const r=ae(t.nodeName);if(_e("uponSanitizeElement",t,{tagName:r,allowedTags:wt}),t.hasChildNodes()&&!ke(t.firstElementChild)&&x(/<[/\w]/g,t.innerHTML)&&x(/<[/\w]/g,t.textContent))return be(t),!0;if(t.nodeType===Z.progressingInstruction)return be(t),!0;if(Ct&&t.nodeType===Z.comment&&x(/<[/\w]/g,t.data))return be(t),!0;if(!wt[r]||$t[r]){if(!$t[r]&&Ne(r)){if(_t.tagNameCheck instanceof RegExp&&x(_t.tagNameCheck,r))return!1;if(_t.tagNameCheck instanceof Function&&_t.tagNameCheck(r))return!1}if(Ht&&!Wt[r]){const e=et(t)||t.parentNode,n=tt(t)||t.childNodes;if(n&&e)for(let r=n.length-1;r>=0;--r){const o=q(n[r],!0);o.__removalCount=(t.__removalCount||0)+1,e.insertBefore(o,V(t))}}return be(t),!0}return t instanceof _&&!he(t)?(be(t),!0):"noscript"!==r&&"noembed"!==r&&"noframes"!==r||!x(/<\/no(script|embed|frames)/i,t.innerHTML)?(St&&t.nodeType===Z.text&&(e=t.textContent,u([ut,dt,ft],(t=>{e=h(e,t," ")})),t.textContent!==e&&(f(n.removed,{element:t.cloneNode()}),t.textContent=e)),_e("afterSanitizeElements",t,null),!1):(be(t),!0)},Ee=function(t,e,n){if(Ft&&("id"===e||"name"===e)&&(n in r||n in se))return!1;if(Tt&&!Et[e]&&x(pt,e));else if(Nt&&x(mt,e));else if(!vt[e]||Et[e]){if(!(Ne(t)&&(_t.tagNameCheck instanceof RegExp&&x(_t.tagNameCheck,t)||_t.tagNameCheck instanceof Function&&_t.tagNameCheck(t))&&(_t.attributeNameCheck instanceof RegExp&&x(_t.attributeNameCheck,e)||_t.attributeNameCheck instanceof Function&&_t.attributeNameCheck(e))||"is"===e&&_t.allowCustomizedBuiltInElements&&(_t.tagNameCheck instanceof RegExp&&x(_t.tagNameCheck,n)||_t.tagNameCheck instanceof Function&&_t.tagNameCheck(n))))return!1}else if(Vt[e]);else if(x(yt,h(n,ht,"")));else if("src"!==e&&"xlink:href"!==e&&"href"!==e||"script"===t||0!==b(n,"data:")||!Gt[t])if(Mt&&!x(gt,h(n,ht,"")));else if(n)return!1;return!0},Ne=function(t){return"annotation-xml"!==t&&g(t,bt)},Te=function(t){_e("beforeSanitizeAttributes",t,null);const{attributes:e}=t;if(!e)return;const r={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:vt};let o=e.length;for(;o--;){const i=e[o],{name:a,namespaceURI:l,value:s}=i,c=ae(a);let f="value"===a?s:y(s);if(r.attrName=c,r.attrValue=f,r.keepAttr=!0,r.forceKeepAttr=void 0,_e("uponSanitizeAttribute",t,r),f=r.attrValue,r.forceKeepAttr)continue;if(ye(a,t),!r.keepAttr)continue;if(!At&&x(/\/>/i,f)){ye(a,t);continue}St&&u([ut,dt,ft],(t=>{f=h(f,t," ")}));const p=ae(t.nodeName);if(Ee(p,c,f))if(!Pt||"id"!==c&&"name"!==c||(ye(a,t),f=Ut+f),Ct&&x(/((--!?|])>)|<\/(style|title)/i,f))ye(a,t);else{if(nt&&"object"==typeof j&&"function"==typeof j.getAttributeType)if(l);else switch(j.getAttributeType(p,c)){case"TrustedHTML":f=nt.createHTML(f);break;case"TrustedScriptURL":f=nt.createScriptURL(f)}try{l?t.setAttributeNS(l,a,f):t.setAttribute(a,f),ve(t)?be(t):d(n.removed)}catch(t){}}}_e("afterSanitizeAttributes",t,null)},Me=function t(e){let n=null;const r=xe(e);for(_e("beforeSanitizeShadowDOM",e,null);n=r.nextNode();)_e("uponSanitizeShadowNode",n,null),$e(n)||(n.content instanceof s&&t(n.content),Te(n));_e("afterSanitizeShadowDOM",e,null)};return n.sanitize=function(t){let e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},r=null,i=null,a=null,l=null;if(te=!t,te&&(t="\x3c!--\x3e"),"string"!=typeof t&&!ke(t)){if("function"!=typeof t.toString)throw v("toString is not a function");if("string"!=typeof(t=t.toString()))throw v("dirty is not a string, aborting")}if(!n.isSupported)return t;if(Lt||ue(e),n.removed=[],"string"==typeof t&&(jt=!1),jt){if(t.nodeName){const e=ae(t.nodeName);if(!wt[e]||$t[e])throw v("root node is forbidden and cannot be sanitized in-place")}}else if(t instanceof k)r=we("\x3c!----\x3e"),i=r.ownerDocument.importNode(t,!0),i.nodeType===Z.element&&"BODY"===i.nodeName||"HTML"===i.nodeName?r=i:r.appendChild(i);else{if(!Dt&&!St&&!Rt&&-1===t.indexOf("<"))return nt&&zt?nt.createHTML(t):t;if(r=we(t),!r)return Dt?null:zt?rt:""}r&&Ot&&be(r.firstChild);const c=xe(jt?t:r);for(;a=c.nextNode();)$e(a)||(a.content instanceof s&&Me(a.content),Te(a));if(jt)return t;if(Dt){if(It)for(l=at.call(r.ownerDocument);r.firstChild;)l.appendChild(r.firstChild);else l=r;return(vt.shadowroot||vt.shadowrootmode)&&(l=st.call(o,l,!0)),l}let d=Rt?r.outerHTML:r.innerHTML;return Rt&&wt["!doctype"]&&r.ownerDocument&&r.ownerDocument.doctype&&r.ownerDocument.doctype.name&&x(Y,r.ownerDocument.doctype.name)&&(d="<!DOCTYPE "+r.ownerDocument.doctype.name+">\n"+d),St&&u([ut,dt,ft],(t=>{d=h(d,t," ")})),nt&&zt?nt.createHTML(d):d},n.setConfig=function(){ue(arguments.length>0&&void 0!==arguments[0]?arguments[0]:{}),Lt=!0},n.clearConfig=function(){le=null,Lt=!1},n.isValidAttribute=function(t,e,n){le||ue({});const r=ae(t),o=ae(e);return Ee(r,o,n)},n.addHook=function(t,e){"function"==typeof e&&(ct[t]=ct[t]||[],f(ct[t],e))},n.removeHook=function(t){if(ct[t])return d(ct[t])},n.removeHooks=function(t){ct[t]&&(ct[t]=[])},n.removeAllHooks=function(){ct={}},n}var tt=Q();return tt}();var yt=ht(bt.exports);function wt(t){for(var e=t.length/6|0,n=new Array(e),r=0;r<e;)n[r]="#"+t.slice(6*r,6*++r);return n}function xt(t,e,n){t.prototype=e.prototype=n,n.constructor=t}function vt(t,e){var n=Object.create(t.prototype);for(var r in e)n[r]=e[r];return n}function kt(){}var _t=.7,$t=1/_t,Et="\\s*([+-]?\\d+)\\s*",Nt="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*",Tt="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*",Mt=/^#([0-9a-f]{3,8})$/,At=new RegExp(`^rgb\\(${Et},${Et},${Et}\\)$`),St=new RegExp(`^rgb\\(${Tt},${Tt},${Tt}\\)$`),Ct=new RegExp(`^rgba\\(${Et},${Et},${Et},${Nt}\\)$`),Rt=new RegExp(`^rgba\\(${Tt},${Tt},${Tt},${Nt}\\)$`),Lt=new RegExp(`^hsl\\(${Nt},${Tt},${Tt}\\)$`),Ot=new RegExp(`^hsla\\(${Nt},${Tt},${Tt},${Nt}\\)$`),Dt={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function It(){return this.rgb().formatHex()}function zt(){return this.rgb().formatRgb()}function Ft(t){var e,n;return t=(t+"").trim().toLowerCase(),(e=Mt.exec(t))?(n=e[1].length,e=parseInt(e[1],16),6===n?Pt(e):3===n?new jt(e>>8&15|e>>4&240,e>>4&15|240&e,(15&e)<<4|15&e,1):8===n?Ut(e>>24&255,e>>16&255,e>>8&255,(255&e)/255):4===n?Ut(e>>12&15|e>>8&240,e>>8&15|e>>4&240,e>>4&15|240&e,((15&e)<<4|15&e)/255):null):(e=At.exec(t))?new jt(e[1],e[2],e[3],1):(e=St.exec(t))?new jt(255*e[1]/100,255*e[2]/100,255*e[3]/100,1):(e=Ct.exec(t))?Ut(e[1],e[2],e[3],e[4]):(e=Rt.exec(t))?Ut(255*e[1]/100,255*e[2]/100,255*e[3]/100,e[4]):(e=Lt.exec(t))?Vt(e[1],e[2]/100,e[3]/100,1):(e=Ot.exec(t))?Vt(e[1],e[2]/100,e[3]/100,e[4]):Dt.hasOwnProperty(t)?Pt(Dt[t]):"transparent"===t?new jt(NaN,NaN,NaN,0):null}function Pt(t){return new jt(t>>16&255,t>>8&255,255&t,1)}function Ut(t,e,n,r){return r<=0&&(t=e=n=NaN),new jt(t,e,n,r)}function Ht(t,e,n,r){return 1===arguments.length?((o=t)instanceof kt||(o=Ft(o)),o?new jt((o=o.rgb()).r,o.g,o.b,o.opacity):new jt):new jt(t,e,n,null==r?1:r);var o}function jt(t,e,n,r){this.r=+t,this.g=+e,this.b=+n,this.opacity=+r}function Bt(){return`#${Yt(this.r)}${Yt(this.g)}${Yt(this.b)}`}function Wt(){const t=qt(this.opacity);return`${1===t?"rgb(":"rgba("}${Gt(this.r)}, ${Gt(this.g)}, ${Gt(this.b)}${1===t?")":`, ${t})`}`}function qt(t){return isNaN(t)?1:Math.max(0,Math.min(1,t))}function Gt(t){return Math.max(0,Math.min(255,Math.round(t)||0))}function Yt(t){return((t=Gt(t))<16?"0":"")+t.toString(16)}function Vt(t,e,n,r){return r<=0?t=e=n=NaN:n<=0||n>=1?t=e=NaN:e<=0&&(t=NaN),new Zt(t,e,n,r)}function Xt(t){if(t instanceof Zt)return new Zt(t.h,t.s,t.l,t.opacity);if(t instanceof kt||(t=Ft(t)),!t)return new Zt;if(t instanceof Zt)return t;var e=(t=t.rgb()).r/255,n=t.g/255,r=t.b/255,o=Math.min(e,n,r),i=Math.max(e,n,r),a=NaN,l=i-o,s=(i+o)/2;return l?(a=e===i?(n-r)/l+6*(n<r):n===i?(r-e)/l+2:(e-n)/l+4,l/=s<.5?i+o:2-i-o,a*=60):l=s>0&&s<1?0:a,new Zt(a,l,s,t.opacity)}function Zt(t,e,n,r){this.h=+t,this.s=+e,this.l=+n,this.opacity=+r}function Jt(t){return(t=(t||0)%360)<0?t+360:t}function Kt(t){return Math.max(0,Math.min(1,t||0))}function Qt(t,e,n){return 255*(t<60?e+(n-e)*t/60:t<180?n:t<240?e+(n-e)*(240-t)/60:e)}xt(kt,Ft,{copy(t){return Object.assign(new this.constructor,this,t)},displayable(){return this.rgb().displayable()},hex:It,formatHex:It,formatHex8:function(){return this.rgb().formatHex8()},formatHsl:function(){return Xt(this).formatHsl()},formatRgb:zt,toString:zt}),xt(jt,Ht,vt(kt,{brighter(t){return t=null==t?$t:Math.pow($t,t),new jt(this.r*t,this.g*t,this.b*t,this.opacity)},darker(t){return t=null==t?_t:Math.pow(_t,t),new jt(this.r*t,this.g*t,this.b*t,this.opacity)},rgb(){return this},clamp(){return new jt(Gt(this.r),Gt(this.g),Gt(this.b),qt(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:Bt,formatHex:Bt,formatHex8:function(){return`#${Yt(this.r)}${Yt(this.g)}${Yt(this.b)}${Yt(255*(isNaN(this.opacity)?1:this.opacity))}`},formatRgb:Wt,toString:Wt})),xt(Zt,(function(t,e,n,r){return 1===arguments.length?Xt(t):new Zt(t,e,n,null==r?1:r)}),vt(kt,{brighter(t){return t=null==t?$t:Math.pow($t,t),new Zt(this.h,this.s,this.l*t,this.opacity)},darker(t){return t=null==t?_t:Math.pow(_t,t),new Zt(this.h,this.s,this.l*t,this.opacity)},rgb(){var t=this.h%360+360*(this.h<0),e=isNaN(t)||isNaN(this.s)?0:this.s,n=this.l,r=n+(n<.5?n:1-n)*e,o=2*n-r;return new jt(Qt(t>=240?t-240:t+120,o,r),Qt(t,o,r),Qt(t<120?t+240:t-120,o,r),this.opacity)},clamp(){return new Zt(Jt(this.h),Kt(this.s),Kt(this.l),qt(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const t=qt(this.opacity);return`${1===t?"hsl(":"hsla("}${Jt(this.h)}, ${100*Kt(this.s)}%, ${100*Kt(this.l)}%${1===t?")":`, ${t})`}`}}));var te=t=>()=>t;function ee(t){return 1==(t=+t)?ne:function(e,n){return n-e?function(t,e,n){return t=Math.pow(t,n),e=Math.pow(e,n)-t,n=1/n,function(r){return Math.pow(t+r*e,n)}}(e,n,t):te(isNaN(e)?n:e)}}function ne(t,e){var n=e-t;return n?function(t,e){return function(n){return t+n*e}}(t,n):te(isNaN(t)?e:t)}var re=function t(e){var n=ee(e);function r(t,e){var r=n((t=Ht(t)).r,(e=Ht(e)).r),o=n(t.g,e.g),i=n(t.b,e.b),a=ne(t.opacity,e.opacity);return function(e){return t.r=r(e),t.g=o(e),t.b=i(e),t.opacity=a(e),t+""}}return r.gamma=t,r}(1);var oe,ie=(oe=function(t){var e=t.length-1;return function(n){var r=n<=0?n=0:n>=1?(n=1,e-1):Math.floor(n*e),o=t[r],i=t[r+1],a=r>0?t[r-1]:2*o-i,l=r<e-1?t[r+2]:2*i-o;return function(t,e,n,r,o){var i=t*t,a=i*t;return((1-3*t+3*i-a)*e+(4-6*i+3*a)*n+(1+3*t+3*i-3*a)*r+a*o)/6}((n-r/e)*e,a,o,i,l)}},function(t){var e,n,r=t.length,o=new Array(r),i=new Array(r),a=new Array(r);for(e=0;e<r;++e)n=Ht(t[e]),o[e]=n.r||0,i[e]=n.g||0,a[e]=n.b||0;return o=oe(o),i=oe(i),a=oe(a),n.opacity=1,function(t){return n.r=o(t),n.g=i(t),n.b=a(t),n+""}});function ae(t,e){e||(e=[]);var n,r=t?Math.min(e.length,t.length):0,o=e.slice();return function(i){for(n=0;n<r;++n)o[n]=t[n]*(1-i)+e[n]*i;return o}}function le(t,e){var n,r=e?e.length:0,o=t?Math.min(r,t.length):0,i=new Array(o),a=new Array(r);for(n=0;n<o;++n)i[n]=me(t[n],e[n]);for(;n<r;++n)a[n]=e[n];return function(t){for(n=0;n<o;++n)a[n]=i[n](t);return a}}function se(t,e){var n=new Date;return t=+t,e=+e,function(r){return n.setTime(t*(1-r)+e*r),n}}function ce(t,e){return t=+t,e=+e,function(n){return t*(1-n)+e*n}}function ue(t,e){var n,r={},o={};for(n in null!==t&&"object"==typeof t||(t={}),null!==e&&"object"==typeof e||(e={}),e)n in t?r[n]=me(t[n],e[n]):o[n]=e[n];return function(t){for(n in r)o[n]=r[n](t);return o}}var de=/[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,fe=new RegExp(de.source,"g");function pe(t,e){var n,r,o,i=de.lastIndex=fe.lastIndex=0,a=-1,l=[],s=[];for(t+="",e+="";(n=de.exec(t))&&(r=fe.exec(e));)(o=r.index)>i&&(o=e.slice(i,o),l[a]?l[a]+=o:l[++a]=o),(n=n[0])===(r=r[0])?l[a]?l[a]+=r:l[++a]=r:(l[++a]=null,s.push({i:a,x:ce(n,r)})),i=fe.lastIndex;return i<e.length&&(o=e.slice(i),l[a]?l[a]+=o:l[++a]=o),l.length<2?s[0]?function(t){return function(e){return t(e)+""}}(s[0].x):function(t){return function(){return t}}(e):(e=s.length,function(t){for(var n,r=0;r<e;++r)l[(n=s[r]).i]=n.x(t);return l.join("")})}function me(t,e){var n,r,o=typeof e;return null==e||"boolean"===o?te(e):("number"===o?ce:"string"===o?(n=Ft(e))?(e=n,re):pe:e instanceof Ft?re:e instanceof Date?se:(r=e,!ArrayBuffer.isView(r)||r instanceof DataView?Array.isArray(e)?le:"function"!=typeof e.valueOf&&"function"!=typeof e.toString||isNaN(e)?ue:ce:ae))(t,e)}function ge(t,e){return t=+t,e=+e,function(n){return Math.round(t*(1-n)+e*n)}}var he=t=>ie(t[t.length-1]),be=he(new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(wt)),ye=he(new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(wt));function we(t,e,n){const r=t.slice();return r[37]=e[n],r[39]=n,r}function xe(t,e,n){const r=t.slice();return r[40]=e[n],r}function ve(t,e,n){const r=t.slice();return r[43]=e[n],r[39]=n,r}function ke(e){let n;return{c(){n=p("div"),n.textContent="Missing tokens will show on completion.",w(n,"class","text-sm border-b text-red-700")},m(t,e){u(t,n,e)},p:t,i:t,o:t,d(t){t&&d(n)}}}function _e(t){let e,n,r,o,i,a,l,s,f,m;o=new mt({props:{token:t[10],index:-1,underlineStyle:t[5](t[10]),bgStyle:t[6](t[10])}});let g="None"!==t[2]&&$e(t),b="None"!==t[3]&&Ee(t),y=void 0!==t[10].top_k&&Ne(t);return{c(){e=p("div"),n=p("div"),r=p("div"),V(o.$$.fragment),i=h(),a=p("table"),l=p("tbody"),g&&g.c(),s=h(),b&&b.c(),f=h(),y&&y.c(),w(r,"class","mb-5 mt-1"),w(l,"class","text-xs tracking-wider"),w(a,"class","w-full"),w(n,"class","text-2xl px-1 pb-1 text-left w-full bg-white"),w(e,"class","col-1 flex flex-col items-center")},m(t,d){u(t,e,d),c(e,n),c(n,r),X(o,r,null),c(n,i),c(n,a),c(a,l),g&&g.m(l,null),c(l,s),b&&b.m(l,null),c(e,f),y&&y.m(e,null),m=!0},p(t,n){const r={};1024&n[0]&&(r.token=t[10]),1056&n[0]&&(r.underlineStyle=t[5](t[10])),1088&n[0]&&(r.bgStyle=t[6](t[10])),o.$set(r),"None"!==t[2]?g?g.p(t,n):(g=$e(t),g.c(),g.m(l,s)):g&&(g.d(1),g=null),"None"!==t[3]?b?b.p(t,n):(b=Ee(t),b.c(),b.m(l,null)):b&&(b.d(1),b=null),void 0!==t[10].top_k?y?y.p(t,n):(y=Ne(t),y.c(),y.m(e,null)):y&&(y.d(1),y=null)},i(t){m||(q(o.$$.fragment,t),m=!0)},o(t){G(o.$$.fragment,t),m=!1},d(t){t&&d(e),Z(o),g&&g.d(),b&&b.d(),y&&y.d()}}}function $e(t){let e,n,r,o,i,a,l,s,f,m=t[11](t[10],t[2])+"";return{c(){e=p("tr"),n=p("td"),r=p("span"),o=g(t[2]),a=h(),l=p("td"),s=p("span"),f=g(m),w(r,"style",i=t[6](t[10])),w(s,"class","pl-1"),w(l,"class","text-right")},m(t,i){u(t,e,i),c(e,n),c(n,r),c(r,o),c(e,a),c(e,l),c(l,s),c(s,f)},p(t,e){4&e[0]&&x(o,t[2]),1088&e[0]&&i!==(i=t[6](t[10]))&&w(r,"style",i),1028&e[0]&&m!==(m=t[11](t[10],t[2])+"")&&x(f,m)},d(t){t&&d(e)}}}function Ee(t){let e,n,r,o,i,a,l,s,f,m=t[11](t[10],t[3])+"";return{c(){e=p("tr"),n=p("td"),r=p("span"),o=g(t[3]),a=h(),l=p("td"),s=p("span"),f=g(m),w(r,"class","border-b-2"),w(r,"style",i=t[5](t[10])),w(l,"class","text-right")},m(t,i){u(t,e,i),c(e,n),c(n,r),c(r,o),c(e,a),c(e,l),c(l,s),c(s,f)},p(t,e){8&e[0]&&x(o,t[3]),1056&e[0]&&i!==(i=t[5](t[10]))&&w(r,"style",i),1032&e[0]&&m!==(m=t[11](t[10],t[3])+"")&&x(f,m)},d(t){t&&d(e)}}}function Ne(t){let e,n,r,o,i,a,l=Y(t[10].top_k),s=[];for(let e=0;e<l.length;e+=1)s[e]=Te(ve(t,l,e));return{c(){e=p("hr"),n=h(),r=p("table"),o=p("thead"),o.innerHTML='<tr><th class="px-1 pb-1 font-normal text-xs text-left text-gray-700 tracking-wide">Candidate</th> <th class="px-1 pb-1 font-normal text-xs text-right text-gray-700 tracking-wide">Prob</th></tr>',i=h(),a=p("tbody");for(let t=0;t<s.length;t+=1)s[t].c();w(e,"class","bg-gray-400 w-full my-2"),w(r,"class","w-full")},m(t,l){u(t,e,l),u(t,n,l),u(t,r,l),c(r,o),c(r,i),c(r,a);for(let t=0;t<s.length;t+=1)s[t]&&s[t].m(a,null)},p(t,e){if(132096&e[0]){let n;for(l=Y(t[10].top_k),n=0;n<l.length;n+=1){const r=ve(t,l,n);s[n]?s[n].p(r,e):(s[n]=Te(r),s[n].c(),s[n].m(a,null))}for(;n<s.length;n+=1)s[n].d(1);s.length=l.length}},d(t){t&&(d(e),d(n),d(r)),f(s,t)}}}function Te(t){let e,n,r,o,i,a,l,s,f,m=t[17](t[43].text)+"",b=t[43].prob.toFixed(3)+"";return{c(){e=p("tr"),n=p("td"),r=p("span"),i=h(),a=p("td"),l=g(b),f=h(),w(r,"class","bg-gray-200"),w(n,"class",o="px-1 text-left font-mono text-sm decoration-2 "+(t[43].is_masked?"line-through":"")),w(a,"class",s="px-1 text-right font-mono text-sm decoration-2 "+(t[43].is_masked?"line-through":"")),w(e,"class",""+(5===t[39]?"border-t border-dashed border-gray-300":""))},m(t,o){u(t,e,o),c(e,n),c(n,r),r.innerHTML=m,c(e,i),c(e,a),c(a,l),c(e,f)},p(t,e){1024&e[0]&&m!==(m=t[17](t[43].text)+"")&&(r.innerHTML=m),1024&e[0]&&o!==(o="px-1 text-left font-mono text-sm decoration-2 "+(t[43].is_masked?"line-through":""))&&w(n,"class",o),1024&e[0]&&b!==(b=t[43].prob.toFixed(3)+"")&&x(l,b),1024&e[0]&&s!==(s="px-1 text-right font-mono text-sm decoration-2 "+(t[43].is_masked?"line-through":""))&&w(a,"class",s)},d(t){t&&d(e)}}}function Me(e){let n,r,o,i;return n=new mt({props:{token:e[18],index:-1}}),{c(){V(n.$$.fragment),r=h(),o=p("div"),w(o,"class","basis-full h-2")},m(t,e){X(n,t,e),u(t,r,e),u(t,o,e),i=!0},p:t,i(t){i||(q(n.$$.fragment,t),i=!0)},o(t){G(n.$$.fragment,t),i=!1},d(t){t&&(d(r),d(o)),Z(n,t)}}}function Ae(t){let e;let n=function(t){return 0===t[39]?Ce:Se}(t),r=n(t);return{c(){r.c(),e=b()},m(t,n){r.m(t,n),u(t,e,n)},d(t){t&&d(e),r.d(t)}}}function Se(t){let e,n,r=Y({length:2}),o=[];for(let e=0;e<r.length;e+=1)o[e]=Re(xe(t,r,e));return{c(){for(let t=0;t<o.length;t+=1)o[t].c();e=h(),n=p("div"),w(n,"class","basis-full h-0")},m(t,r){for(let e=0;e<o.length;e+=1)o[e]&&o[e].m(t,r);u(t,e,r),u(t,n,r)},d(t){t&&(d(e),d(n)),f(o,t)}}}function Ce(t){let e;return{c(){e=p("div"),w(e,"class","basis-full h-2")},m(t,n){u(t,e,n)},d(t){t&&d(e)}}}function Re(e){let n,r,o;return{c(){n=p("div"),r=h(),o=p("span"),o.textContent=" ",w(n,"class","basis-full h-0"),w(o,"class","inline-block")},m(t,e){u(t,n,e),u(t,r,e),u(t,o,e)},p:t,d(t){t&&(d(n),d(r),d(o))}}}function Le(t){let e,n,r,o=!0===t[37].special&&""!==t[37].role&&Ae(t);return n=new mt({props:{token:t[37],index:t[39],underlineStyle:t[5](t[37]),bgStyle:t[6](t[37])}}),{c(){o&&o.c(),e=h(),V(n.$$.fragment)},m(t,i){o&&o.m(t,i),u(t,e,i),X(n,t,i),r=!0},p(t,r){!0===t[37].special&&""!==t[37].role?o||(o=Ae(t),o.c(),o.m(e.parentNode,e)):o&&(o.d(1),o=null);const i={};16&r[0]&&(i.token=t[37]),48&r[0]&&(i.underlineStyle=t[5](t[37])),80&r[0]&&(i.bgStyle=t[6](t[37])),n.$set(i)},i(t){r||(q(n.$$.fragment,t),r=!0)},o(t){G(n.$$.fragment,t),r=!1},d(t){t&&d(e),o&&o.d(t),Z(n,t)}}}function Oe(t){let e;return{c(){e=p("span"),e.textContent=" ",w(e,"class","inline-block mt-2 border-b-2 border-white bg-gray-700 animate-cpulse")},m(t,n){u(t,e,n)},d(t){t&&d(e)}}}function De(t){let e,n,o,i,a,s,m,g,b,x,k,_,$;const E=[_e,ke],N=[];function T(t,e){return t[10]?0:1}o=T(t),i=N[o]=E[o](t);let M=t[1]&&Me(t),A=Y(t[4]),S=[];for(let e=0;e<A.length;e+=1)S[e]=Le(we(t,A,e));const C=t=>G(S[t],1,1,(()=>{S[t]=null}));let R=!1===t[0]&&Oe();return{c(){e=p("div"),n=p("div"),i.c(),a=h(),s=p("div"),m=p("div"),g=p("span"),M&&M.c(),b=h();for(let t=0;t<S.length;t+=1)S[t].c();x=h(),R&&R.c(),w(e,"class","px-1 pt-1 pb-3 absolute opacity-95 bg-white shadow border border-gray-300 pointer-events-none z-50"),v(e,"top",t[9]+"px"),v(e,"left",t[8]+"px"),v(e,"display","none"),w(g,"class","flex flex-wrap text-sm"),w(g,"role","main"),w(m,"class","px-4"),w(s,"class","pt-6 pb-6 flex text-gray-800 font-token")},m(r,i){u(r,e,i),c(e,n),N[o].m(n,null),t[27](e),u(r,a,i),u(r,s,i),c(s,m),c(m,g),M&&M.m(g,null),c(g,b);for(let t=0;t<S.length;t+=1)S[t]&&S[t].m(g,null);c(g,x),R&&R.m(g,null),k=!0,_||($=[l(gt.call(null,g,Ie)),y(g,"longmouseover",t[12]),y(g,"longmouseout",t[14]),y(g,"mouseover",t[13]),y(g,"mouseout",t[15]),y(g,"focus",t[16]),y(g,"blur",t[16])],_=!0)},p(t,r){let a=o;if(o=T(t),o===a?N[o].p(t,r):(B(),G(N[a],1,1,(()=>{N[a]=null})),W(),i=N[o],i?i.p(t,r):(i=N[o]=E[o](t),i.c()),q(i,1),i.m(n,null)),(!k||512&r[0])&&v(e,"top",t[9]+"px"),(!k||256&r[0])&&v(e,"left",t[8]+"px"),t[1]?M?(M.p(t,r),2&r[0]&&q(M,1)):(M=Me(t),M.c(),q(M,1),M.m(g,b)):M&&(B(),G(M,1,1,(()=>{M=null})),W()),112&r[0]){let e;for(A=Y(t[4]),e=0;e<A.length;e+=1){const n=we(t,A,e);S[e]?(S[e].p(n,r),q(S[e],1)):(S[e]=Le(n),S[e].c(),q(S[e],1),S[e].m(g,x))}for(B(),e=A.length;e<S.length;e+=1)C(e);W()}!1===t[0]?R||(R=Oe(),R.c(),R.m(g,null)):R&&(R.d(1),R=null)},i(t){if(!k){q(i),q(M);for(let t=0;t<A.length;t+=1)q(S[t]);k=!0}},o(t){G(i),G(M),S=S.filter(Boolean);for(let t=0;t<S.length;t+=1)G(S[t]);k=!1},d(n){n&&(d(e),d(a),d(s)),N[o].d(),t[27](null),M&&M.d(),f(S,n),R&&R.d(),_=!1,r($)}}}const Ie=200;function ze(t,e,n){let{textComponents:r}=e,{tokenDetails:o}=e,{isCompleted:i}=e,{isError:a}=e,{requireFullReplay:l=!1}=e,{bgField:s="Token"}=e,{underlineField:c="Probability"}=e,u=t=>"",d=t=>"";const f=t=>{const e=(t=>{const e=t.match(/rgba?\(\s*(\d+),\s*(\d+),\s*(\d+)/);return e?.299*parseInt(e[1],10)+.587*parseInt(e[2],10)+.114*parseInt(e[3],10):(console.error("Invalid RGBA format."),0)})(t);return e>186?"rgba(0, 0, 0, 1)":"rgba(255, 255, 255, 1)"},p=(t,e)=>{if(void 0===t)return"";let n=be(t);return`background-color: ${n}; color: ${f(n)};`},m=(t,e)=>{if(void 0===t)return"";return`border-bottom-color: ${ye(.7*t)};`},g=t=>{let e="";return t.is_input?e="rgba(255, 255, 255, 0)":t.is_force_forwarded?e="rgba(243, 244, 246, 1)":t.is_generated?e="rgba(229, 231, 235, 1)":(console.log(`ERROR: token ${t.text} does not have emit flags.`),e="rgba(255, 255, 255, 0)"),`background-color: ${e};`},h=(t,e,n,r)=>{let o=!1,i=!1;return t<=n&&e-1>=n?o=!0:t<=r-1&&e>=r?(o=!0,i=!0):t>=n&&e<=r&&(o=!0),[o,i]};let b,y,w=[],x=[],v=[],k=new Set,_={},$=0,E={},N=0,T=0;let M="",A="";return t.$$set=t=>{"textComponents"in t&&n(19,r=t.textComponents),"tokenDetails"in t&&n(20,o=t.tokenDetails),"isCompleted"in t&&n(0,i=t.isCompleted),"isError"in t&&n(21,a=t.isError),"requireFullReplay"in t&&n(1,l=t.requireFullReplay),"bgField"in t&&n(2,s=t.bgField),"underlineField"in t&&n(3,c=t.underlineField)},t.$$.update=()=>{if(133693469&t.$$.dirty[0]){for(0===r.length&&(n(4,w=[]),n(22,x=[]),n(23,v=[]),k.clear(),n(24,_={}),n(25,$=0));$<r.length;n(25,$+=1)){const t=r[$];if(nt(t))x.push(t),v.push(t.closer_text||"");else if(rt(t))if(0===x.length)if(0!==v.length&&v[v.length-1]===t.value){const e={text:t.value,prob:1,latency_ms:0,role:"",special:!0,is_input:t.is_input,is_force_forwarded:t.is_force_forwarded,is_generated:t.is_generated};k.add(e.text),w.push(e),v.pop()}else{const e={text:t.value,prob:1,latency_ms:0,role:"",special:!1,is_input:t.is_input,is_force_forwarded:t.is_force_forwarded,is_generated:t.is_generated};w.push(e)}else{const e=x[x.length-1];e.text&&e.text!==t.value&&console.log(`Active role text does not match next text output: ${e.text} - ${t.value}`);const r={text:t.value,prob:1,latency_ms:0,role:e.name||"",special:!0,is_input:t.is_input,is_force_forwarded:t.is_force_forwarded,is_generated:t.is_generated};""!==r.role&&n(24,_[t.value]=r.role,_),k.add(r.text),w.push(r),x.pop()}}0!==x.length||v.length;if(o.length>0){const t=function(t,e){const n=[];for(const r of e){let e=0;for(;-1!==(e=t.indexOf(r,e));)n.push([e,e+r.length,r]),e+=r.length}return n.sort(((t,e)=>t[0]===e[0]?t[1]-e[1]:t[0]-e[0])),n}(o.map((t=>t.text)).join(""),Array.from(k));n(4,w=[]);let e=0,r=0,i=!1;for(const a of o){e=r,r=e+a.text.length;let o=!1,l="";if(t.length>0){let[n,a,s]=t[0];e>=a&&(t.shift(),t.length>0&&([n,a,s]=t[0]));let[c,u]=h(e,r,n,a);if(c){if(Object.keys(_).includes(s)&&(i||(l=_[s],i=!0)),t.length>1){let[n,o,a]=t[1];const[s,c]=h(e,r,n,o);s&&Object.keys(_).includes(a)&&(l=_[a],i=!0,u=!1)}u||(o=!0)}else i=!1}const s={text:a.text,prob:a.prob,latency_ms:a.latency_ms,role:l,special:o,is_input:a.is_input,is_force_forwarded:a.is_force_forwarded,is_generated:a.is_generated,top_k:a.top_k};n(26,E["latency.max"]=Math.max(s.latency_ms,E["latency.max"]||0),E),w.push(s)}}n(5,u=!i||a?t=>"border: none;":"Probability"===c?t=>m(t.prob):"Latency (ms)"===c?t=>m(Math.log(t.latency_ms)/Math.log(E["latency.max"])):t=>"border: none;"),!i||a||"Type"===s?n(6,d=t=>g(t)):"Probability"===s?n(6,d=t=>p(t.prob)):"Latency (ms)"===s?(n(6,d=t=>p(Math.log(t.latency_ms)/Math.log(E["latency.max"]))),console.log(E["latency.max"])):n(6,d=t=>""),n(0,i),n(19,r),n(36,k),n(25,$),n(22,x),n(23,v),n(4,w),n(20,o),n(24,_),n(26,E),n(21,a),n(3,c),n(2,s),n(21,a),n(19,r),n(36,k),n(25,$),n(22,x),n(23,v),n(4,w),n(20,o),n(24,_),n(26,E),n(0,i),n(3,c),n(2,s),n(20,o),n(19,r),n(36,k),n(25,$),n(22,x),n(23,v),n(4,w),n(24,_),n(26,E),n(0,i),n(21,a),n(3,c),n(2,s),n(19,r),n(36,k),n(25,$),n(22,x),n(23,v),n(4,w),n(20,o),n(24,_),n(26,E),n(0,i),n(21,a),n(3,c),n(2,s),n(4,w),n(19,r),n(36,k),n(25,$),n(22,x),n(23,v),n(20,o),n(24,_),n(26,E),n(0,i),n(21,a),n(3,c),n(2,s)}},[i,l,s,c,w,u,d,b,N,T,y,(t,e)=>{if("Probability"===e)return t.prob.toFixed(3);if("Latency (ms)"===e)return t.latency_ms.toFixed(0);if("Type"===e){if(t.is_input)return"Input";if(t.is_force_forwarded)return"Forwarded";if(t.is_generated)return"Generated"}else if("None"===e)return""},t=>{const e=t.detail.target;if(e.matches(".token-grid-item")){const t=e.dataset.index,r=15,o=10,i=e.getBoundingClientRect();n(8,N=i.left+window.scrollX+i.width/2+r),n(9,T=i.bottom+window.scrollY+o),n(7,b.style.display="block",b);const a=Number(t);n(10,y=w[a]),N+b.offsetWidth>window.innerWidth&&n(8,N=window.innerWidth-b.offsetWidth),T+b.offsetHeight>window.innerHeight&&n(9,T=window.innerHeight-b.offsetHeight)}},t=>{var e;const n=t.target;if(n.matches(".token-grid-item")){const t=n.dataset.index,r=null===(e=n.parentElement)||void 0===e?void 0:e.querySelectorAll(`.token-grid-item[data-index="${t}"]`);if(r)for(const t of r){const e=t;M=e.style.color,A=e.style.backgroundColor,e.style.color="rgb(249, 250, 251)",e.style.backgroundColor="rgb(75, 85, 99)"}}},t=>{t.detail.target.matches(".token-grid-item")&&n(7,b.style.display="none",b)},t=>{var e;const n=t.target;if(n.matches(".token-grid-item")){const t=n.dataset.index,r=null===(e=n.parentElement)||void 0===e?void 0:e.querySelectorAll(`.token-grid-item[data-index="${t}"]`);if(r)for(const t of r){const e=t;e.style.color=M,e.style.backgroundColor=A}}},t=>{},t=>yt.sanitize(t.replaceAll(" ","&nbsp;").replaceAll("\t","\\t").replaceAll("\n","\\n")),{text:"...",prob:1,latency_ms:0,role:"",special:!1,is_input:!0,is_force_forwarded:!1,is_generated:!0},r,o,a,x,v,_,$,E,function(t){C[t?"unshift":"push"]((()=>{b=t,n(7,b)}))}]}class Fe extends Q{constructor(t){super(),K(this,t,ze,De,i,{textComponents:19,tokenDetails:20,isCompleted:0,isError:21,requireFullReplay:1,bgField:2,underlineField:3},null,[-1,-1])}}function Pe(t){let e,n=null;return T((()=>{e=document.querySelector("html"),window.addEventListener("load",(()=>{n=setInterval((()=>{const t=e.getBoundingClientRect().height;if(0!==t&&e.checkVisibility()){const e={type:"resize",content:{height:`${t}px`,width:"100%"}};it.set(e)}}),20)}))})),M((()=>{clearInterval(n)})),[]}class Ue extends Q{constructor(t){super(),K(this,t,Pe,null,i,{})}}const{window:He}=s;function je(e){let n,r;return{c:t,m(t,o){n||(r=y(He,"message",e[0]),n=!0)},p:t,i:t,o:t,d(t){n=!1,r()}}}function Be(t){let e=null;return T((()=>{e=it.subscribe((t=>{void 0!==t&&window.parent.postMessage(t,"*")}))})),M((()=>{e&&e()})),[t=>{if(t.source===window.parent&&"type"in t.data&&"kernelmsg"===t.data.type){let e=t.data;ot.set(e)}}]}class We extends Q{constructor(t){super(),K(this,t,Be,je,i,{})}}function qe(t,e){return null==t||null==e?NaN:t<e?-1:t>e?1:t>=e?0:NaN}function Ge(t,e){return null==t||null==e?NaN:e<t?-1:e>t?1:e>=t?0:NaN}function Ye(t){let e,n,r;function o(t,r,o=0,i=t.length){if(o<i){if(0!==e(r,r))return i;do{const e=o+i>>>1;n(t[e],r)<0?o=e+1:i=e}while(o<i)}return o}return 2!==t.length?(e=qe,n=(e,n)=>qe(t(e),n),r=(e,n)=>t(e)-n):(e=t===qe||t===Ge?t:Ve,n=t,r=t),{left:o,center:function(t,e,n=0,i=t.length){const a=o(t,e,n,i-1);return a>n&&r(t[a-1],e)>-r(t[a],e)?a-1:a},right:function(t,r,o=0,i=t.length){if(o<i){if(0!==e(r,r))return i;do{const e=o+i>>>1;n(t[e],r)<=0?o=e+1:i=e}while(o<i)}return o}}}function Ve(){return 0}const Xe=Ye(qe).right;Ye((function(t){return null===t?NaN:+t})).center;const Ze=Math.sqrt(50),Je=Math.sqrt(10),Ke=Math.sqrt(2);function Qe(t,e,n){const r=(e-t)/Math.max(0,n),o=Math.floor(Math.log10(r)),i=r/Math.pow(10,o),a=i>=Ze?10:i>=Je?5:i>=Ke?2:1;let l,s,c;return o<0?(c=Math.pow(10,-o)/a,l=Math.round(t*c),s=Math.round(e*c),l/c<t&&++l,s/c>e&&--s,c=-c):(c=Math.pow(10,o)*a,l=Math.round(t/c),s=Math.round(e/c),l*c<t&&++l,s*c>e&&--s),s<l&&.5<=n&&n<2?Qe(t,e,2*n):[l,s,c]}function tn(t,e,n){return Qe(t=+t,e=+e,n=+n)[2]}function en(t,e){switch(arguments.length){case 0:break;case 1:this.range(t);break;default:this.range(e).domain(t)}return this}function nn(t){return+t}var rn=[0,1];function on(t){return t}function an(t,e){return(e-=t=+t)?function(n){return(n-t)/e}:(n=isNaN(e)?NaN:.5,function(){return n});var n}function ln(t,e,n){var r=t[0],o=t[1],i=e[0],a=e[1];return o<r?(r=an(o,r),i=n(a,i)):(r=an(r,o),i=n(i,a)),function(t){return i(r(t))}}function sn(t,e,n){var r=Math.min(t.length,e.length)-1,o=new Array(r),i=new Array(r),a=-1;for(t[r]<t[0]&&(t=t.slice().reverse(),e=e.slice().reverse());++a<r;)o[a]=an(t[a],t[a+1]),i[a]=n(e[a],e[a+1]);return function(e){var n=Xe(t,e,1,r)-1;return i[n](o[n](e))}}function cn(){var t,e,n,r,o,i,a=rn,l=rn,s=me,c=on;function u(){var t,e,n,s=Math.min(a.length,l.length);return c!==on&&(t=a[0],e=a[s-1],t>e&&(n=t,t=e,e=n),c=function(n){return Math.max(t,Math.min(e,n))}),r=s>2?sn:ln,o=i=null,d}function d(e){return null==e||isNaN(e=+e)?n:(o||(o=r(a.map(t),l,s)))(t(c(e)))}return d.invert=function(n){return c(e((i||(i=r(l,a.map(t),ce)))(n)))},d.domain=function(t){return arguments.length?(a=Array.from(t,nn),u()):a.slice()},d.range=function(t){return arguments.length?(l=Array.from(t),u()):l.slice()},d.rangeRound=function(t){return l=Array.from(t),s=ge,u()},d.clamp=function(t){return arguments.length?(c=!!t||on,u()):c!==on},d.interpolate=function(t){return arguments.length?(s=t,u()):s},d.unknown=function(t){return arguments.length?(n=t,d):n},function(n,r){return t=n,e=r,u()}}function un(t,e){if((n=(t=e?t.toExponential(e-1):t.toExponential()).indexOf("e"))<0)return null;var n,r=t.slice(0,n);return[r.length>1?r[0]+r.slice(2):r,+t.slice(n+1)]}function dn(t){return(t=un(Math.abs(t)))?t[1]:NaN}var fn,pn=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function mn(t){if(!(e=pn.exec(t)))throw new Error("invalid format: "+t);var e;return new gn({fill:e[1],align:e[2],sign:e[3],symbol:e[4],zero:e[5],width:e[6],comma:e[7],precision:e[8]&&e[8].slice(1),trim:e[9],type:e[10]})}function gn(t){this.fill=void 0===t.fill?" ":t.fill+"",this.align=void 0===t.align?">":t.align+"",this.sign=void 0===t.sign?"-":t.sign+"",this.symbol=void 0===t.symbol?"":t.symbol+"",this.zero=!!t.zero,this.width=void 0===t.width?void 0:+t.width,this.comma=!!t.comma,this.precision=void 0===t.precision?void 0:+t.precision,this.trim=!!t.trim,this.type=void 0===t.type?"":t.type+""}function hn(t,e){var n=un(t,e);if(!n)return t+"";var r=n[0],o=n[1];return o<0?"0."+new Array(-o).join("0")+r:r.length>o+1?r.slice(0,o+1)+"."+r.slice(o+1):r+new Array(o-r.length+2).join("0")}mn.prototype=gn.prototype,gn.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var bn={"%":(t,e)=>(100*t).toFixed(e),b:t=>Math.round(t).toString(2),c:t=>t+"",d:function(t){return Math.abs(t=Math.round(t))>=1e21?t.toLocaleString("en").replace(/,/g,""):t.toString(10)},e:(t,e)=>t.toExponential(e),f:(t,e)=>t.toFixed(e),g:(t,e)=>t.toPrecision(e),o:t=>Math.round(t).toString(8),p:(t,e)=>hn(100*t,e),r:hn,s:function(t,e){var n=un(t,e);if(!n)return t+"";var r=n[0],o=n[1],i=o-(fn=3*Math.max(-8,Math.min(8,Math.floor(o/3))))+1,a=r.length;return i===a?r:i>a?r+new Array(i-a+1).join("0"):i>0?r.slice(0,i)+"."+r.slice(i):"0."+new Array(1-i).join("0")+un(t,Math.max(0,e+i-1))[0]},X:t=>Math.round(t).toString(16).toUpperCase(),x:t=>Math.round(t).toString(16)};function yn(t){return t}var wn,xn,vn,kn=Array.prototype.map,_n=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function $n(t){var e,n,r=void 0===t.grouping||void 0===t.thousands?yn:(e=kn.call(t.grouping,Number),n=t.thousands+"",function(t,r){for(var o=t.length,i=[],a=0,l=e[0],s=0;o>0&&l>0&&(s+l+1>r&&(l=Math.max(1,r-s)),i.push(t.substring(o-=l,o+l)),!((s+=l+1)>r));)l=e[a=(a+1)%e.length];return i.reverse().join(n)}),o=void 0===t.currency?"":t.currency[0]+"",i=void 0===t.currency?"":t.currency[1]+"",a=void 0===t.decimal?".":t.decimal+"",l=void 0===t.numerals?yn:function(t){return function(e){return e.replace(/[0-9]/g,(function(e){return t[+e]}))}}(kn.call(t.numerals,String)),s=void 0===t.percent?"%":t.percent+"",c=void 0===t.minus?"−":t.minus+"",u=void 0===t.nan?"NaN":t.nan+"";function d(t){var e=(t=mn(t)).fill,n=t.align,d=t.sign,f=t.symbol,p=t.zero,m=t.width,g=t.comma,h=t.precision,b=t.trim,y=t.type;"n"===y?(g=!0,y="g"):bn[y]||(void 0===h&&(h=12),b=!0,y="g"),(p||"0"===e&&"="===n)&&(p=!0,e="0",n="=");var w="$"===f?o:"#"===f&&/[boxX]/.test(y)?"0"+y.toLowerCase():"",x="$"===f?i:/[%p]/.test(y)?s:"",v=bn[y],k=/[defgprs%]/.test(y);function _(t){var o,i,s,f=w,_=x;if("c"===y)_=v(t)+_,t="";else{var $=(t=+t)<0||1/t<0;if(t=isNaN(t)?u:v(Math.abs(t),h),b&&(t=function(t){t:for(var e,n=t.length,r=1,o=-1;r<n;++r)switch(t[r]){case".":o=e=r;break;case"0":0===o&&(o=r),e=r;break;default:if(!+t[r])break t;o>0&&(o=0)}return o>0?t.slice(0,o)+t.slice(e+1):t}(t)),$&&0==+t&&"+"!==d&&($=!1),f=($?"("===d?d:c:"-"===d||"("===d?"":d)+f,_=("s"===y?_n[8+fn/3]:"")+_+($&&"("===d?")":""),k)for(o=-1,i=t.length;++o<i;)if(48>(s=t.charCodeAt(o))||s>57){_=(46===s?a+t.slice(o+1):t.slice(o))+_,t=t.slice(0,o);break}}g&&!p&&(t=r(t,1/0));var E=f.length+t.length+_.length,N=E<m?new Array(m-E+1).join(e):"";switch(g&&p&&(t=r(N+t,N.length?m-_.length:1/0),N=""),n){case"<":t=f+t+_+N;break;case"=":t=f+N+t+_;break;case"^":t=N.slice(0,E=N.length>>1)+f+t+_+N.slice(E);break;default:t=N+f+t+_}return l(t)}return h=void 0===h?6:/[gprs]/.test(y)?Math.max(1,Math.min(21,h)):Math.max(0,Math.min(20,h)),_.toString=function(){return t+""},_}return{format:d,formatPrefix:function(t,e){var n=d(((t=mn(t)).type="f",t)),r=3*Math.max(-8,Math.min(8,Math.floor(dn(e)/3))),o=Math.pow(10,-r),i=_n[8+r/3];return function(t){return n(o*t)+i}}}}function En(t,e,n,r){var o,i=function(t,e,n){n=+n;const r=(e=+e)<(t=+t),o=r?tn(e,t,n):tn(t,e,n);return(r?-1:1)*(o<0?1/-o:o)}(t,e,n);switch((r=mn(null==r?",f":r)).type){case"s":var a=Math.max(Math.abs(t),Math.abs(e));return null!=r.precision||isNaN(o=function(t,e){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(dn(e)/3)))-dn(Math.abs(t)))}(i,a))||(r.precision=o),vn(r,a);case"":case"e":case"g":case"p":case"r":null!=r.precision||isNaN(o=function(t,e){return t=Math.abs(t),e=Math.abs(e)-t,Math.max(0,dn(e)-dn(t))+1}(i,Math.max(Math.abs(t),Math.abs(e))))||(r.precision=o-("e"===r.type));break;case"f":case"%":null!=r.precision||isNaN(o=function(t){return Math.max(0,-dn(Math.abs(t)))}(i))||(r.precision=o-2*("%"===r.type))}return xn(r)}function Nn(t){var e=t.domain;return t.ticks=function(t){var n=e();return function(t,e,n){if(!((n=+n)>0))return[];if((t=+t)==(e=+e))return[t];const r=e<t,[o,i,a]=r?Qe(e,t,n):Qe(t,e,n);if(!(i>=o))return[];const l=i-o+1,s=new Array(l);if(r)if(a<0)for(let t=0;t<l;++t)s[t]=(i-t)/-a;else for(let t=0;t<l;++t)s[t]=(i-t)*a;else if(a<0)for(let t=0;t<l;++t)s[t]=(o+t)/-a;else for(let t=0;t<l;++t)s[t]=(o+t)*a;return s}(n[0],n[n.length-1],null==t?10:t)},t.tickFormat=function(t,n){var r=e();return En(r[0],r[r.length-1],null==t?10:t,n)},t.nice=function(n){null==n&&(n=10);var r,o,i=e(),a=0,l=i.length-1,s=i[a],c=i[l],u=10;for(c<s&&(o=s,s=c,c=o,o=a,a=l,l=o);u-- >0;){if((o=tn(s,c,n))===r)return i[a]=s,i[l]=c,e(i);if(o>0)s=Math.floor(s/o)*o,c=Math.ceil(c/o)*o;else{if(!(o<0))break;s=Math.ceil(s*o)/o,c=Math.floor(c*o)/o}r=o}return t},t}function Tn(){var t=cn()(on,on);return t.copy=function(){return e=t,Tn().domain(e.domain()).range(e.range()).interpolate(e.interpolate()).clamp(e.clamp()).unknown(e.unknown());var e},en.apply(t,arguments),Nn(t)}function Mn(t,e,n){const r=t.slice();return r[12]=e[n],r[14]=n,r}function An(t){let e,n,r,o,i;return{c(){e=m("rect"),w(e,"x",n=t[7](t[14])),w(e,"y",r=t[6](Math.max(t[12],Cn))),w(e,"width",o=t[5]-1),w(e,"height",i=t[6](0)-t[6](Math.max(t[12],Cn))),w(e,"class",t[1])},m(t,n){u(t,e,n)},p(t,a){128&a&&n!==(n=t[7](t[14]))&&w(e,"x",n),80&a&&r!==(r=t[6](Math.max(t[12],Cn)))&&w(e,"y",r),32&a&&o!==(o=t[5]-1)&&w(e,"width",o),80&a&&i!==(i=t[6](0)-t[6](Math.max(t[12],Cn)))&&w(e,"height",i),2&a&&w(e,"class",t[1])},d(t){t&&d(e)}}}function Sn(e){let n,r,o,i,a=Y(e[4]),l=[];for(let t=0;t<a.length;t+=1)l[t]=An(Mn(e,a,t));return{c(){n=p("div"),r=m("svg"),o=m("g");for(let t=0;t<l.length;t+=1)l[t].c();w(r,"class",e[0]),w(n,"class","flex items-center"),I((()=>e[11].call(n)))},m(t,a){u(t,n,a),c(n,r),c(r,o);for(let t=0;t<l.length;t+=1)l[t]&&l[t].m(o,null);i=function(t,e){"static"===getComputedStyle(t).position&&(t.style.position="relative");const n=p("iframe");n.setAttribute("style","display: block; position: absolute; top: 0; left: 0; width: 100%; height: 100%; overflow: hidden; border: 0; opacity: 0; pointer-events: none; z-index: -1;"),n.setAttribute("aria-hidden","true"),n.tabIndex=-1;const r=$();let o;return r?(n.src="data:text/html,<script>onresize=function(){parent.postMessage(0,'*')}<\/script>",o=y(window,"message",(t=>{t.source===n.contentWindow&&e()}))):(n.src="about:blank",n.onload=()=>{o=y(n.contentWindow,"resize",e),e()}),c(t,n),()=>{(r||o&&n.contentWindow)&&o(),d(n)}}(n,e[11].bind(n))},p(t,[e]){if(242&e){let n;for(a=Y(t[4]),n=0;n<a.length;n+=1){const r=Mn(t,a,n);l[n]?l[n].p(r,e):(l[n]=An(r),l[n].c(),l[n].m(o,null))}for(;n<l.length;n+=1)l[n].d(1);l.length=a.length}1&e&&w(r,"class",t[0])},i:t,o:t,d(t){t&&d(n),f(l,t),i()}}}wn=$n({thousands:",",grouping:[3],currency:["$",""]}),xn=wn.format,vn=wn.formatPrefix;let Cn=.05;function Rn(t,e,n){let r,o,i,a,l,{values:s}=e,{svgClass:c}=e,{rectClass:u}=e,{padding:d={left:0,right:0,top:0,bottom:0}}=e,f=0,p=0;return t.$$set=t=>{"values"in t&&n(8,s=t.values),"svgClass"in t&&n(0,c=t.svgClass),"rectClass"in t&&n(1,u=t.rectClass),"padding"in t&&n(9,d=t.padding)},t.$$.update=()=>{256&t.$$.dirty&&n(4,r=s),536&t.$$.dirty&&n(7,o=Tn().domain([0,r.length]).range([0,p-d.right])),516&t.$$.dirty&&n(6,i=Tn().domain([0,1]).range([f-d.bottom,d.top])),520&t.$$.dirty&&n(10,a=p-(d.left+d.right)),1040&t.$$.dirty&&n(5,l=a/r.length)},[c,u,f,p,r,l,i,o,s,d,a,function(){f=this.clientHeight,p=this.clientWidth,n(2,f),n(3,p)}]}class Ln extends Q{constructor(t){super(),K(this,t,Rn,Sn,i,{values:8,svgClass:0,rectClass:1,padding:9})}}function On(e){let n,r,o,i,a=e[0].units+"";return{c(){n=p("div"),r=g(e[1]),o=p("span"),i=g(a),w(o,"class","text-xs pl-1"),w(n,"class","min-w-12 text-center text-lg text-gray-700 group-hover:text-gray-100")},m(t,e){u(t,n,e),c(n,r),c(n,o),c(o,i)},p(t,e){2&e&&x(r,t[1]),1&e&&a!==(a=t[0].units+"")&&x(i,a)},i:t,o:t,d(t){t&&d(n)}}}function Dn(e){let n,r,o,i,a=e[1].toFixed(e[0].precision)+"",l=e[0].units+"";return{c(){n=p("div"),r=g(a),o=p("span"),i=g(l),w(o,"class","text-xs pl-1"),w(n,"class","min-w-12 text-center text-lg text-gray-700 group-hover:text-gray-100")},m(t,e){u(t,n,e),c(n,r),c(n,o),c(o,i)},p(t,e){3&e&&a!==(a=t[1].toFixed(t[0].precision)+"")&&x(r,a),1&e&&l!==(l=t[0].units+"")&&x(i,l)},i:t,o:t,d(t){t&&d(n)}}}function In(t){let e,n;return e=new Ln({props:{values:t[1],svgClass:"w-12 h-6",rectClass:"fill-gray-700 group-hover:fill-gray-100",padding:t[2]}}),{c(){V(e.$$.fragment)},m(t,r){X(e,t,r),n=!0},p(t,n){const r={};2&n&&(r.values=t[1]),e.$set(r)},i(t){n||(q(e.$$.fragment,t),n=!0)},o(t){G(e.$$.fragment,t),n=!1},d(t){Z(e,t)}}}function zn(t){let e,n,r,o,i,a,l,s=t[0].name+"";const f=[In,Dn,On],m=[];function b(t,e){return t[1].constructor===Array?0:"number"==typeof t[1]?1:2}return i=b(t),a=m[i]=f[i](t),{c(){e=p("div"),n=p("div"),r=g(s),o=h(),a.c(),w(n,"class","uppercase tracking-wider text-xs text-gray-500 group-hover:text-gray-100 whitespace-nowrap"),w(e,"class","flex flex-col items-center py-1 px-4 hover:bg-gray-700 group")},m(t,a){u(t,e,a),c(e,n),c(n,r),c(e,o),m[i].m(e,null),l=!0},p(t,[n]){(!l||1&n)&&s!==(s=t[0].name+"")&&x(r,s);let o=i;i=b(t),i===o?m[i].p(t,n):(B(),G(m[o],1,1,(()=>{m[o]=null})),W(),a=m[i],a?a.p(t,n):(a=m[i]=f[i](t),a.c()),q(a,1),a.m(e,null))},i(t){l||(q(a),l=!0)},o(t){G(a),l=!1},d(t){t&&d(e),m[i].d()}}}function Fn(t,e,n){let{metricDef:r}=e,{value:o}=e;return t.$$set=t=>{"metricDef"in t&&n(0,r=t.metricDef),"value"in t&&n(1,o=t.value)},[r,o,{left:0,right:0,top:4,bottom:0}]}class Pn extends Q{constructor(t){super(),K(this,t,Fn,zn,i,{metricDef:0,value:1})}}function Un(t){var e=function(e){var n=e.target;t.contains(n)||t.dispatchEvent(new CustomEvent("outclick"))};return document.addEventListener("click",e,!0),{destroy:function(){document.removeEventListener("click",e,!0)}}}function Hn(t,e,n){const r=t.slice();return r[10]=e[n],r[12]=n,r}function jn(t){let e,n=Y(t[1]),r=[];for(let e=0;e<n.length;e+=1)r[e]=Bn(Hn(t,n,e));return{c(){e=p("ul");for(let t=0;t<r.length;t+=1)r[t].c();w(e,"role","listbox"),w(e,"class","absolute pt-2 pb-3 z-10 mt-1 bg-white shadow border border-gray-300")},m(t,n){u(t,e,n);for(let t=0;t<r.length;t+=1)r[t]&&r[t].m(e,null)},p(t,o){if(66&o){let i;for(n=Y(t[1]),i=0;i<n.length;i+=1){const a=Hn(t,n,i);r[i]?r[i].p(a,o):(r[i]=Bn(a),r[i].c(),r[i].m(e,null))}for(;i<r.length;i+=1)r[i].d(1);r.length=n.length}},d(t){t&&d(e),f(r,t)}}}function Bn(t){let e,n,o,i,a=t[10]+"";function l(...e){return t[8](t[10],...e)}return{c(){e=p("li"),n=g(a),w(e,"class",`w-full px-4 py-1 ${0===t[12]?"mt-1":""} hover:bg-gray-700 hover:text-white text-nowrap`),w(e,"role","option"),w(e,"aria-selected","false")},m(t,r){u(t,e,r),c(e,n),o||(i=[y(e,"click",l),y(e,"keypress",qn)],o=!0)},p(e,r){t=e,2&r&&a!==(a=t[10]+"")&&x(n,a)},d(t){t&&d(e),o=!1,r(i)}}}function Wn(e){let n,o,i,a,s,f,b,v,k,_,$,E,N=e[3]&&jn(e);return{c(){n=p("div"),o=p("button"),i=p("span"),a=p("span"),s=g(e[2]),f=h(),b=m("svg"),v=m("path"),_=h(),N&&N.c(),w(a,"class",""),w(v,"fill-rule","evenodd"),w(v,"d","M4.22 6.22a.75.75 0 0 1 1.06 0L8 8.94l2.72-2.72a.75.75 0 1 1 1.06 1.06l-3.25 3.25a.75.75 0 0 1-1.06 0L4.22 7.28a.75.75 0 0 1 0-1.06Z"),w(v,"clip-rule","evenodd"),w(b,"xmlns","http://www.w3.org/2000/svg"),w(b,"viewBox","0 0 16 16"),w(b,"fill","currentColor"),w(b,"class","size-4"),w(i,"class",k=`mr-4 inline-flex justify-between items-center hover:bg-gray-700 hover:text-white ${e[0]}`),w(n,"class","relative")},m(t,r){u(t,n,r),c(n,o),c(o,i),c(i,a),c(a,s),c(i,f),c(i,b),c(b,v),c(n,_),N&&N.m(n,null),$||(E=[l(Un.call(null,o)),y(o,"click",e[4]),l(Un.call(null,n)),y(n,"outclick",e[5])],$=!0)},p(t,[e]){4&e&&x(s,t[2]),1&e&&k!==(k=`mr-4 inline-flex justify-between items-center hover:bg-gray-700 hover:text-white ${t[0]}`)&&w(i,"class",k),t[3]?N?N.p(t,e):(N=jn(t),N.c(),N.m(n,null)):N&&(N.d(1),N=null)},i:t,o:t,d(t){t&&d(n),N&&N.d(),$=!1,r(E)}}}const qn=t=>{};function Gn(t,e,n){let{classes:r=""}=e,{values:o=[]}=e,{defaultValue:i=""}=e,a=i,l=!1;const s=A(),c=t=>{n(2,a=t),n(3,l=!1),s("select",a)};return t.$$set=t=>{"classes"in t&&n(0,r=t.classes),"values"in t&&n(1,o=t.values),"defaultValue"in t&&n(7,i=t.defaultValue)},[r,o,a,l,t=>{n(3,l=!l)},t=>{n(3,l=!1)},c,i,(t,e)=>c(t)]}class Yn extends Q{constructor(t){super(),K(this,t,Gn,Wn,i,{classes:0,values:1,defaultValue:7})}}function Vn(t,e,n){const r=t.slice();return r[16]=e[n][0],r[17]=e[n][1],r}function Xn(t){let e,n,r,o=Y(Object.entries(t[2])),i=[];for(let e=0;e<o.length;e+=1)i[e]=Zn(Vn(t,o,e));const a=t=>G(i[t],1,1,(()=>{i[t]=null}));return{c(){e=p("section"),n=p("div");for(let t=0;t<i.length;t+=1)i[t].c();w(n,"class","pl-2 flex"),w(e,"class","w-full flex bg-gray-100 border-b border-gray-200 text-gray-500 justify-between")},m(t,o){u(t,e,o),c(e,n);for(let t=0;t<i.length;t+=1)i[t]&&i[t].m(n,null);r=!0},p(t,e){if(516&e){let r;for(o=Y(Object.entries(t[2])),r=0;r<o.length;r+=1){const a=Vn(t,o,r);i[r]?(i[r].p(a,e),q(i[r],1)):(i[r]=Zn(a),i[r].c(),q(i[r],1),i[r].m(n,null))}for(B(),r=o.length;r<i.length;r+=1)a(r);W()}},i(t){if(!r){for(let t=0;t<o.length;t+=1)q(i[t]);r=!0}},o(t){i=i.filter(Boolean);for(let t=0;t<i.length;t+=1)G(i[t]);r=!1},d(t){t&&d(e),f(i,t)}}}function Zn(t){let e,n;return e=new Pn({props:{value:t[17],metricDef:t[9][t[16]]}}),{c(){V(e.$$.fragment)},m(t,r){X(e,t,r),n=!0},p(t,n){const r={};4&n&&(r.value=t[17]),4&n&&(r.metricDef=t[9][t[16]]),e.$set(r)},i(t){n||(q(e.$$.fragment,t),n=!0)},o(t){G(e.$$.fragment,t),n=!1},d(t){Z(e,t)}}}function Jn(t){let e,n,r;return{c(){e=m("svg"),n=m("path"),r=m("path"),w(n,"fill-rule","evenodd"),w(n,"d","M3.28 2.22a.75.75 0 0 0-1.06 1.06l10.5 10.5a.75.75 0 1 0 1.06-1.06l-1.322-1.323a7.012 7.012 0 0 0 2.16-3.11.87.87 0 0 0 0-.567A7.003 7.003 0 0 0 4.82 3.76l-1.54-1.54Zm3.196 3.195 1.135 1.136A1.502 1.502 0 0 1 9.45 8.389l1.136 1.135a3 3 0 0 0-4.109-4.109Z"),w(n,"clip-rule","evenodd"),w(r,"d","m7.812 10.994 1.816 1.816A7.003 7.003 0 0 1 1.38 8.28a.87.87 0 0 1 0-.566 6.985 6.985 0 0 1 1.113-2.039l2.513 2.513a3 3 0 0 0 2.806 2.806Z"),w(e,"xmlns","http://www.w3.org/2000/svg"),w(e,"viewBox","0 0 16 16"),w(e,"fill","currentColor"),w(e,"class","size-3")},m(t,o){u(t,e,o),c(e,n),c(e,r)},d(t){t&&d(e)}}}function Kn(t){let e,n,r;return{c(){e=m("svg"),n=m("path"),r=m("path"),w(n,"d","M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"),w(r,"fill-rule","evenodd"),w(r,"d","M1.38 8.28a.87.87 0 0 1 0-.566 7.003 7.003 0 0 1 13.238.006.87.87 0 0 1 0 .566A7.003 7.003 0 0 1 1.379 8.28ZM11 8a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z"),w(r,"clip-rule","evenodd"),w(e,"xmlns","http://www.w3.org/2000/svg"),w(e,"viewBox","0 0 16 16"),w(e,"fill","currentColor"),w(e,"class","size-3")},m(t,o){u(t,e,o),c(e,n),c(e,r)},d(t){t&&d(e)}}}function Qn(t){let e,n,o,i,a,l,s,f,m,g,b,x,v,k,_,$,E,N,T,M,A,S,C,R;o=new We({}),a=new Ue({});let L=t[6]&&Xn(t);function O(t,e){return t[6]?Kn:Jn}let D=O(t),I=D(t);return $=new Yn({props:{values:["None","Type","Probability","Latency (ms)"],classes:"bg-gray-200",defaultValue:"Type"}}),$.$on("select",t[14]),N=new Yn({props:{values:["None","Probability","Latency (ms)"],classes:"border-b-2 border-gray-400",defaultValue:"Probability"}}),N.$on("select",t[15]),A=new Fe({props:{textComponents:t[0],tokenDetails:t[3],isCompleted:t[4],isError:t[5],bgField:t[7],underlineField:t[8],requireFullReplay:t[1]}}),{c(){e=p("meta"),n=h(),V(o.$$.fragment),i=h(),V(a.$$.fragment),l=h(),s=p("div"),f=p("nav"),L&&L.c(),m=h(),g=p("section"),b=p("div"),x=p("div"),v=p("span"),v.textContent="Metrics",k=h(),I.c(),_=h(),V($.$$.fragment),E=h(),V(N.$$.fragment),T=h(),M=p("section"),V(A.$$.fragment),document.title="graphpaper",w(e,"name","description"),w(e,"content","graphpaper"),w(v,"class","text-xs inline-flex flex-col justify-center uppercase tracking-wider"),w(x,"class","ml-4 mr-4 inline-flex justify-between items-center hover:bg-gray-700 hover:text-white"),w(x,"tabindex","-1"),w(x,"role","button"),w(b,"class","text-sm pt-2 pb-2 flex border-b border-gray-200"),w(f,"class","sticky top-0 z-50 opacity-90"),w(M,"class","w-full"),w(s,"class","w-full min-h-72")},m(r,d){c(document.head,e),u(r,n,d),X(o,r,d),u(r,i,d),X(a,r,d),u(r,l,d),u(r,s,d),c(s,f),L&&L.m(f,null),c(f,m),c(f,g),c(g,b),c(b,x),c(x,v),c(x,k),I.m(x,null),c(b,_),X($,b,null),c(b,E),X(N,b,null),c(s,T),c(s,M),X(A,M,null),S=!0,C||(R=[y(x,"click",t[10]),y(x,"keydown",t[11])],C=!0)},p(t,[e]){t[6]?L?(L.p(t,e),64&e&&q(L,1)):(L=Xn(t),L.c(),q(L,1),L.m(f,m)):L&&(B(),G(L,1,1,(()=>{L=null})),W()),D!==(D=O(t))&&(I.d(1),I=D(t),I&&(I.c(),I.m(x,null)));const n={};1&e&&(n.textComponents=t[0]),8&e&&(n.tokenDetails=t[3]),16&e&&(n.isCompleted=t[4]),32&e&&(n.isError=t[5]),128&e&&(n.bgField=t[7]),256&e&&(n.underlineField=t[8]),2&e&&(n.requireFullReplay=t[1]),A.$set(n)},i(t){S||(q(o.$$.fragment,t),q(a.$$.fragment,t),q(L),q($.$$.fragment,t),q(N.$$.fragment,t),q(A.$$.fragment,t),S=!0)},o(t){G(o.$$.fragment,t),G(a.$$.fragment,t),G(L),G($.$$.fragment,t),G(N.$$.fragment,t),G(A.$$.fragment,t),S=!1},d(t){t&&(d(n),d(i),d(l),d(s)),d(e),Z(o,t),Z(a,t),L&&L.d(),I.d(),Z($),Z(N),Z(A),C=!1,r(R)}}}function tr(t,e,n){let r,o;a(t,ot,(t=>n(13,r=t)));let i=[],l=[],s=!1,c=!1,u=!0,d=!0,f="Type",p="Probability";const m={status:{name:"status",units:"",description:"Determines whether engine is running, completed or in error.",isScalar:!0,precision:0},cpu:{name:"cpu",units:"%",description:"Average utilization across CPU cores.",isScalar:!1,precision:1},gpu:{name:"gpu",units:"%",description:"Average utilization across GPUs.",isScalar:!1,precision:1},ram:{name:"ram",units:"GB",description:"Utilization of RAM.",isScalar:!0,precision:1},vram:{name:"vram",units:"GB",description:"Utilization of video RAM.",isScalar:!0,precision:1},"wall time":{name:"wall time",units:"s",description:"Time taken from initial display to engine completion.",isScalar:!0,precision:1},"avg latency":{name:"avg latency",units:"ms",description:"Average roundtrip latency per token",isScalar:!0,precision:0},consumed:{name:"consumed",units:"tkn",description:"Total tokens consumed by language model.",isScalar:!0,precision:0},"token reduction":{name:"token reduction",units:"%",description:"Total tokens consumed by language model divided by total tokens.",isScalar:!0,precision:0}},g={status:"⟳",cpu:[0,0,0,0,0],ram:0,"wall time":0,"avg latency":0,consumed:0,"token reduction":0};T((()=>{const t={type:"clientmsg",content:JSON.stringify({class_name:"ClientReadyMessage"})};it.set(t)}));return t.$$.update=()=>{if(12295&t.$$.dirty&&void 0!==r&&""!==r.content){if(n(12,o=JSON.parse(r.content)),null!=(e=o)&&"TraceMessage"===e.class_name)(rt(o.node_attr)||nt(o.node_attr)||function(t){return null!=t&&"RoleCloserInput"===t.class_name}(o.node_attr))&&i.push(o.node_attr);else if(function(t){return null!=t&&"ExecutionStartedMessage"===t.class_name}(o))n(1,d=!1);else if(function(t){return null!=t&&"ClientReadyAckMessage"===t.class_name}(o)){if(d){console.log("Require full replay and went past completion output message.");const t={type:"clientmsg",content:JSON.stringify({class_name:"OutputRequestMessage"})};it.set(t)}}else if(function(t){return null!=t&&"ResetDisplayMessage"===t.class_name}(o))n(0,i=[]),n(4,s=!1);else if(function(t){return null!=t&&"MetricMessage"===t.class_name}(o)){const t=o.name,e=o.value;if(t in g&&t in m){let r=g[t];const o=m[t];!1===o.isScalar?e.constructor===Array?n(2,g[t]=e,g):n(2,g[t]=[...r.slice(1),e],g):!0===o.isScalar?n(2,g[t]=e,g):console.log(`Cannot handle metric: ${t}: ${e}.`),"status"===t&&n(5,c="⚠"===e)}}else!function(t){return null!=t&&"ExecutionCompletedMessage"===t.class_name}(o)?function(t){return null!=t&&"TokensMessage"===t.class_name}(o)&&(n(1,d=!1),n(4,s=!0),n(3,l=o.tokens),console.log(i),console.log(o.tokens)):n(4,s=!0);n(0,i),n(13,r),n(12,o),n(1,d),n(2,g)}var e},[i,d,g,l,s,c,u,f,p,m,t=>{n(6,u=!u)},t=>{},o,r,t=>n(7,f=t.detail),t=>n(8,p=t.detail)]}return new class extends Q{constructor(t){super(),K(this,t,tr,Qn,i,{})}}({target:document.body})}();
+</script>
+</body>
+</html>
diff --git a/guidance/trace/__init__.py b/guidance/trace/__init__.py
new file mode 100644
index 000000000..f70829da7
--- /dev/null
+++ b/guidance/trace/__init__.py
@@ -0,0 +1,11 @@
+"""Trace tree of inputs & outputs generated from a guidance program.
+
+The first implementation aims for simplicity.
+Once benchmark figures are out, we'll figure out what to optimize.
+
+The most critical class is the trace handler. See its documentation for trace design & motivations.
+"""
+
+from ._trace import NodeAttr, InputAttr, OutputAttr, StatefulGuidanceInput, StatelessGuidanceInput
+from ._trace import LiteralInput, EmbeddedInput, ImageInput, RoleCloserInput, RoleOpenerInput
+from ._trace import TextOutput, ImageOutput, CaptureOutput, TraceNode, TraceHandler
diff --git a/guidance/trace/_trace.py b/guidance/trace/_trace.py
new file mode 100644
index 000000000..3bfea4bd0
--- /dev/null
+++ b/guidance/trace/_trace.py
@@ -0,0 +1,339 @@
+# TODO(nopdive): Consider integrating token operations into trace nodes (handles token healing cleaner).
+# TODO(nopdive): Benchmark (expected heap fragmentation issue). Likely need memory pooling (via rust/ctypes/Cython).
+# TODO(nopdive): Integrate images when PR for multimodal is in.
+import weakref
+from itertools import count
+from typing import Any, Optional, Generator, Dict
+import logging
+from pydantic import BaseModel, Field
+from guidance._schema import GenToken
+from .._utils import pydantic_no_default_repr, pydantic_no_default_str, log_cleanup
+
+logger = logging.getLogger(__name__)
+
+
+class NodeAttr(BaseModel):
+    """Attributes of a trace node."""
+
+    class_name: str = ""
+
+    def __init__(self, **kwargs):
+        kwargs["class_name"] = self.__class__.__name__
+        super().__init__(**kwargs)
+
+    def __repr__(self):
+        return pydantic_no_default_repr(self)
+
+    def __str__(self):
+        return pydantic_no_default_str(self)
+
+
+class InputAttr(NodeAttr):
+    """Input for a guidance program (i.e. literal or guidance grammar)."""
+
+    pass
+
+
+class OutputAttr(NodeAttr):
+    """Output for a guidance program (i.e. text output)."""
+
+    pass
+
+
+class StatelessGuidanceInput(InputAttr):
+    """Stateless guidance input (light wrapper)."""
+
+    # NOTE(nopdive): Open to debate what we should serialize here, excluding for now.
+    value: Any = Field(exclude=True)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.value})"
+
+
+class StatefulGuidanceInput(InputAttr):
+    """Stateful guidance input (light wrapper)."""
+
+    # NOTE(nopdive): Open to debate what we should serialize here, excluding for now.
+    value: Any = Field(exclude=True)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.value})"
+
+
+class LiteralInput(InputAttr):
+    """Text string as a literal."""
+
+    value: str
+
+
+# NOTE(nopdive): Placeholder, needs to be filled once multimodal PR is in.
+class ImageInput(InputAttr):
+    """Image input."""
+
+    value: bytes
+
+
+class EmbeddedInput(InputAttr):
+    """Text string with embedded guidance input."""
+
+    value: str
+
+
+class RoleOpenerInput(InputAttr):
+    """Appears when a role is opened (i.e. user / system).
+
+    This usually occurs as a role context and __enter__ is called.
+    """
+
+    name: Optional[str] = None
+    text: Optional[str] = None
+    closer_text: Optional[str] = None
+
+
+class RoleCloserInput(InputAttr):
+    """Appears when a role is closed (i.e. user / system).
+
+    This usually occurs as a role context and __exit__ is called.
+    """
+
+    name: Optional[str] = None
+    text: Optional[str] = None
+
+
+class TextOutput(OutputAttr):
+    """Text string."""
+
+    value: str
+    is_input: bool = False
+    is_generated: bool = False
+    is_force_forwarded: bool = False
+    token_count: int = 0
+    prob: float = 0.0
+    tokens: list[GenToken] = Field(
+        exclude=True, default_factory=list
+    )  # use to store tokens associated with output
+
+    def __str__(self):
+        return self.value
+
+
+# NOTE(nopdive): Placeholder, needs to be filled once multimodal PR is in.
+class ImageOutput(OutputAttr):
+    """Image as bytes."""
+
+    value: bytes
+
+
+class CaptureOutput(OutputAttr):
+    """Capture variable output as a string.
+
+    If `value` is set to None, this means it's a reset (needed for append capture group outputs).
+    """
+
+    name: str
+    value: Optional[str] = None
+    is_append: bool = False
+    log_probs: float = 0.0
+
+    def __str__(self):
+        return f"{self.name}{'+=' if self.is_append else '='}{self.value.__str__()}"
+
+
+class WeakRefList(list):
+    """Weak reference list implementation that uses weakref ref objects.
+
+    This does not override all methods for list.
+    """
+
+    def append(self, item):
+        super().append(weakref.ref(item))
+
+    def __getitem__(self, index):
+        ref = super().__getitem__(index)
+        obj = ref()
+        if obj is None:
+            raise ReferenceError("The referenced object has been garbage collected")
+        return obj
+
+    def __iter__(self):
+        return (ref() for ref in super().__iter__() if ref() is not None)
+
+    def remove(self, item):
+        ref_to_remove = None
+        for ref in super().__iter__():
+            obj = ref()
+            if obj is item:
+                ref_to_remove = ref
+                break
+        if ref_to_remove:
+            super().remove(ref_to_remove)
+
+
+def _cleanup(log_msg: str):
+    log_cleanup(log_msg)
+
+
+class TraceNode(BaseModel):
+    """Trace node which associates inputs and outputs of a guidance program."""
+
+    identifier: int = Field(default_factory=count().__next__)
+    parent: Optional["TraceNode"] = None
+    children: list["TraceNode"] = Field(default_factory=WeakRefList)
+    input: Optional[InputAttr] = None
+    output: Optional[OutputAttr] = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        weakref.finalize(self, _cleanup, f"trace({id(self)}):{self.identifier}")
+
+    def add_child(self, child: "TraceNode") -> None:
+        """Add a child node to the trace node.
+
+        Args:
+            child: The child node to add.
+        """
+        child.parent = self
+        self.children.append(child)
+
+    def remove_child(self, child: "TraceNode") -> None:
+        """Remove a child node from the trace node.
+
+        Args:
+            child: The child node to remove.
+        """
+        child.parent = None
+        self.children.remove(child)
+
+    def ancestors(self) -> Generator["TraceNode", None, None]:
+        """Yields ancestor trace nodes ending with root.
+
+        Yields:
+            Ancestor trace nodes.
+        """
+        node = self
+        while node.parent is not None:
+            yield node.parent
+            node = node.parent
+
+    def path(self) -> Generator["TraceNode", None, None]:
+        """Yields path of from root to self inclusively.
+
+        Yields:
+            Trace nodes from root to self.
+        """
+        yield from reversed(list(self.ancestors()))
+        yield self
+
+    def root(self) -> "TraceNode":
+        """Returns root by traversing parents of self.
+
+        Returns:
+            Root of tree self is part of.
+        """
+        if self.parent is None:
+            root = self
+        else:
+            *_, root = self.ancestors()
+        return root
+
+    def traverse(self, bfs: bool = True):
+        """Traverse the trace nodes starting with self.
+
+        Args:
+            bfs: Use breadth-first-search, otherwise depth-first-search.
+
+        Yields:
+            Trace nodes in traversal order.
+        """
+        queue = [self]
+        while queue:
+            node = queue.pop(0)
+            yield node
+
+            if bfs:
+                queue.extend(node.children)
+            else:
+                # NOTE(nopdive): Analogous to extend but at front of list.
+                queue[0:0] = node.children
+
+    def __repr__(self):
+        return f"{self.identifier}:{self.input!r}:{self.output!r}"
+
+    def __hash__(self):
+        return hash(self.identifier)
+
+
+class TraceHandler(BaseModel):
+    """Trace handler that will own a tree of trace nodes.
+
+    This will primarily be owned by a model's engine.
+    Each guidance model corresponds to one trace node.
+    All guidance models emitted from an engine is to be included as their own paths within the tree.
+
+    The requirement for holding all live traces ensures downstream consumers such as UI providers
+    can do near-real-time partial updates.
+    """
+
+    # NOTE(nopdive): Type trickery for pydantic.
+    id_node_map: Dict[int, TraceNode] = weakref.WeakValueDictionary()  # type: ignore
+    node_id_map: Dict[TraceNode, int] = weakref.WeakKeyDictionary()  # type: ignore
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        weakref.finalize(self, _cleanup, f"tracehandler({id(self)})")
+
+    def __getitem__(self, item):
+        return self.id_node_map[item]
+
+    def update_node(
+        self, identifier: int, parent_id: Optional[int], node_attr: Optional[NodeAttr] = None
+    ) -> TraceNode:
+        """Update the trace node with the given identifier.
+
+        If the trace node does not exist, it will be created.
+        Both parent id and node attributes can be updated only once until further notice.
+
+        Args:
+            identifier: User-defined identifier for the trace node.
+            parent_id: User-defined parent identifier for the trace node.
+            node_attr: Input or output node attribute to be updated on the trace node.
+        """
+        node = self.id_node_map.get(identifier, None)
+        if node is None:
+            node = TraceNode()
+
+            self.id_node_map[identifier] = node
+            self.node_id_map[node] = identifier
+
+            if parent_id is not None:
+                parent_node = self.id_node_map.get(parent_id, None)
+                if parent_node is not None:
+                    parent_node.add_child(node)
+
+        if node_attr is not None:
+            if isinstance(node_attr, InputAttr):
+                assert node.input is None
+                node.input = node_attr
+            elif isinstance(node_attr, OutputAttr):
+                assert node.output is None
+                node.output = node_attr
+            else:
+                raise ValueError(f"Unexpected node attr: {node_attr}")
+        return node
+
+    def root(self) -> TraceNode:
+        """Returns root node of trace handler.
+
+        Raises:
+            Exception: If root cannot be found.
+
+        Returns: Root trace node.
+        """
+        root = None
+        for _, node in self.id_node_map.items():
+            if node.parent is None:
+                root = node
+                break
+        if root is None:
+            raise Exception("No root in trace handler.")
+        return root
diff --git a/guidance/visual/__init__.py b/guidance/visual/__init__.py
index a286a2509..1cbcbefae 100644
--- a/guidance/visual/__init__.py
+++ b/guidance/visual/__init__.py
@@ -3,4 +3,9 @@
 Users should have few reasons to be accessing this module.
 """
 
-from ._environment import Environment
\ No newline at end of file
+from ._message import GuidanceMessage, TraceMessage, ResetDisplayMessage, ClientReadyMessage, ClientReadyAckMessage
+from ._message import ExecutionCompletedMessage, TokensMessage, MetricMessage, OutputRequestMessage
+from ._message import ExecutionStartedMessage
+from ._renderer import AutoRenderer, LegacyHtmlRenderer, JupyterWidgetRenderer, Renderer, legacy_mode
+from ._message import serialize_message, deserialize_message
+from ._trace import trace_node_to_str, display_trace_tree, trace_node_to_html
\ No newline at end of file
diff --git a/guidance/visual/_async.py b/guidance/visual/_async.py
new file mode 100644
index 000000000..2ddc69d7a
--- /dev/null
+++ b/guidance/visual/_async.py
@@ -0,0 +1,84 @@
+""" Asynchronous handling for visual components.
+
+This includes a separate thread dedicated for visualization and messaging.
+"""
+# NOTE(nopdive): This is run on a single global thread.
+# Consider per engine threads later after memory review on engine.
+
+import asyncio
+import threading
+from asyncio import AbstractEventLoop, Future, Task
+from typing import Tuple, Coroutine
+
+
+def _start_asyncio_loop(loop: AbstractEventLoop):
+    asyncio.set_event_loop(loop)
+    loop.run_forever()
+
+
+def _asyncio_background_thread() -> Tuple[threading.Thread, AbstractEventLoop]:
+    loop = asyncio.new_event_loop()
+    thread = threading.Thread(target=_start_asyncio_loop, args=(loop,))
+    thread.daemon = True
+    return thread, loop
+
+def _run_thread_if_needed():
+    global _loop
+    global _thread
+
+    if _loop is None:
+        _thread, _loop = _asyncio_background_thread()
+        _thread.start()
+    return _thread, _loop
+
+
+async def async_task(coroutine: Coroutine) -> Task:
+    """ Creates an asyncio task from coroutine.
+
+    Args:
+        coroutine: Coroutine within task.
+
+    Returns:
+        Asyncio task.
+    """
+    task = asyncio.create_task(coroutine)
+    return task
+
+
+async def print_all_tasks():  # pragma: no cover
+    """Prints all tasks running in visual thread loop."""
+    for task in asyncio.all_tasks():
+        print(task)
+
+
+def async_loop() -> AbstractEventLoop:
+    """ Returns async loop in visual thread.
+
+    Returns:
+        Async loop of visual thread.
+    """
+    _, loop = _run_thread_if_needed()
+    return loop
+
+
+# TODO: Test.
+def call_soon_threadsafe(cb, *args, context = None):
+    loop = async_loop()
+    return loop.call_soon_threadsafe(cb, *args, context=context)
+
+
+def run_async_coroutine(coroutine: Coroutine) -> Future:
+    """ Runs an asynchronous coroutine in the visual thread.
+
+    Args:
+        coroutine: Coroutine to be run on visual thread.
+
+    Returns:
+        Future of coroutine.
+    """
+    _, loop = _run_thread_if_needed()
+    future = asyncio.run_coroutine_threadsafe(coroutine, loop)
+    return future
+
+_loop = None
+_thread = None
\ No newline at end of file
diff --git a/guidance/visual/_jupyter.py b/guidance/visual/_jupyter.py
new file mode 100644
index 000000000..01dc70230
--- /dev/null
+++ b/guidance/visual/_jupyter.py
@@ -0,0 +1,30 @@
+""" Jupyter specific utilities."""
+
+
+import weakref
+from typing import Callable, Any, Tuple
+import logging
+try:
+    from IPython import get_ipython
+except ImportError:
+    pass
+
+logger = logging.getLogger(__name__)
+
+IPythonCallback = Callable[[Any], None]
+
+# TODO(nopdive): Connect cell handling again to renderer.
+
+
+def ipy_handle_event_once(cb: IPythonCallback, event_name: str) -> IPythonCallback:
+    ipy = get_ipython()
+
+    if ipy is None:
+        return None
+    
+    def cb_closure(msg):
+        cb(info=msg)
+        ipy.events.unregister(event_name, cb_closure)
+    ipy.events.register(event_name, cb_closure)
+    
+    return cb_closure
\ No newline at end of file
diff --git a/guidance/visual/_message.py b/guidance/visual/_message.py
new file mode 100644
index 000000000..8c0298239
--- /dev/null
+++ b/guidance/visual/_message.py
@@ -0,0 +1,129 @@
+"""Messages that used between server (usually Jupyter Python kernel) and client.
+
+Messages are required to be added to the model registry for serialization.
+"""
+from typing import Optional, Dict, Union
+
+from pydantic import BaseModel, Field
+
+from guidance._schema import GenTokenExtra
+from ..trace import NodeAttr
+import json
+
+
+_msg_counter: int = -1
+class GuidanceMessage(BaseModel):
+    """Message sent within Guidance layer."""
+
+    message_id: int = Field(default=None)
+    class_name: str = ""
+
+    def __init__(self, **kwargs):
+        global _msg_counter
+
+        kwargs["class_name"] = self.__class__.__name__
+        if kwargs.get("message_id") is None:
+            _msg_counter += 1
+            kwargs["message_id"] = _msg_counter
+        super().__init__(**kwargs)
+
+
+class TraceMessage(GuidanceMessage):
+    """Update on a trace node."""
+    trace_id: int
+    parent_trace_id: Optional[int] = None
+    node_attr: Optional[NodeAttr] = None
+
+
+class MetricMessage(GuidanceMessage):
+    """Metric that has been emitted."""
+    name: str
+    value: Union[float, str, list[float], list[str]] = Field(union_mode='left_to_right')
+    scalar: bool = True
+
+
+class ExecutionStartedMessage(GuidanceMessage):
+    """Fired when renderer has started trace messages."""
+
+
+class ExecutionCompletedMessage(GuidanceMessage):
+    """Fired when renderer has completed trace messages.
+
+    This functions as the last message sent to client.
+    """
+    last_trace_id: Optional[int] = None
+    is_err: bool = False
+
+
+class TokensMessage(GuidanceMessage):
+    """Fired when trace messages are completed, with tokens for client."""
+    trace_id: int
+    text: str
+    tokens: list[GenTokenExtra]
+
+    def __str__(self):
+        return f"message_id={self.message_id} class_name={self.class_name} trace_id={self.trace_id}"
+
+
+class ResetDisplayMessage(GuidanceMessage):
+    """Instructs client to reset the display, removing all output."""
+    pass
+
+
+class ClientReadyMessage(GuidanceMessage):
+    """Fired when client is ready to receive messages."""
+    pass
+
+
+class ClientReadyAckMessage(GuidanceMessage):
+    """Fired when server acknowledges client readiness."""
+    pass
+
+
+class OutputRequestMessage(GuidanceMessage):
+    """Fired when client requests tokens from server."""
+    pass
+
+
+model_registry: Dict[str, type(GuidanceMessage)] = {
+    'TraceMessage': TraceMessage,
+    'ExecutionStartedMessage': ExecutionStartedMessage,
+    'ExecutionCompletedMessage': ExecutionCompletedMessage,
+    'ExecutionCompletedOutputMessage': TokensMessage,
+    'ResetDisplayMessage': ResetDisplayMessage,
+    'ClientReadyMessage': ClientReadyMessage,
+    'ClientReadyAckMessage': ClientReadyAckMessage,
+    'OutputRequestMessage': OutputRequestMessage,
+    'MetricMessage': MetricMessage,
+    'TokensMessage': TokensMessage,
+}
+
+
+def serialize_message(message: GuidanceMessage) -> str:
+    """ Serializes guidance message.
+
+    Args:
+        message: Message to be serialized.
+
+    Returns:
+        Serialized message in JSON format.
+    """
+    message_json = message.model_dump_json(indent=2, serialize_as_any=True)
+    return message_json
+
+
+def deserialize_message(data: str) -> GuidanceMessage:
+    """ Deserializes string into a guidance message.
+
+    Args:
+        data: JSON string to be deserialized.
+
+    Returns:
+        Guidance message.
+    """
+    data_json = json.loads(data)
+    class_name = data_json.get("class_name")
+    model_class = model_registry.get(class_name)
+    if not model_class:
+        raise ValueError(f"Unknown class_name: {class_name}")
+    return model_class.model_validate_json(data)
\ No newline at end of file
diff --git a/guidance/visual/_renderer.py b/guidance/visual/_renderer.py
new file mode 100644
index 000000000..3dee7ec1a
--- /dev/null
+++ b/guidance/visual/_renderer.py
@@ -0,0 +1,497 @@
+""" Renderer is responsible for displaying output.
+
+Our main focus is on jupyter notebooks and later terminal.
+"""
+# TODO(nopdive): Implementation for terminals & append-only text displays.
+# NOTE(nopdive): Testing this notebook related components is tricky. Should figure this out at some point.
+
+import asyncio
+import logging
+import weakref
+from typing import Optional, Callable, Tuple, Any
+from asyncio import Queue
+from functools import partial
+
+from . import MetricMessage, TokensMessage
+from ._environment import Environment
+from ._jupyter import ipy_handle_event_once
+from ._message import ExecutionCompletedMessage, \
+    deserialize_message, serialize_message, ClientReadyAckMessage, ExecutionStartedMessage
+from .._utils import log_cleanup
+from ..trace import TraceHandler
+from ..visual import GuidanceMessage, TraceMessage, ResetDisplayMessage, ClientReadyMessage
+from ._trace import trace_node_to_html
+from ._async import run_async_coroutine, async_task, call_soon_threadsafe
+from warnings import warn
+
+try:
+    from IPython.display import clear_output, display, HTML
+    from IPython import get_ipython
+
+    ipython_imported = True
+except ImportError:
+    ipython_imported = False
+
+
+try:
+    import stitch
+
+    stitch_installed = True
+except ImportError:
+    stitch_installed = False
+
+logger = logging.getLogger(__name__)
+
+
+# NOTE(nopdive): Temporary solution until we iron out all issues with widgets.
+_legacy_mode = False  # pragma: no cover
+def legacy_mode(flag: Optional[bool] = None) -> bool:  # pragma: no cover
+    """ Sets visualizations to legacy mode (how Guidance used to be).
+
+    This method call will likely deprecate when a fresher API for
+    renderers is defined.
+
+    Args:
+        flag: True if legacy is wanted.
+
+    Returns:
+        Whether legacy mode is enabled.
+    """
+    global _legacy_mode
+    if flag is not None:
+        _legacy_mode = flag
+    return _legacy_mode
+
+
+class Renderer:
+    """Renders guidance model to a visual medium."""
+
+    def __init__(self):
+        """Initializes. """
+        self._observers = []
+
+    def notify(self, message: GuidanceMessage):
+        """ Notifies all observers of the renderer of an incoming message.
+
+        Args:
+            message: Incoming message.
+        """
+        for observer in self._observers:
+            observer(message)
+
+    def subscribe(self, callback: Callable[[GuidanceMessage], None]) -> None:
+        """ Subscribes to incoming messages.
+
+        Args:
+            callback: Callback to handle incoming messages.
+        """
+        self._observers.append(callback)
+
+    def unsubscribe(self, callback: Callable[[GuidanceMessage], None]) -> None:
+        """ Unsubscribes from incoming messages.
+
+        Args:
+            callback: Callback to remove.
+        """
+        self._observers.remove(callback)
+
+    def update(self, message: GuidanceMessage) -> None:
+        """ Updates renderer with incoming message.
+
+        Args:
+            message: Incoming message.
+        """
+        raise NotImplementedError("Update not implemented.")
+
+
+def _create_stitch_widget():
+    from stitch import StitchWidget
+    import pkg_resources
+
+    if _create_stitch_widget.src_doc_template is None:
+        with open(
+            pkg_resources.resource_filename("guidance", "resources/graphpaper-inline.html"), "r"
+        ) as f:
+            _create_stitch_widget.src_doc_template = f.read()
+    w = StitchWidget()
+    w.initial_width = "100%"
+    w.initial_height = "auto"
+    w.srcdoc = _create_stitch_widget.src_doc_template
+    weakref.finalize(w, log_cleanup, f"stitch({id(w)})")
+
+    return w
+
+
+_create_stitch_widget.src_doc_template = None
+
+
+def _cleanup(recv_queue: Optional[Queue], send_queue: Optional[Queue], log_msg: str) -> None:
+    log_cleanup(log_msg)
+    if recv_queue is not None:
+        call_soon_threadsafe(send_queue.put_nowait, None)
+    if send_queue is not None:
+        call_soon_threadsafe(recv_queue.put_nowait, None)
+
+
+async def _create_queue() -> Queue:
+    # This will run in the visual thread.
+    return Queue()
+
+
+def _on_stitch_clientmsg(recv_queue_weakref: weakref.ReferenceType["Queue"], change: dict) -> None:
+    # NOTE(nopdive): Widget callbacks do not print to stdout/stderr nor module log.
+    recv_queue = recv_queue_weakref()
+    if recv_queue is not None:
+        call_soon_threadsafe(recv_queue.put_nowait, change['new'])
+
+
+def _on_cell_completion(renderer_weakref: weakref.ReferenceType["Renderer"], info) -> None:
+    logger.debug(f"CELL:executed")
+    try:
+        renderer = renderer_weakref()
+        if renderer is None:
+            return
+
+        message = ExecutionCompletedMessage(
+            last_trace_id=renderer._last_trace_id,
+            is_err=info.error_in_exec is not None,
+        )
+        renderer.update(message)
+    except Exception as e:
+        logger.error(repr(e))
+
+
+async def _handle_recv_messages(renderer_weakref: weakref.ReferenceType["Renderer"], queue_weakref: weakref.ReferenceType["Queue"]) -> None:
+    logger.debug("RECV:init")
+
+    while True:
+        try:
+            queue = queue_weakref()
+            if queue is None:
+                break
+            value = await queue.get()
+
+            # logger.debug(f"RECV:raw:{value}")
+
+            if value is None:
+                logger.debug("RECV:closing")
+                break
+
+            message = deserialize_message(value)
+            # logger.debug(f"RECV:msg:{message}")
+
+            renderer = renderer_weakref()
+            if renderer is None:
+                logger.debug("RECV:renderer early clean")
+                break
+
+            if isinstance(message, ClientReadyMessage):
+                logger.debug("RECV:clientready")
+                call_soon_threadsafe(renderer._send_queue.put_nowait, ClientReadyAckMessage())
+
+            renderer.notify(message)
+            renderer._recv_queue.task_done()
+        except Exception as e:
+            logger.error(f"RECV:err:{repr(e)}")
+
+
+async def _handle_send_messages(renderer_weakref: weakref.ReferenceType["Renderer"], queue_weakref: weakref.ReferenceType["Queue"]) -> None:
+    logger.debug("SEND:init")
+    # NOTE(nopdive): Waiting on client cb does not work, client messages received on cell completion.
+    #                Currently, we do a replay of messages on completion for client if client
+    #                first receives non-zero message identifier.
+
+    # What if we only used 1% of our brain?
+    await asyncio.sleep(200 / 1000.)
+    logger.debug("SEND:ready")
+
+    while True:
+        try:
+            queue = queue_weakref()
+            if queue is None:
+                break
+            message = await queue.get()
+            # logger.debug(f"SEND:msg:{message}")
+
+            if message is None:
+                logger.debug("SEND:closing")
+                break
+
+            message_json = serialize_message(message)
+            # logger.debug(f"SEND:json:{message_json}")
+
+            renderer = renderer_weakref()
+            if renderer is None:
+                break
+            if renderer._stitch_widget is not None:
+                renderer._stitch_widget.kernelmsg = message_json
+            else:
+                logger.debug(f"SEND:jupyter:send but no widget")
+            renderer._send_queue.task_done()
+        except Exception as e:
+            logger.error(f"SEND:err:{repr(e)}")
+
+
+class JupyterWidgetRenderer(Renderer):
+    """Jupyter widget renderer that is implemented via stitch package."""
+
+    def __init__(self, trace_handler: TraceHandler) -> None:
+        """ Initializes.
+
+        Args:
+            trace_handler: Trace handler of an engine.
+        """
+        super().__init__()
+
+        self._trace_handler = trace_handler
+        self._messages: list[GuidanceMessage] = []
+        self._completed = False
+        self._running = False
+        self._need_reset = False
+        self._stitch_widget = None
+        self._stitch_on_clientmsg = None
+        self._cell_event_handler = None
+        self._last_trace_id = None
+
+        # Create queue and wait for instantiation
+        self._send_queue: Queue = run_async_coroutine(_create_queue()).result()
+        self._recv_queue: Queue = run_async_coroutine(_create_queue()).result()
+
+        # Start send/recv message loops
+        recv_coroutine = _handle_recv_messages(weakref.ref(self), weakref.ref(self._recv_queue))
+        send_coroutine = _handle_send_messages(weakref.ref(self), weakref.ref(self._send_queue))
+        self._recv_task = run_async_coroutine(async_task(recv_coroutine)).result()
+        self._send_task = run_async_coroutine(async_task(send_coroutine)).result()
+
+        weakref.finalize(self, _cleanup, self._recv_queue, self._send_queue, f"renderer({id(self)})")
+
+
+    def has_divergence(self, message: GuidanceMessage) -> Tuple[bool, int]:
+        """Checks if message has divergence with current path.
+
+        Args:
+            message: Incoming message.
+
+        Returns:
+            Tuple of (has diverged, shared ancestor index). Index will be -1 if no divergence.
+
+        Raises:
+            Exception if there is no shared ancestor (including root). This should not happen.
+        """
+        if not isinstance(message, TraceMessage):
+            return False, -1
+
+        # If we diverge from the model path, truncate and reset
+        message_trace_node = self._trace_handler[message.trace_id]
+
+        prev_trace_messages = [x for x in self._messages if isinstance(x, TraceMessage)]
+        trace_messages_len = len(prev_trace_messages)
+        if trace_messages_len == 0:
+            return False, -1
+        elif trace_messages_len == 1:
+            if isinstance(self._messages[0], TraceMessage):
+                last_trace_node = self._trace_handler[self._messages[0].trace_id]
+                if message_trace_node.parent == last_trace_node:
+                    return False, -1
+                else:
+                    return True, 0
+            else:
+                return False, -1
+        else:
+            last_trace_message = prev_trace_messages[-1]
+            last_trace_node = self._trace_handler[last_trace_message.trace_id]
+
+            if last_trace_node not in message_trace_node.path():
+                logger.debug(f"DIVERGENCE:curr:{message_trace_node}")
+                logger.debug(f"DIVERGENCE:prev:{last_trace_node}")
+
+                # Truncate path that is no longer used by current trace node
+                ancestor_idx = -1
+                ancestors = set(message_trace_node.ancestors())
+                for idx, prev_message in enumerate(self._messages):
+                    if isinstance(prev_message, TraceMessage):
+                        prev_trace_node = self._trace_handler[prev_message.trace_id]
+                        if prev_trace_node in ancestors:
+                            ancestor_idx = idx
+
+                if ancestor_idx == -1:
+                    if message_trace_node.parent == last_trace_node.root():  # pragma: no cover
+                        ancestor_idx = 0
+                    else:
+                        raise Exception(f"Parent missing for trace node: {message_trace_node}")
+
+                return True, ancestor_idx
+            else:
+                return False, -1
+
+
+    def update(self, message: GuidanceMessage) -> None:
+        out_messages = []
+
+        if isinstance(message, ExecutionCompletedMessage):
+            logger.debug("RENDERER:execution end")
+            self._completed = True
+            self._running = False
+            self.notify(message)
+
+            if message.is_err:
+                out_messages.append(MetricMessage(name="status", value="⚠"))
+            else:
+                out_messages.append(MetricMessage(name="status", value="✓"))
+
+        if not self._running and isinstance(message, TraceMessage):
+            logger.debug("RENDERER:execution start")
+            started_msg = ExecutionStartedMessage()
+            out_messages.append(started_msg)
+            out_messages.append(MetricMessage(name="status", value='⟳'))
+
+            ipy_handle_event_once(
+                partial(_on_cell_completion, weakref.ref(self)),
+                'post_run_cell'
+            )
+            self._need_reset = True
+            self._running = True
+            self._completed = False
+
+            # TODO(nopdive): Fire off execution immediately to renderer subscribers. Review later.
+            call_soon_threadsafe(self._recv_queue.put_nowait, serialize_message(started_msg))
+
+        # Check if message has diverged from prev messages
+        diverged, shared_ancestor_idx = self.has_divergence(message)
+        if diverged:
+            out_messages.append(ResetDisplayMessage())
+            out_messages[len(out_messages):] = self._messages[:shared_ancestor_idx]
+            self._messages.clear()
+
+        # Reset if needed
+        if self._need_reset:
+            logger.debug("RENDERER:reset")
+
+            # Clear messages
+            self._messages = []
+
+            if self._stitch_widget is not None:
+                self._stitch_widget.unobserve(self._stitch_on_clientmsg, names='clientmsg')
+
+            self._stitch_widget = _create_stitch_widget()
+            self._stitch_on_clientmsg = partial(_on_stitch_clientmsg, weakref.ref(self._recv_queue))
+            self._stitch_widget.observe(self._stitch_on_clientmsg, names='clientmsg')
+
+            # Redraw
+            # clear_output(wait=True)
+            display(self._stitch_widget)
+
+            self._need_reset = False
+
+        # Append current message to outgoing
+        out_messages.append(message)
+
+        # Send outgoing messages to client
+        for out_message in out_messages:
+            # logger.debug(f"RENDERER:out:{out_message}")
+            if isinstance(out_message, TraceMessage):
+                self._last_trace_id = out_message.trace_id
+
+            self._messages.append(out_message)
+            call_soon_threadsafe(self._send_queue.put_nowait, out_message)
+
+class DoNothingRenderer(Renderer):
+    """ It does nothing. Placeholder for future renderers."""
+
+    def __init__(self, trace_handler: TraceHandler) -> None:
+        """ Initializes.
+
+        Args:
+            trace_handler: Trace handler of an engine.
+        """
+        self._trace_handler = trace_handler
+        super().__init__()
+
+    def update(self, message: GuidanceMessage) -> None:
+        pass
+
+
+class LegacyHtmlRenderer(JupyterWidgetRenderer):
+    """Original HTML renderer for guidance."""
+
+    def __init__(self, trace_handler: TraceHandler) -> None:
+        """ Initializes.
+
+        Args:
+            trace_handler: Trace handler of an engine.
+        """
+
+        self._trace_handler = trace_handler
+        super().__init__(trace_handler)
+
+    def update(self, message: GuidanceMessage) -> None:
+        pass
+        # # Handle Jupyter cell completion
+        # self._handle_jupyter_cell_completion()
+        #
+        # if isinstance(message, TraceMessage) or isinstance(message, ExecutionCompletedOutputMessage):
+        #     complete_msg = None
+        #     if isinstance(message, ExecutionCompletedOutputMessage):
+        #         complete_msg = message
+        #
+        #     trace_node = self._trace_handler[message.trace_id]
+        #     self._last_trace_id = message.trace_id
+        #     if trace_node is not None:
+        #         clear_output(wait=True)
+        #         display(HTML(trace_node_to_html(trace_node, prettify_roles=False, complete_msg=complete_msg)))
+        # elif isinstance(message, ExecutionCompletedMessage):
+        #     logger.debug("RENDERER:cell executed")
+        # else:
+        #     pass
+
+
+class AutoRenderer(Renderer):
+    """ Automatically detects which renderer to use based on environment."""
+
+    def __init__(self, trace_handler: TraceHandler):
+        """ Initializes.
+
+        Args:
+            trace_handler: Trace handler of an engine.
+        """
+        self._env = Environment()
+
+        if legacy_mode():
+            self._renderer = LegacyHtmlRenderer(trace_handler=trace_handler)
+        else:
+            if self._env.is_notebook():
+                if stitch_installed:
+                    self._renderer = JupyterWidgetRenderer(trace_handler=trace_handler)
+                else:
+                    self._renderer = LegacyHtmlRenderer(trace_handler=trace_handler)
+            elif self._env.is_terminal():
+                # TODO(nopdive): When IPython events are figured out (cell completion)
+                #                hook up terminal interface separate to non-interactive
+                #                shell.
+                self._renderer = DoNothingRenderer(trace_handler=trace_handler)
+            else:  # pragma: no cover
+                logger.error("Env detection has failed. This is a bug.")
+                warn("Env detection has failed. No renderer will be provided.")
+                self._renderer = DoNothingRenderer(trace_handler=trace_handler)
+
+        super().__init__()
+
+    def notify(self, message: GuidanceMessage):
+        self._renderer.notify(message)
+
+    def subscribe(self, callback: Callable[[GuidanceMessage], None]) -> None:
+        self._renderer.subscribe(callback)
+
+    def unsubscribe(self, callback: Callable[[GuidanceMessage], None]) -> None:
+        self._renderer.unsubscribe(callback)
+
+    def update(self, message: GuidanceMessage) -> None:
+        self._renderer.update(message)
+
+    def renderer_type(self) -> type:
+        """Type of renderer that has been selected based on environment.
+
+        Returns:
+            Type of selected renderer.
+        """
+        return type(self._renderer)
\ No newline at end of file
diff --git a/guidance/visual/_trace.py b/guidance/visual/_trace.py
new file mode 100644
index 000000000..24f6f2c62
--- /dev/null
+++ b/guidance/visual/_trace.py
@@ -0,0 +1,208 @@
+""" Visualization related to trace. """
+
+import base64
+import json
+from typing import Optional, Dict
+from .._schema import GenToken
+
+from ..visual._message import TokensMessage
+from ..trace import (
+    TextOutput,
+    TraceNode,
+    TraceHandler,
+    RoleOpenerInput,
+    RoleCloserInput,
+    ImageOutput,
+)
+import html
+
+
+def trace_node_to_html(
+    node: TraceNode, prettify_roles=False, complete_msg: TokensMessage = None
+) -> str:
+    """Represents trace path as html string.
+
+    Args:
+        node: Trace node that designates the end of a trace path for HTML output.
+        prettify_roles: Enables prettier formatting for roles.
+        complete_msg: Output message received on completion of engine.
+
+    Returns:
+        HTML string of trace path as html.
+    """
+    buffer = []
+    node_path = list(node.path())
+    active_role: Optional[TraceNode] = None
+
+    prob_idx = 0
+    # remaining_text = ""
+    full_text = ""
+    if complete_msg:
+        for token in complete_msg.tokens:
+            full_text += token.text
+
+    for i, node in enumerate(node_path):
+        if isinstance(node.input, RoleOpenerInput):
+            active_role = node
+        elif isinstance(node.input, RoleCloserInput):
+            active_role = node
+
+        if isinstance(node.output, TextOutput):
+            if active_role is not None:
+                if isinstance(active_role.input, RoleOpenerInput) and prettify_roles:
+                    role_name = active_role.input.name
+                    fmt = f"<div style='display: flex; border-bottom: 1px solid rgba(127, 127, 127, 0.2);  justify-content: center; align-items: center;'><div style='flex: 0 0 80px; opacity: 0.5;'>{role_name.lower()}</div><div style='flex-grow: 1; padding: 5px; padding-top: 10px; padding-bottom: 10px; margin-top: 0px; white-space: pre-wrap; margin-bottom: 0px;'>"
+                    buffer.append(fmt)
+                if not prettify_roles:
+                    buffer.append("<span style='background-color: rgba(255, 180, 0, 0.3); border-radius: 3px;'>")
+
+            if not (active_role and prettify_roles):
+                attr = node.output
+
+                fmt = ""
+                if not complete_msg:
+                    if attr.is_generated:
+                        # fmt = f"<span style='background-color: rgba({165 * (1 - attr.prob)}, {165 * attr.prob}, 0, 0.15); border-radius: 3ps;' title='{attr.prob}'>{html.escape(attr.value)}</span>"
+                        fmt = f"<span style='background-color: rgba({0}, {255}, {0}, 0.15); border-radius: 3ps;' title='{attr.prob}'>{html.escape(attr.value)}</span>"
+                    elif attr.is_force_forwarded:
+                        fmt = f"<span style='background-color: rgba({0}, {0}, {255}, 0.15); border-radius: 3ps;' title='{attr.prob}'>{html.escape(attr.value)}</span>"
+                    else:
+                        # fmt = f"{html.escape(attr.value)}"
+                        fmt += f"<span style='background-color: rgba({255}, {255}, {255}, 0.15); border-radius: 3ps;' title='{attr.prob}'>{html.escape(attr.value)}</span>"
+                else:
+                    # switch to token-based
+                    # cell_tokens = attr.tokens
+                    # for token in cell_tokens:
+                    #     # assert token.token == complete_msg.tokens[prob_idx].token, f"Token mismatch {token.token} != {complete_msg.tokens[prob_idx].token}"
+                    #     if token.token_id != complete_msg.tokens[prob_idx].token_id:
+                    #         if remaining_text + token.text != complete_msg.tokens[prob_idx].text:
+                    #             remaining_text += token.text
+                    #             continue
+                    #         else:
+                    #             remaining_text = ""
+
+                    #     token_str = complete_msg.tokens[prob_idx].text
+                    #     prob = complete_msg.tokens[prob_idx].prob
+                    #     top_k = {}
+                    #     # find the correct token
+                    #     for _item in complete_msg.tokens[prob_idx].top_k:
+                    #         top_k[f"{_item.text}"] = f"{_item.prob} - Masked: {_item.is_masked}"
+                    #     top_k = json.dumps(top_k, indent=2)
+
+                    #     latency = f"{complete_msg.tokens[prob_idx].latency_ms:.2f}"
+
+                    #     if complete_msg.tokens[prob_idx].is_generated:
+                    #         fmt += f"<span style='background-color: rgba({0}, {127 + int(127 * prob)}, {0}, 0.15); border-radius: 3ps;' title='Token: \"{token_str}\" : {prob}\nTop-k: {top_k}\nlatency_ms: {latency}'>{html.escape(token_str)}</span>"
+                    #     elif complete_msg.tokens[prob_idx].is_force_forwarded:
+                    #         fmt += f"<span style='background-color: rgba({0}, {0}, {127 + int(127 * prob)}, 0.15); border-radius: 3ps;' title='Token: \"{token_str}\" : {prob}\nTop-k: {top_k}\nlatency_ms: {latency}'>{html.escape(token_str)}</span>"
+                    #     else:
+                    #         fmt += f"<span style='background-color: rgba({255}, {255}, {255}, 0.15); border-radius: 3ps;' title='Token: \"{token_str}\" : {prob}\nTop-k: {top_k}'>{html.escape(token_str)}</span>"
+
+                    #     full_text = full_text[len(token_str) :]
+                    #     prob_idx += 1
+
+                    chunk_text = attr.value
+                    # find tokens in complete message that cover this chunk
+                    tokens: list[GenToken] = []
+                    _idx = prob_idx
+                    tokens_text = ""
+                    while _idx < len(complete_msg.tokens):
+                        _token = complete_msg.tokens[_idx]
+                        tokens_text += _token.text
+                        tokens.append(_token)
+                        if chunk_text in tokens_text:
+                            break
+                        _idx += 1
+
+                    assert (
+                        chunk_text in tokens_text
+                    ), f"Token mismatch {tokens_text} != {chunk_text}"
+
+                    start_idx = tokens_text.index(chunk_text)
+                    remaining_text = tokens_text[start_idx + len(chunk_text) :]
+
+                    if remaining_text:
+                        # remove the last tokens
+                        tokens.pop(-1)
+
+                    # update prob_idx
+                    prob_idx += len(tokens)
+
+                    for token in tokens:
+                        token_str = token.text
+                        prob = token.prob
+                        top_k = {}
+                        # find the correct token
+                        for _item in token.top_k:
+                            top_k[f"{_item.text}"] = f"{_item.prob} - Masked: {_item.is_masked}"
+                        top_k = json.dumps(top_k, indent=2)
+
+                        latency = f"{token.latency_ms:.2f}"
+
+                        if token.is_generated:
+                            fmt += f"<span style='background-color: rgba({0}, {127 + int(127 * prob)}, {0}, 0.15); border-radius: 3ps;' title='Token: \"{token_str}\" : {prob}\nTop-k: {top_k}\nlatency_ms: {latency}'>{html.escape(token_str)}</span>"
+                        elif token.is_force_forwarded:
+                            fmt += f"<span style='background-color: rgba({0}, {0}, {127 + int(127 * prob)}, 0.15); border-radius: 3ps;' title='Token: \"{token_str}\" : {prob}\nTop-k: {top_k}\nlatency_ms: {latency}'>{html.escape(token_str)}</span>"
+                        else:
+                            fmt += f"<span style='background-color: rgba({255}, {255}, {255}, 0.15); border-radius: 3ps;' title='Token: \"{token_str}\" : {prob}\nTop-k: {top_k}'>{html.escape(token_str)}</span>"
+
+                buffer.append(fmt)
+
+            if active_role is not None:
+                if not prettify_roles:
+                    buffer.append("</span>")
+                if isinstance(active_role.input, RoleCloserInput) and prettify_roles:
+                    buffer.append(f"</div></div>")
+                active_role = None
+        elif isinstance(node.output, ImageOutput):
+            encoded = base64.b64encode(node.output.value).decode()
+            buffer.append(
+                f'<img src="data:image/png;base64,{encoded}" style="max-width" 400px; vertical-align: middle; margin: 4px;">'
+            )
+
+    buffer.insert(
+        0,
+        "<pre style='margin: 0px; padding: 0px; vertical-align: middle; padding-left: 8px; margin-left: -8px; border-radius: 0px; border-left: 1px solid rgba(127, 127, 127, 0.2); white-space: pre-wrap; font-family: ColfaxAI, Arial; font-size: 15px; line-height: 23px;'>",
+    )
+    buffer.append("</pre>")
+    return "".join(buffer)
+
+
+def trace_node_to_str(node: TraceNode) -> str:
+    """Visualize output attributes of a trace node up to the root.
+
+    Users should not be accessing this function. For debugging purposes.
+
+    Args:
+        node: The trace node to visualize.
+    Returns:
+        Output as string.
+    """
+    buffer = []
+    for node in node.path():
+        if isinstance(node.output, TextOutput):
+            buffer.append(str(node.output))
+    return "".join(buffer)
+
+
+def display_trace_tree(trace_handler: TraceHandler) -> None:
+    """Visualize tree of a trace node going down to all its leaves.
+
+    Users should not normally be accessing this function. For debugging purposes.
+
+    Args:
+        trace_handler: Trace handler needed to pull user-defined identifiers of trace nodes.
+    """
+    from anytree import Node, RenderTree
+
+    root = trace_handler.root()
+    trace_viz_map: Dict[TraceNode, Node] = {}
+    for node in root.traverse(bfs=False):
+        viz_parent = trace_viz_map.get(node.parent, None)
+        viz_node = Node(f"{trace_handler.node_id_map[node]}:{node!r}", parent=viz_parent)
+        trace_viz_map[node] = viz_node
+    viz_root = trace_viz_map[root]
+
+    for pre, fill, node in RenderTree(viz_root):
+        tree_str = "%s%s" % (pre, node.name)
+        print(tree_str)
diff --git a/notebooks/unstable/.gitignore b/notebooks/unstable/.gitignore
new file mode 100644
index 000000000..c96a04f00
--- /dev/null
+++ b/notebooks/unstable/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
\ No newline at end of file
diff --git a/notebooks/unstable/State Debugging.ipynb b/notebooks/unstable/State Debugging.ipynb
new file mode 100644
index 000000000..7d7df97e7
--- /dev/null
+++ b/notebooks/unstable/State Debugging.ipynb	
@@ -0,0 +1,196 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d7d1e6967616e177",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-11T22:50:52.915277Z",
+     "start_time": "2024-10-11T22:50:52.730830Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import stitch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1ec02432-a44d-4fdb-b44c-b153529fc03d",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2024-10-20T19:58:31.247827Z",
+     "start_time": "2024-10-20T19:58:24.650343Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/samueljenkins/dev/guidance-dev/venv/lib/python3.9/site-packages/urllib3/__init__.py:35: NotOpenSSLWarning: urllib3 v2 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "from guidance.models import Transformers\n",
+    "from guidance import gen, user, system\n",
+    "\n",
+    "import logging\n",
+    "logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s',\n",
+    "                    datefmt='%Y-%m-%d %H:%M:%S')\n",
+    "logging.getLogger().setLevel(logging.DEBUG)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "18b70f42-4b6d-41a4-94be-a41360571901",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ed0ad5ac277c4702b21ff8fdc9494dcf",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "StitchWidget(initial_height='auto', initial_width='100%', srcdoc='<!doctype html>\\n<html lang=\"en\">\\n<head>\\n …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-10-21 00:33:38 - DEBUG - start gen(name=\"suffix\")\n",
+      "2024-10-21 00:33:38 - DEBUG - finish gen\n",
+      "2024-10-21 00:33:38 - DEBUG - start Model._run_stateless\n",
+      "2024-10-21 00:33:38 - DEBUG - SEND:ready\n",
+      "2024-10-21 00:33:38 - DEBUG - finish Model._run_stateless\n",
+      "2024-10-21 00:33:38 - DEBUG - CELL:executed:message_id=201 class_name='ExecutionCompletedMessage' last_trace_id=69\n",
+      "2024-10-21 00:33:38 - DEBUG - ENGINE:message_id=201 class_name='ExecutionCompletedMessage' last_trace_id=69\n",
+      "2024-10-21 00:33:38 - DEBUG - JUPYTER:changed:8eea1d49-65c5-4f25-a863-5d7000948161|7\n",
+      "2024-10-21 00:33:38 - DEBUG - ENGINE:final_text:<|im_start|>system\n",
+      "You are responsible for writing an epic poem.<|im_end|>\n",
+      "<|im_start|>user\n",
+      "Roses are red and white and blue and red and\n",
+      "2024-10-21 00:33:38 - DEBUG - RENDER:execution completed out\n",
+      "2024-10-21 00:33:38 - DEBUG - RENDER:execution completed\n",
+      "2024-10-21 00:33:38 - DEBUG - RECV:clientready\n",
+      "2024-10-21 00:33:38 - DEBUG - ENGINE:message_id=208 class_name='ClientReadyMessage'\n",
+      "2024-10-21 00:33:38 - DEBUG - JUPYTER:changed:b5537f3f-cafc-4815-9da1-413e814172bd|7\n"
+     ]
+    }
+   ],
+   "source": [
+    "m0 = Transformers(\"gpt2\")\n",
+    "# m0 = Transformers(\"microsoft/Phi-3-mini-4k-instruct\")\n",
+    "# m1 = m0 + \"Alms for the \" + gen(name=\"suffix\", max_tokens=5, stop='\\n')\n",
+    "\n",
+    "with system():\n",
+    "    # m1 = m0 + \"You are responsible for autocompleting a sentence.\"\n",
+    "    m1 = m0 + \"You are responsible for writing an epic poem.\"\n",
+    "with user():\n",
+    "    m2 = m1 + \"Roses are red and \" + gen(name=\"suffix\", regex=r'[\\w\\s]{20,30}', max_tokens=30)\n",
+    "    # m2 = m1 + \"Roses are red and \" + gen(name=\"suffix\", regex=r'[\\w\\s]+{100}', max_tokens=500)\n",
+    "    # m2 = m1 + \"Once upon a time\" + gen(name=\"end\", max_tokens=500)\n",
+    "# m3 = m2 + \">:(\"\n",
+    "\n",
+    "# with user():\n",
+    "#     m3 = m2 + \"\\nWhat can I do?\"\n",
+    "\n",
+    "# m1 = m0 + f\"Hi there {gen(name='name', max_tokens=10, regex='[A-Za-z]{3,5}')}\"\n",
+    "# m2 = m0 + f\"You can't stop \" + gen(name='name', max_tokens=10, regex='[A-Za-z]{3,5}')\n",
+    "\n",
+    "# with system():\n",
+    "#     m3 = m0 + \"You are responsible for autocompleting a sentence.\"\n",
+    "\n",
+    "# with user():\n",
+    "#     m4 = m3 + \"The sun is rising \" + gen(name='sentence_suffix', max_tokens=3)\n",
+    "\n",
+    "# m2.html()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "5a5d668a11bda28f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7bc266ab105a4e1ebac84a5ccf374e93",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "StitchWidget(initial_height='auto', initial_width='100%', srcdoc='<!doctype html>\\n<html lang=\"en\">\\n<head>\\n …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-10-21 00:23:55 - DEBUG - CELL:executed:message_id=70 class_name='ExecutionCompletedMessage' last_trace_id=25\n",
+      "2024-10-21 00:23:55 - DEBUG - ENGINE:message_id=70 class_name='ExecutionCompletedMessage' last_trace_id=25\n",
+      "2024-10-21 00:23:55 - DEBUG - JUPYTER:changed:4a597956-2fce-418b-9cd4-7442bfc9dea2|5\n",
+      "2024-10-21 00:23:55 - DEBUG - SEND:ready\n",
+      "2024-10-21 00:23:55 - DEBUG - ENGINE:final_text:What is this?\n",
+      "2024-10-21 00:23:55 - DEBUG - RENDER:execution completed out\n",
+      "2024-10-21 00:23:55 - DEBUG - RENDER:execution completed\n",
+      "2024-10-21 00:23:55 - DEBUG - RECV:clientready\n",
+      "2024-10-21 00:23:55 - DEBUG - ENGINE:message_id=77 class_name='ClientReadyMessage'\n",
+      "2024-10-21 00:23:55 - DEBUG - JUPYTER:changed:196b33d5-8401-4388-ba99-d49248536afb|5\n"
+     ]
+    }
+   ],
+   "source": [
+    "from guidance import legacy_mode\n",
+    "legacy_mode(False)\n",
+    "\n",
+    "m5 = Transformers(\"gpt2\")\n",
+    "m6 = m5 + \"What is this?\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "235109a1-e1de-4303-bb0b-d7f9931a421c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/packages/python/stitch/.coveragerc b/packages/python/stitch/.coveragerc
new file mode 100644
index 000000000..dc0dc815f
--- /dev/null
+++ b/packages/python/stitch/.coveragerc
@@ -0,0 +1,2 @@
+[run]
+omit = stitch/tests/*
diff --git a/packages/python/stitch/.eslintignore b/packages/python/stitch/.eslintignore
new file mode 100644
index 000000000..e8a22210a
--- /dev/null
+++ b/packages/python/stitch/.eslintignore
@@ -0,0 +1,5 @@
+node_modules
+dist
+coverage
+**/*.d.ts
+tests
\ No newline at end of file
diff --git a/packages/python/stitch/.eslintrc.js b/packages/python/stitch/.eslintrc.js
new file mode 100644
index 000000000..9fb27ea5b
--- /dev/null
+++ b/packages/python/stitch/.eslintrc.js
@@ -0,0 +1,28 @@
+module.exports = {
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/eslint-recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended'
+  ],
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.eslint.json',
+    sourceType: 'module'
+  },
+  plugins: ['@typescript-eslint'],
+  rules: {
+    '@typescript-eslint/no-unused-vars': ['warn', { args: 'none' }],
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-namespace': 'off',
+    '@typescript-eslint/no-use-before-define': 'off',
+    '@typescript-eslint/quotes': [
+      'error',
+      'single',
+      { avoidEscape: true, allowTemplateLiterals: false }
+    ],
+    curly: ['error', 'all'],
+    eqeqeq: 'error',
+    'prefer-arrow-callback': 'error'
+  }
+};
\ No newline at end of file
diff --git a/packages/python/stitch/.github/workflows/build.yml b/packages/python/stitch/.github/workflows/build.yml
new file mode 100644
index 000000000..dfab4e374
--- /dev/null
+++ b/packages/python/stitch/.github/workflows/build.yml
@@ -0,0 +1,44 @@
+name: Build
+
+on:
+  push:
+    branches: main
+  pull_request:
+    branches: "*"
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.7", "3.10"]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - uses: jupyterlab/maintainer-tools/.github/actions/base-setup@v1
+
+      - name: Install dependencies
+        run: |
+          python -m pip install -U codecov
+          npm install -g codecov
+      - name: Test the extension
+        run: |
+          python -m pip install --upgrade -v -e ".[test, examples, docs]"
+          python -m pytest
+          yarn run test
+
+      - name: Linting
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        run: |
+          yarn run lint:check
+
+      - name: Check docs can be build + links
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        working-directory: docs
+        run: |
+          sudo apt install -y pandoc
+          make html
+          python -m pytest --check-links
diff --git a/packages/python/stitch/.gitignore b/packages/python/stitch/.gitignore
new file mode 100644
index 000000000..61493d6f8
--- /dev/null
+++ b/packages/python/stitch/.gitignore
@@ -0,0 +1,156 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask instance folder
+instance/
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+docs/source/_static/embed-bundle.js
+docs/source/_static/embed-bundle.js.map
+
+# PyBuilder
+target/
+
+# IPython Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# dotenv
+.env
+
+# virtualenv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+
+# Rope project settings
+.ropeproject
+
+# =========================
+# Operating System Files
+# =========================
+
+# OSX
+# =========================
+
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows
+# =========================
+
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+
+# NPM
+# ----
+
+**/node_modules/
+stitch/nbextension/index.*
+.yarn/
+
+# Coverage data
+# -------------
+**/coverage/
+
+# Packed lab extensions
+stitch/labextension
diff --git a/packages/python/stitch/.npmignore b/packages/python/stitch/.npmignore
new file mode 100644
index 000000000..f8ec1d196
--- /dev/null
+++ b/packages/python/stitch/.npmignore
@@ -0,0 +1,7 @@
+.DS_Store
+node_modules/
+tests/
+.jshintrc
+# Ignore any build output from python:
+dist/*.tar.gz
+dist/*.wheel
diff --git a/packages/python/stitch/.prettierignore b/packages/python/stitch/.prettierignore
new file mode 100644
index 000000000..b56605bbd
--- /dev/null
+++ b/packages/python/stitch/.prettierignore
@@ -0,0 +1,4 @@
+node_modules
+**/node_modules
+**/lib
+**/package.json
\ No newline at end of file
diff --git a/packages/python/stitch/.prettierrc b/packages/python/stitch/.prettierrc
new file mode 100644
index 000000000..dc2fb828f
--- /dev/null
+++ b/packages/python/stitch/.prettierrc
@@ -0,0 +1,3 @@
+{
+    "singleQuote": true
+}
\ No newline at end of file
diff --git a/packages/python/stitch/.yarnrc.yml b/packages/python/stitch/.yarnrc.yml
new file mode 100644
index 000000000..3186f3f07
--- /dev/null
+++ b/packages/python/stitch/.yarnrc.yml
@@ -0,0 +1 @@
+nodeLinker: node-modules
diff --git a/packages/python/stitch/LICENSE.txt b/packages/python/stitch/LICENSE.txt
new file mode 100644
index 000000000..be5b7c6c6
--- /dev/null
+++ b/packages/python/stitch/LICENSE.txt
@@ -0,0 +1,27 @@
+Copyright (c) 2024 Guidance Contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/packages/python/stitch/MANIFEST.in b/packages/python/stitch/MANIFEST.in
new file mode 100644
index 000000000..ef35b9f2d
--- /dev/null
+++ b/packages/python/stitch/MANIFEST.in
@@ -0,0 +1,41 @@
+include LICENSE.txt
+include README.md
+
+include setup.py
+include pyproject.toml
+include pytest.ini
+include .coverage.rc
+
+include tsconfig.json
+include package.json
+include webpack.config.js
+include stitch/labextension/*.tgz
+
+# Documentation
+graft docs
+exclude docs/\#*
+prune docs/build
+prune docs/gh-pages
+prune docs/dist
+
+# Examples
+graft examples
+
+# Tests
+graft tests
+prune tests/build
+
+# Javascript files
+graft stitch/nbextension
+graft src
+graft css
+prune **/node_modules
+prune coverage
+prune lib
+
+# Patterns to exclude from any directory
+global-exclude *~
+global-exclude *.pyc
+global-exclude *.pyo
+global-exclude .git
+global-exclude .ipynb_checkpoints
diff --git a/packages/python/stitch/README.md b/packages/python/stitch/README.md
new file mode 100644
index 000000000..3267f1986
--- /dev/null
+++ b/packages/python/stitch/README.md
@@ -0,0 +1,83 @@
+
+# stitch
+
+[![Build Status](https://travis-ci.org/guidance-ai/stitch.svg?branch=master)](https://travis-ci.org/guidance-ai/stitch)
+[![codecov](https://codecov.io/gh/guidance-ai/stitch/branch/master/graph/badge.svg)](https://codecov.io/gh/guidance-ai/stitch)
+
+
+Bidirectional comms for Jupyter and JavaScript.
+
+## Installation
+
+You can install using `pip`:
+
+```bash
+pip install stitch
+```
+
+If you are using Jupyter Notebook 5.2 or earlier, you may also need to enable
+the nbextension:
+```bash
+jupyter nbextension enable --py [--sys-prefix|--user|--system] stitch
+```
+
+## Development Installation
+
+Create a dev environment:
+```bash
+conda create -n stitch-dev -c conda-forge nodejs python jupyterlab=4.0.11
+conda activate stitch-dev
+```
+
+Install the python. This will also build the TS package.
+```bash
+pip install -e ".[test, examples]"
+```
+
+When developing your extensions, you need to manually enable your extensions with the
+notebook / lab frontend. For lab, this is done by the command:
+
+```
+jupyter labextension develop --overwrite .
+jlpm run build
+```
+
+For classic notebook, you need to run:
+
+```
+jupyter nbextension install --sys-prefix --symlink --overwrite --py stitch
+jupyter nbextension enable --sys-prefix --py stitch
+```
+
+Note that the `--symlink` flag doesn't work on Windows, so you will here have to run
+the `install` command every time that you rebuild your extension. For certain installations
+you might also need another flag instead of `--sys-prefix`, but we won't cover the meaning
+of those flags here.
+
+### How to see your changes
+#### Typescript:
+If you use JupyterLab to develop then you can watch the source directory and run JupyterLab at the same time in different
+terminals to watch for changes in the extension's source and automatically rebuild the widget.
+
+```bash
+# Watch the source directory in one terminal, automatically rebuilding when needed
+jlpm run watch
+# Run JupyterLab in another terminal
+jupyter lab
+```
+
+After a change wait for the build to finish and then refresh your browser and the changes should take effect.
+
+#### Python:
+If you make a change to the python code then you will need to restart the notebook kernel to have it take effect.
+
+## Updating the version
+
+To update the version, install tbump and use it to bump the version.
+By default it will also create a tag.
+
+```bash
+pip install tbump
+tbump <new-version>
+```
+
diff --git a/packages/python/stitch/babel.config.js b/packages/python/stitch/babel.config.js
new file mode 100644
index 000000000..bbc789a7f
--- /dev/null
+++ b/packages/python/stitch/babel.config.js
@@ -0,0 +1,13 @@
+module.exports = {
+  sourceMap: 'inline',
+  presets: [
+    [
+      '@babel/preset-env',
+      {
+        targets: {
+          node: 'current',
+        },
+      },
+    ],
+  ],
+};
diff --git a/packages/python/stitch/codecov.yml b/packages/python/stitch/codecov.yml
new file mode 100644
index 000000000..075746814
--- /dev/null
+++ b/packages/python/stitch/codecov.yml
@@ -0,0 +1,12 @@
+comment: off
+# show coverage in CI status, but never consider it a failure
+coverage:
+  status:
+    project:
+      default:
+        target: 0%
+    patch:
+      default:
+        target: 0%
+ignore:
+  - "stitch/tests"
diff --git a/packages/python/stitch/css/widget.css b/packages/python/stitch/css/widget.css
new file mode 100644
index 000000000..f7abb3f64
--- /dev/null
+++ b/packages/python/stitch/css/widget.css
@@ -0,0 +1,4 @@
+.custom-widget {
+  background-color: lightseagreen;
+  padding: 0px 2px;
+}
diff --git a/packages/python/stitch/docs/Makefile b/packages/python/stitch/docs/Makefile
new file mode 100644
index 000000000..8e5059549
--- /dev/null
+++ b/packages/python/stitch/docs/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SPHINXPROJ    = stitch
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/packages/python/stitch/docs/environment.yml b/packages/python/stitch/docs/environment.yml
new file mode 100644
index 000000000..f3f33d9cc
--- /dev/null
+++ b/packages/python/stitch/docs/environment.yml
@@ -0,0 +1,12 @@
+
+name: stitch_docs
+channels:
+  - conda-forge
+dependencies:
+  - python=3.*
+  - nodejs
+  - jupyter_sphinx
+  - sphinx
+  - sphinx_rtd_theme
+  - nbsphinx
+  - nbsphinx-link
diff --git a/packages/python/stitch/docs/make.bat b/packages/python/stitch/docs/make.bat
new file mode 100644
index 000000000..b7ff4ee61
--- /dev/null
+++ b/packages/python/stitch/docs/make.bat
@@ -0,0 +1,36 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+set SPHINXPROJ=stitch
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd
diff --git a/packages/python/stitch/docs/source/_static/helper.js b/packages/python/stitch/docs/source/_static/helper.js
new file mode 100644
index 000000000..cb2e2a819
--- /dev/null
+++ b/packages/python/stitch/docs/source/_static/helper.js
@@ -0,0 +1,5 @@
+var cache_require = window.require;
+
+window.addEventListener('load', function() {
+  window.require = cache_require;
+});
diff --git a/packages/python/stitch/docs/source/conf.py b/packages/python/stitch/docs/source/conf.py
new file mode 100644
index 000000000..d581c4b5d
--- /dev/null
+++ b/packages/python/stitch/docs/source/conf.py
@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# stitch documentation build configuration file
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.viewcode',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.todo',
+    'nbsphinx',
+    'jupyter_sphinx',
+    'nbsphinx_link',
+]
+
+# Set the nbsphinx JS path to empty to avoid showing twice of the widgets
+nbsphinx_requirejs_path = ""
+nbsphinx_widgets_path = ""
+
+# Ensure our extension is available:
+import sys
+from os.path import dirname, join as pjoin
+docs = dirname(dirname(__file__))
+root = dirname(docs)
+sys.path.insert(0, root)
+sys.path.insert(0, pjoin(docs, 'sphinxext'))
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = 'stitch'
+copyright = '2024, Guidance Contributors'
+author = 'Guidance Contributors'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+
+
+# get version from python package:
+import os
+here = os.path.dirname(__file__)
+repo = os.path.join(here, '..', '..')
+_version_py = os.path.join(repo, 'stitch', '_version.py')
+version_ns = {}
+with open(_version_py) as f:
+    exec(f.read(), version_ns)
+
+# The short X.Y version.
+version = '%i.%i' % version_ns['version_info'][:2]
+# The full version, including alpha/beta/rc tags.
+release = version_ns['__version__']
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = "en"
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+exclude_patterns = ['**.ipynb_checkpoints']
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+# html_theme_options = {}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+
+# -- Options for HTMLHelp output ------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'stitchdoc'
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #
+    # 'papersize': 'letterpaper',
+
+    # The font size ('10pt', '11pt' or '12pt').
+    #
+    # 'pointsize': '10pt',
+
+    # Additional stuff for the LaTeX preamble.
+    #
+    # 'preamble': '',
+
+    # Latex figure (float) alignment
+    #
+    # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (master_doc, 'stitch.tex', 'stitch Documentation',
+     'Guidance Contributors', 'manual'),
+]
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc,
+    'stitch',
+    'stitch Documentation',
+     [author], 1)
+]
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc,
+     'stitch',
+     'stitch Documentation',
+     author,
+     'stitch',
+     'Bidirectional comms for Jupyter and JavaScript.',
+     'Miscellaneous'),
+]
+
+
+# Example configuration for intersphinx: refer to the Python standard library.
+intersphinx_mapping = {'https://docs.python.org/': None}
+
+# Read The Docs
+# on_rtd is whether we are on readthedocs.org, this line of code grabbed from
+# docs.readthedocs.org
+on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
+
+if not on_rtd:  # only import and set the theme if we're building docs locally
+    import sphinx_rtd_theme
+    html_theme = 'sphinx_rtd_theme'
+    html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
+
+# otherwise, readthedocs.org uses their theme by default, so no need to specify it
+
+
+# Uncomment this line if you have know exceptions in your included notebooks
+# that nbsphinx complains about:
+#
+nbsphinx_allow_errors = True # exception ipstruct.py ipython_genutils
+
+from sphinx.util import logging
+logger = logging.getLogger(__name__)
+
+def setup(app):
+    def add_scripts(app):
+        for fname in ['helper.js', 'embed-bundle.js']:
+            if not os.path.exists(os.path.join(here, '_static', fname)):
+                logger.warning('missing javascript file: %s' % fname)
+            app.add_js_file(fname)
+    app.connect('builder-inited', add_scripts)
diff --git a/packages/python/stitch/docs/source/develop-install.rst b/packages/python/stitch/docs/source/develop-install.rst
new file mode 100644
index 000000000..3f66ed415
--- /dev/null
+++ b/packages/python/stitch/docs/source/develop-install.rst
@@ -0,0 +1,31 @@
+
+Developer install
+=================
+
+
+To install a developer version of stitch, you will first need to clone
+the repository::
+
+    git clone https://github.com/guidance-ai/stitch
+    cd stitch
+
+Next, install it with a develop install using pip::
+
+    pip install -e .
+
+
+If you are planning on working on the JS/frontend code, you should also do
+a link installation of the extension::
+
+    jupyter nbextension install [--sys-prefix / --user / --system] --symlink --py stitch
+
+    jupyter nbextension enable [--sys-prefix / --user / --system] --py stitch
+
+with the `appropriate flag`_. Or, if you are using Jupyterlab::
+
+    jupyter labextension install .
+
+
+.. links
+
+.. _`appropriate flag`: https://jupyter-notebook.readthedocs.io/en/stable/extending/frontend_extensions.html#installing-and-enabling-extensions
diff --git a/packages/python/stitch/docs/source/examples/index.rst b/packages/python/stitch/docs/source/examples/index.rst
new file mode 100644
index 000000000..57bad7f44
--- /dev/null
+++ b/packages/python/stitch/docs/source/examples/index.rst
@@ -0,0 +1,18 @@
+
+Examples
+========
+
+This section contains several examples generated from Jupyter notebooks.
+The widgets have been embedded into the page for demonstrative purposes.
+
+.. todo::
+
+    Add links to notebooks in examples folder similar to the initial
+    one. This is a manual step to ensure only those examples that
+    are suited for inclusion are used.
+
+
+.. toctree::
+    :glob:
+
+    *
diff --git a/packages/python/stitch/docs/source/examples/introduction.nblink b/packages/python/stitch/docs/source/examples/introduction.nblink
new file mode 100644
index 000000000..258bb0f01
--- /dev/null
+++ b/packages/python/stitch/docs/source/examples/introduction.nblink
@@ -0,0 +1,3 @@
+{
+  "path": "../../../examples/introduction.ipynb"
+}
diff --git a/packages/python/stitch/docs/source/index.rst b/packages/python/stitch/docs/source/index.rst
new file mode 100644
index 000000000..413f16721
--- /dev/null
+++ b/packages/python/stitch/docs/source/index.rst
@@ -0,0 +1,49 @@
+
+stitch
+=====================================
+
+Version: |release|
+
+Bidirectional comms for Jupyter and JavaScript.
+
+
+Quickstart
+----------
+
+To get started with stitch, install with pip::
+
+    pip install stitch
+
+or with conda::
+
+    conda install stitch
+
+
+Contents
+--------
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Installation and usage
+
+   installing
+   introduction
+
+.. toctree::
+   :maxdepth: 1
+
+   examples/index
+
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Development
+
+   develop-install
+
+
+.. links
+
+.. _`Jupyter widgets`: https://jupyter.org/widgets.html
+
+.. _`notebook`: https://jupyter-notebook.readthedocs.io/en/latest/
diff --git a/packages/python/stitch/docs/source/installing.rst b/packages/python/stitch/docs/source/installing.rst
new file mode 100644
index 000000000..e5f8ad74f
--- /dev/null
+++ b/packages/python/stitch/docs/source/installing.rst
@@ -0,0 +1,37 @@
+
+.. _installation:
+
+Installation
+============
+
+
+The simplest way to install stitch is via pip::
+
+    pip install stitch
+
+or via conda::
+
+    conda install stitch
+
+
+If you installed via pip, and notebook version < 5.3, you will also have to
+install / configure the front-end extension as well. If you are using classic
+notebook (as opposed to Jupyterlab), run::
+
+    jupyter nbextension install [--sys-prefix / --user / --system] --py stitch
+
+    jupyter nbextension enable [--sys-prefix / --user / --system] --py stitch
+
+with the `appropriate flag`_. If you are using Jupyterlab, install the extension
+with::
+
+    jupyter labextension install stitch
+
+If you are installing using conda, these commands should be unnecessary, but If
+you need to run them the commands should be the same (just make sure you choose the
+`--sys-prefix` flag).
+
+
+.. links
+
+.. _`appropriate flag`: https://jupyter-notebook.readthedocs.io/en/stable/extending/frontend_extensions.html#installing-and-enabling-extensions
diff --git a/packages/python/stitch/docs/source/introduction.rst b/packages/python/stitch/docs/source/introduction.rst
new file mode 100644
index 000000000..ad0edd44f
--- /dev/null
+++ b/packages/python/stitch/docs/source/introduction.rst
@@ -0,0 +1,7 @@
+=============
+Introduction
+=============
+
+.. todo::
+
+    add prose explaining project purpose and usage here
diff --git a/packages/python/stitch/examples/introduction.ipynb b/packages/python/stitch/examples/introduction.ipynb
new file mode 100644
index 000000000..b6e992f47
--- /dev/null
+++ b/packages/python/stitch/examples/introduction.ipynb
@@ -0,0 +1,123 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Introduction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import stitch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "w = stitch.StitchWidget()\n",
+    "w.srcdoc = \"\"\"\n",
+    "<html style=\"\">\n",
+    "<script>\n",
+    "window.addEventListener(\"message\", function(event) {\n",
+    "    if (event.source === window.parent && event.data.type === \"kernelmsg\") {\n",
+    "        document.getElementById(\"msgview\").innerHTML = event.data.content;\n",
+    "        window.parent.postMessage({type: \"clientmsg\", content: event.data.content}, \"*\");\n",
+    "    }\n",
+    "});\n",
+    "\n",
+    "window.addEventListener(\"load\", function(){\n",
+    "    var prevHeight = 0;\n",
+    "    setInterval(function() {\n",
+    "        var body = document.body;\n",
+    "        var html = document.documentElement;\n",
+    "        var height = html.getBoundingClientRect().height\n",
+    "        if (height !== prevHeight && html.checkVisibility()) {\n",
+    "            msg = {\n",
+    "                type: 'resize',\n",
+    "                content: {\n",
+    "                    height: height + 'px',\n",
+    "                    width: '100%'\n",
+    "                }\n",
+    "            };\n",
+    "            window.parent.postMessage(msg, \"*\");\n",
+    "            prevHeight = height;\n",
+    "        }\n",
+    "    }, 100);\n",
+    "});\n",
+    "\n",
+    "</script>\n",
+    "<body style=\"\">\n",
+    "<div>\n",
+    "MESSAGE: <span id=\"msgview\" style=\"background-color: #90ee90;\"></span>\n",
+    "</div>\n",
+    "</body>\n",
+    "</html>\n",
+    "\"\"\"\n",
+    "w.initial_width = '100%'\n",
+    "w.initial_height = 'auto'\n",
+    "display(w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "w.kernelmsg = \"\"\"\n",
+    "A language model is a probabilistic model of a natural language.[1] In 1980, the first significant statistical language model was proposed, and during the decade IBM performed ‘Shannon-style’ experiments, in which potential sources for language modeling improvement were identified by observing and analyzing the performance of human subjects in predicting or correcting text.[2]\n",
+    "\n",
+    "Language models are useful for a variety of tasks, including speech recognition[3] (helping prevent predictions of low-probability (e.g. nonsense) sequences), machine translation,[4] natural language generation (generating more human-like text), optical character recognition, handwriting recognition,[5] grammar induction,[6] and information retrieval.[7][8]\n",
+    "\n",
+    "Large language models, currently their most advanced form, are a combination of larger datasets (frequently using words scraped from the public internet), feedforward neural networks, and transformers. They have superseded recurrent neural network-based models, which had previously superseded the pure statistical models, such as word n-gram language model. \n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "w.observe(lambda x: print(x['new']), 'kernelmsg')\n",
+    "w.kernelmsg = \"Wow, a change!\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/packages/python/stitch/install.json b/packages/python/stitch/install.json
new file mode 100644
index 000000000..fd70e6be8
--- /dev/null
+++ b/packages/python/stitch/install.json
@@ -0,0 +1,5 @@
+{
+  "packageManager": "python",
+  "packageName": "stitch",
+  "uninstallInstructions": "Use your Python package manager (pip, conda, etc.) to uninstall the package stitch"
+}
diff --git a/packages/python/stitch/jest.config.js b/packages/python/stitch/jest.config.js
new file mode 100644
index 000000000..79453a3ae
--- /dev/null
+++ b/packages/python/stitch/jest.config.js
@@ -0,0 +1,16 @@
+module.exports = {
+  automock: false,
+  moduleNameMapper: {
+    '\\.(css|less|sass|scss)$': 'identity-obj-proxy',
+  },
+  preset: 'ts-jest/presets/js-with-babel',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  testPathIgnorePatterns: ['/lib/', '/node_modules/'],
+  testRegex: '/__tests__/.*.spec.ts[x]?$',
+  transformIgnorePatterns: ['/node_modules/(?!(@jupyter(lab|-widgets)/.*)/)'],
+  globals: {
+    'ts-jest': {
+      tsconfig: '<rootDir>/tsconfig.json',
+    },
+  },
+};
diff --git a/packages/python/stitch/package.json b/packages/python/stitch/package.json
new file mode 100644
index 000000000..b510ce5d5
--- /dev/null
+++ b/packages/python/stitch/package.json
@@ -0,0 +1,101 @@
+{
+  "name": "stitch",
+  "version": "0.1.0",
+  "description": "Bidirectional comms for Jupyter and JavaScript.",
+  "keywords": [
+    "jupyter",
+    "jupyterlab",
+    "jupyterlab-extension",
+    "widgets"
+  ],
+  "files": [
+    "lib/**/*.js",
+    "dist/*.js",
+    "css/*.css"
+  ],
+  "homepage": "https://github.com/guidance-ai/guidance",
+  "bugs": {
+    "url": "https://github.com/guidance-ai/guidance/issues"
+  },
+  "license": "BSD-3-Clause",
+  "author": {
+    "name": "Guidance Contributors",
+    "email": "maintainers@guidance-ai.org"
+  },
+  "main": "lib/index.js",
+  "types": "./lib/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/guidance-ai/guidance"
+  },
+  "scripts": {
+    "build": "jlpm run build:lib && jlpm run build:nbextension && jlpm run build:labextension:dev",
+    "build:prod": "jlpm run build:lib && jlpm run build:nbextension && jlpm run build:labextension",
+    "build:labextension": "jupyter labextension build .",
+    "build:labextension:dev": "jupyter labextension build --development True .",
+    "build:lib": "tsc",
+    "build:nbextension": "webpack",
+    "clean": "jlpm run clean:lib && jlpm run clean:nbextension && jlpm run clean:labextension",
+    "clean:lib": "rimraf lib",
+    "clean:labextension": "rimraf stitch/labextension",
+    "clean:nbextension": "rimraf stitch/nbextension/static/index.js",
+    "lint": "eslint . --ext .ts,.tsx --fix",
+    "lint:check": "eslint . --ext .ts,.tsx",
+    "prepack": "jlpm run build:lib",
+    "test": "jest",
+    "watch": "npm-run-all -p watch:*",
+    "watch:lib": "tsc -w",
+    "watch:nbextension": "webpack --watch --mode=development",
+    "watch:labextension": "jupyter labextension watch ."
+  },
+  "dependencies": {
+    "@jupyter-widgets/base": "^1.1.10 || ^2 || ^3 || ^4 || ^5 || ^6"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.23.7",
+    "@babel/preset-env": "^7.23.8",
+    "@jupyter-widgets/base-manager": "^1.0.7",
+    "@jupyterlab/builder": "^4.0.11",
+    "@lumino/application": "^2.3.0",
+    "@lumino/widgets": "^2.3.1",
+    "@types/jest": "^29.5.11",
+    "@types/webpack-env": "^1.18.4",
+    "@typescript-eslint/eslint-plugin": "^6.19.1",
+    "@typescript-eslint/parser": "^6.19.1",
+    "acorn": "^8.11.3",
+    "css-loader": "^6.9.1",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "fs-extra": "^11.2.0",
+    "identity-obj-proxy": "^3.0.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "mkdirp": "^3.0.1",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^3.2.4",
+    "rimraf": "^5.0.5",
+    "source-map-loader": "^5.0.0",
+    "style-loader": "^3.3.4",
+    "ts-jest": "^29.1.2",
+    "ts-loader": "^9.5.1",
+    "typescript": "~5.3.3",
+    "webpack": "^5.90.0",
+    "webpack-cli": "^5.1.4"
+  },
+  "devDependenciesComments": {
+    "@jupyterlab/builder": "pinned to the latest JupyterLab 3.x release",
+    "@lumino/application": "pinned to the latest Lumino 1.x release",
+    "@lumino/widgets": "pinned to the latest Lumino 1.x release"
+  },
+  "jupyterlab": {
+    "extension": "lib/plugin",
+    "outputDir": "stitch/labextension/",
+    "sharedPackages": {
+      "@jupyter-widgets/base": {
+        "bundled": false,
+        "singleton": true
+      }
+    }
+  }
+}
diff --git a/packages/python/stitch/pyproject.toml b/packages/python/stitch/pyproject.toml
new file mode 100644
index 000000000..7712ab07f
--- /dev/null
+++ b/packages/python/stitch/pyproject.toml
@@ -0,0 +1,122 @@
+[build-system]
+requires = [
+    "hatchling>=1.21.1",
+    "jupyterlab>=4.0.0,<5",
+    "hatch-nodejs-version>=0.3.2",
+]
+build-backend = "hatchling.build"
+
+[project]
+name = "guidance-stitch"
+description = "Bidirectional comms for Jupyter and JavaScript."
+readme = "README.md"
+license = { file = "LICENSE.txt" }
+requires-python = ">=3.9"
+authors = [
+    { name = "Guidance Maintainers", email = "maintainers@guidance-ai.org" },
+]
+keywords = [
+    "IPython",
+    "Jupyter",
+    "Widgets",
+]
+classifiers = [
+    "Framework :: Jupyter",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: BSD License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "ipywidgets>=8.0.0",
+]
+version = "0.1.0"
+
+[project.optional-dependencies]
+docs = [
+    "jupyter_sphinx",
+    "nbsphinx",
+    "nbsphinx-link",
+    "pypandoc",
+    "pytest_check_links",
+    "recommonmark",
+    "sphinx>=1.5",
+    "sphinx_rtd_theme",
+]
+examples = []
+test = [
+    "nbval",
+    "pytest-cov",
+    "pytest>=6.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/guidance-ai/guidance"
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build]
+artifacts = [
+    "stitch/nbextension/index.*",
+    "stitch/labextension/*.tgz",
+    "stitch/labextension",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["stitch"]
+
+[tool.hatch.build.targets.wheel.shared-data]
+"stitch/nbextension" = "share/jupyter/nbextensions/stitch"
+"stitch/labextension" = "share/jupyter/labextensions/stitch"
+"./install.json" = "share/jupyter/labextensions/stitch/install.json"
+"./stitch.json" = "etc/jupyter/nbconfig/notebook.d/stitch.json"
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    ".github",
+]
+
+[tool.hatch.build.hooks.jupyter-builder]
+build-function = "hatch_jupyter_builder.npm_builder"
+ensured-targets = [
+    "stitch/nbextension/index.js",
+    "stitch/labextension/package.json",
+]
+skip-if-exists = [
+    "stitch/nbextension/index.js",
+    "stitch/labextension/package.json",
+]
+dependencies = [
+    "hatch-jupyter-builder>=0.8.3",
+]
+
+[tool.hatch.build.hooks.jupyter-builder.build-kwargs]
+path = "."
+build_cmd = "build:prod"
+npm = ["jlpm"]
+
+[tool.tbump]
+field = [
+    { name = "channel", default = "" },
+    { name = "release", default = "" },
+]
+file = [
+    { src = "pyproject.toml", version_template = "version = \"{major}.{minor}.{patch}{channel}{release}\"" },
+    { src = "stitch/_version.py" },
+]
+
+[tool.tbump.version]
+current = "0.1.0.dev0"
+regex = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)((?P<channel>a|b|rc|.dev)(?P<release>\\d+))?"
+
+[tool.tbump.git]
+message_template = "Bump to {new_version}"
+tag_template = "v{new_version}"
diff --git a/packages/python/stitch/pytest.ini b/packages/python/stitch/pytest.ini
new file mode 100644
index 000000000..e77e2a193
--- /dev/null
+++ b/packages/python/stitch/pytest.ini
@@ -0,0 +1,4 @@
+[pytest]
+testpaths = stitch/tests examples
+norecursedirs = node_modules .ipynb_checkpoints
+addopts = --nbval --current-env
diff --git a/packages/python/stitch/readthedocs.yml b/packages/python/stitch/readthedocs.yml
new file mode 100644
index 000000000..c972d9ccf
--- /dev/null
+++ b/packages/python/stitch/readthedocs.yml
@@ -0,0 +1,9 @@
+type: sphinx
+python:
+  version: 3.5
+  pip_install: true
+  extra_requirements:
+    - examples
+    - docs
+conda:
+  file: docs/environment.yml
diff --git a/packages/python/stitch/setup.py b/packages/python/stitch/setup.py
new file mode 100644
index 000000000..b6c668135
--- /dev/null
+++ b/packages/python/stitch/setup.py
@@ -0,0 +1,2 @@
+# setup.py shim for use with applications that require it.
+__import__("setuptools").setup()
diff --git a/packages/python/stitch/src/__tests__/index.spec.ts b/packages/python/stitch/src/__tests__/index.spec.ts
new file mode 100644
index 000000000..2f11e4498
--- /dev/null
+++ b/packages/python/stitch/src/__tests__/index.spec.ts
@@ -0,0 +1,33 @@
+/** @jest-environment jsdom */
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+// Add any needed widget imports here (or from controls)
+// import {} from '@jupyter-widgets/base';
+
+// NOTE(nopdive): Workaround for jsdom drag event failure.
+Object.defineProperty(window, 'DragEvent', {
+  value: class DragEvent {},
+});
+
+import { createTestModel } from './utils';
+import { StitchModel } from '..';
+
+describe('Example', () => {
+  describe('StitchModel', () => {
+    it('should be createable', () => {
+      const model = createTestModel(StitchModel);
+      expect(model).toBeInstanceOf(StitchModel);
+      expect(model.get('srcdoc')).toEqual(
+        '<p>srcdoc should be defined by the user</p>',
+      );
+    });
+
+    it('should be createable with a value', () => {
+      const state = { srcdoc: 'it is alright' };
+      const model = createTestModel(StitchModel, state);
+      expect(model).toBeInstanceOf(StitchModel);
+      expect(model.get('srcdoc')).toEqual('it is alright');
+    });
+  });
+});
diff --git a/packages/python/stitch/src/__tests__/utils.ts b/packages/python/stitch/src/__tests__/utils.ts
new file mode 100644
index 000000000..0a61d63e9
--- /dev/null
+++ b/packages/python/stitch/src/__tests__/utils.ts
@@ -0,0 +1,119 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+import * as widgets from '@jupyter-widgets/base';
+import * as baseManager from '@jupyter-widgets/base-manager';
+import * as services from '@jupyterlab/services';
+
+let numComms = 0;
+
+export class MockComm implements widgets.IClassicComm {
+  constructor() {
+    this.comm_id = `mock-comm-id-${numComms}`;
+    numComms += 1;
+  }
+  on_close(fn: ((x?: any) => void) | null): void {
+    this._on_close = fn;
+  }
+  on_msg(fn: (x?: any) => void): void {
+    this._on_msg = fn;
+  }
+  _process_msg(msg: services.KernelMessage.ICommMsgMsg): void | Promise<void> {
+    if (this._on_msg) {
+      return this._on_msg(msg);
+    } else {
+      return Promise.resolve();
+    }
+  }
+  close(): string {
+    if (this._on_close) {
+      this._on_close();
+    }
+    return 'dummy';
+  }
+  send(): string {
+    return 'dummy';
+  }
+
+  open(): string {
+    return 'dummy';
+  }
+
+  comm_id: string;
+  target_name = 'dummy';
+  _on_msg: ((x?: any) => void) | null = null;
+  _on_close: ((x?: any) => void) | null = null;
+}
+
+export class DummyManager extends baseManager.ManagerBase {
+  constructor() {
+    super();
+    this.el = window.document.createElement('div');
+  }
+
+  display_view(
+    msg: services.KernelMessage.IMessage,
+    view: widgets.DOMWidgetView,
+    options: any
+  ) {
+    // TODO: make this a spy
+    // TODO: return an html element
+    return Promise.resolve(view).then((view) => {
+      this.el.appendChild(view.el);
+      view.on('remove', () => console.log('view removed', view));
+      return view.el;
+    });
+  }
+
+  protected loadClass(
+    className: string,
+    moduleName: string,
+    moduleVersion: string
+  ): Promise<any> {
+    if (moduleName === '@jupyter-widgets/base') {
+      if ((widgets as any)[className]) {
+        return Promise.resolve((widgets as any)[className]);
+      } else {
+        return Promise.reject(`Cannot find class ${className}`);
+      }
+    } else if (moduleName === 'jupyter-datawidgets') {
+      if (this.testClasses[className]) {
+        return Promise.resolve(this.testClasses[className]);
+      } else {
+        return Promise.reject(`Cannot find class ${className}`);
+      }
+    } else {
+      return Promise.reject(`Cannot find module ${moduleName}`);
+    }
+  }
+
+  _get_comm_info() {
+    return Promise.resolve({});
+  }
+
+  _create_comm() {
+    return Promise.resolve(new MockComm());
+  }
+
+  el: HTMLElement;
+
+  testClasses: { [key: string]: any } = {};
+}
+
+export interface Constructor<T> {
+  new (attributes?: any, options?: any): T;
+}
+
+export function createTestModel<T extends widgets.WidgetModel>(
+  constructor: Constructor<T>,
+  attributes?: any
+): T {
+  const id = widgets.uuid();
+  const widget_manager = new DummyManager();
+  const modelOptions = {
+    widget_manager: widget_manager,
+    model_id: id,
+  };
+
+  return new constructor(attributes, modelOptions);
+}
diff --git a/packages/python/stitch/src/extension.ts b/packages/python/stitch/src/extension.ts
new file mode 100644
index 000000000..18ef180b2
--- /dev/null
+++ b/packages/python/stitch/src/extension.ts
@@ -0,0 +1,16 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+// Entry point for the notebook bundle containing custom model definitions.
+//
+// Setup notebook base URL
+//
+// Some static assets may be required by the custom widget javascript. The base
+// url for the notebook is not known at build time and is therefore computed
+// dynamically.
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+(window as any).__webpack_public_path__ =
+  document.querySelector('body')!.getAttribute('data-base-url') +
+  'nbextensions/stitch';
+
+export * from './index';
diff --git a/packages/python/stitch/src/index.ts b/packages/python/stitch/src/index.ts
new file mode 100644
index 000000000..182c4ca09
--- /dev/null
+++ b/packages/python/stitch/src/index.ts
@@ -0,0 +1,5 @@
+// Copyright (c) Guidance Contributors
+// Distributed under the terms of the Modified BSD License.
+
+export * from './version';
+export * from './widget';
diff --git a/packages/python/stitch/src/plugin.ts b/packages/python/stitch/src/plugin.ts
new file mode 100644
index 000000000..49bea2f54
--- /dev/null
+++ b/packages/python/stitch/src/plugin.ts
@@ -0,0 +1,42 @@
+// Copyright (c) Guidance Contributors
+// Distributed under the terms of the Modified BSD License.
+
+import { Application, IPlugin } from '@lumino/application';
+
+import { Widget } from '@lumino/widgets';
+
+import { IJupyterWidgetRegistry } from '@jupyter-widgets/base';
+
+import * as widgetExports from './widget';
+
+import { MODULE_NAME, MODULE_VERSION } from './version';
+
+const EXTENSION_ID = 'stitch:plugin';
+
+/**
+ * The example plugin.
+ */
+const examplePlugin: IPlugin<Application<Widget>, void> = {
+  id: EXTENSION_ID,
+  requires: [IJupyterWidgetRegistry],
+  activate: activateWidgetExtension,
+  autoStart: true,
+} as unknown as IPlugin<Application<Widget>, void>;
+// the "as unknown as ..." typecast above is solely to support JupyterLab 1
+// and 2 in the same codebase and should be removed when we migrate to Lumino.
+
+export default examplePlugin;
+
+/**
+ * Activate the widget extension.
+ */
+function activateWidgetExtension(
+  app: Application<Widget>,
+  registry: IJupyterWidgetRegistry
+): void {
+  registry.registerWidget({
+    name: MODULE_NAME,
+    version: MODULE_VERSION,
+    exports: widgetExports,
+  });
+}
diff --git a/packages/python/stitch/src/version.ts b/packages/python/stitch/src/version.ts
new file mode 100644
index 000000000..eb22f91b3
--- /dev/null
+++ b/packages/python/stitch/src/version.ts
@@ -0,0 +1,20 @@
+// Copyright (c) Guidance Contributors
+// Distributed under the terms of the Modified BSD License.
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const data = require('../package.json');
+
+/**
+ * The _model_module_version/_view_module_version this package implements.
+ *
+ * The html widget manager assumes that this is the same as the npm package
+ * version number.
+ */
+export const MODULE_VERSION = data.version;
+
+/*
+ * The current package name.
+ */
+export const MODULE_NAME = data.name;
diff --git a/packages/python/stitch/src/widget.ts b/packages/python/stitch/src/widget.ts
new file mode 100644
index 000000000..79922e720
--- /dev/null
+++ b/packages/python/stitch/src/widget.ts
@@ -0,0 +1,114 @@
+// Copyright (c) Guidance Contributors
+// Distributed under the terms of the Modified BSD License.
+
+import {
+  DOMWidgetModel,
+  DOMWidgetView,
+  ISerializers,
+} from '@jupyter-widgets/base';
+
+import { MODULE_NAME, MODULE_VERSION } from './version';
+
+// Import the CSS
+import '../css/widget.css';
+
+export class StitchModel extends DOMWidgetModel {
+  defaults() {
+    return {
+      ...super.defaults(),
+      _model_name: StitchModel.model_name,
+      _model_module: StitchModel.model_module,
+      _model_module_version: StitchModel.model_module_version,
+      _view_name: StitchModel.view_name,
+      _view_module: StitchModel.view_module,
+      _view_module_version: StitchModel.view_module_version,
+      kernelmsg: '',
+      clientmsg: '',
+      srcdoc: '<p>srcdoc should be defined by the user</p>',
+      initial_height: '1px',
+      initial_width: '1px',
+      initial_border: '0',
+    };
+  }
+
+  static serializers: ISerializers = {
+    ...DOMWidgetModel.serializers,
+    // Add any extra serializers here
+  };
+
+  static model_name = 'StitchModel';
+  static model_module = MODULE_NAME;
+  static model_module_version = MODULE_VERSION;
+  static view_name = 'StitchView'; // Set to null if no view
+  static view_module = MODULE_NAME; // Set to null if no view
+  static view_module_version = MODULE_VERSION;
+}
+
+export class StitchView extends DOMWidgetView {
+  private _iframe: HTMLIFrameElement;
+
+  render() {
+    // Create sandboxed frame
+    const iframe = document.createElement('iframe');
+    iframe.sandbox.add('allow-scripts');
+    iframe.srcdoc = this.model.get('srcdoc');
+    iframe.style.height = this.model.get('initial_height');
+    iframe.style.width = this.model.get('initial_width');
+    iframe.style.border = this.model.get('initial_border');
+    iframe.style.display = 'block';
+    this._iframe = iframe;
+
+    // Send first kernelmsg on load.
+    const refreshTimeMs = 100;
+    const sendKernelMsgOnReady = () => {
+      if (this.model.isNew()) {
+        window.setTimeout(sendKernelMsgOnReady, refreshTimeMs);
+      } else {
+        this.kernelmsg_changed();
+      }
+    };
+    window.setTimeout(sendKernelMsgOnReady, refreshTimeMs);
+
+    // Add callback for forwarding messages from client to kernel
+    const model = this.model;
+    const recvFromClient = (event: any) => {
+      const win = iframe.contentWindow;
+      if (win === event.source && event.data.type === 'clientmsg') {
+        model.set('clientmsg', event.data.content);
+        model.save_changes();
+      } else if (win === event.source && event.data.type === 'resize') {
+        iframe.style.height = event.data.content.height;
+        iframe.style.width = event.data.content.width;
+      }
+    };
+    window.addEventListener('message', recvFromClient);
+
+    // Add iframe to root element of widget
+    this.el.appendChild(this._iframe);
+
+    // Connect callbacks for forwarding from kernel to client
+    this.model.on('change:kernelmsg', this.kernelmsg_changed, this);
+
+    // Connect callback for when kernel changes the srcdoc
+    this.model.on('change:srcdoc', this.srcdoc_changed, this);
+  }
+
+  kernelmsg_changed() {
+    // Forward message from kernel to client
+    const kernelmsg = this.model.get('kernelmsg');
+    const winmsg = {
+      type: 'kernelmsg',
+      content: kernelmsg,
+    };
+    this._iframe.contentWindow?.postMessage(winmsg, '*');
+  }
+
+  srcdoc_changed() {
+    // Apply srcdoc provided by client
+    const srcdoc = this.model.get('srcdoc');
+    this._iframe.srcdoc = srcdoc;
+
+    // Push last kernelmsg immediately to iframe
+    this.kernelmsg_changed();
+  }
+}
diff --git a/packages/python/stitch/stitch.json b/packages/python/stitch/stitch.json
new file mode 100644
index 000000000..d18d678e2
--- /dev/null
+++ b/packages/python/stitch/stitch.json
@@ -0,0 +1,5 @@
+{
+  "load_extensions": {
+    "stitch/extension": true
+  }
+}
diff --git a/packages/python/stitch/stitch/__init__.py b/packages/python/stitch/stitch/__init__.py
new file mode 100644
index 000000000..e984ee173
--- /dev/null
+++ b/packages/python/stitch/stitch/__init__.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# Copyright (c) Guidance Contributors.
+# Distributed under the terms of the Modified BSD License.
+
+from .stitch import StitchWidget
+from ._version import __version__, version_info
+
+def _jupyter_labextension_paths():
+    """Called by Jupyter Lab Server to detect if it is a valid labextension and
+    to install the widget
+    Returns
+    =======
+    src: Source directory name to copy files from. Webpack outputs generated files
+        into this directory and Jupyter Lab copies from this directory during
+        widget installation
+    dest: Destination directory name to install widget files to. Jupyter Lab copies
+        from `src` directory into <jupyter path>/labextensions/<dest> directory
+        during widget installation
+    """
+    return [{
+        'src': 'labextension',
+        'dest': 'stitch',
+    }]
+
+
+def _jupyter_nbextension_paths():
+    """Called by Jupyter Notebook Server to detect if it is a valid nbextension and
+    to install the widget
+    Returns
+    =======
+    section: The section of the Jupyter Notebook Server to change.
+        Must be 'notebook' for widget extensions
+    src: Source directory name to copy files from. Webpack outputs generated files
+        into this directory and Jupyter Notebook copies from this directory during
+        widget installation
+    dest: Destination directory name to install widget files to. Jupyter Notebook copies
+        from `src` directory into <jupyter path>/nbextensions/<dest> directory
+        during widget installation
+    require: Path to importable AMD Javascript module inside the
+        <jupyter path>/nbextensions/<dest> directory
+    """
+    return [{
+        'section': 'notebook',
+        'src': 'nbextension',
+        'dest': 'stitch',
+        'require': 'stitch/extension'
+    }]
diff --git a/packages/python/stitch/stitch/_frontend.py b/packages/python/stitch/stitch/_frontend.py
new file mode 100644
index 000000000..4dcf81718
--- /dev/null
+++ b/packages/python/stitch/stitch/_frontend.py
@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# Copyright (c) Guidance Contributors.
+# Distributed under the terms of the Modified BSD License.
+
+"""
+Information about the frontend package of the widgets.
+"""
+
+module_name = "stitch"
+module_version = "^0.1.0"
diff --git a/packages/python/stitch/stitch/_version.py b/packages/python/stitch/stitch/_version.py
new file mode 100644
index 000000000..37c53b133
--- /dev/null
+++ b/packages/python/stitch/stitch/_version.py
@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# Copyright (c) Guidance Contributors.
+# Distributed under the terms of the Modified BSD License.
+
+version_info = (0, 1, 0)
+__version__ = ".".join(map(str, version_info))
diff --git a/packages/python/stitch/stitch/nbextension/extension.js b/packages/python/stitch/stitch/nbextension/extension.js
new file mode 100644
index 000000000..a06baadcc
--- /dev/null
+++ b/packages/python/stitch/stitch/nbextension/extension.js
@@ -0,0 +1,17 @@
+// Entry point for the notebook bundle containing custom model definitions.
+//
+define(function() {
+    "use strict";
+
+    window['requirejs'].config({
+        map: {
+            '*': {
+                'stitch': 'nbextensions/stitch/index',
+            },
+        }
+    });
+    // Export the required load_ipython_extension function
+    return {
+        load_ipython_extension : function() {}
+    };
+});
\ No newline at end of file
diff --git a/packages/python/stitch/stitch/stitch.py b/packages/python/stitch/stitch/stitch.py
new file mode 100644
index 000000000..66ebc29ab
--- /dev/null
+++ b/packages/python/stitch/stitch/stitch.py
@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# Copyright (c) Guidance Contributors.
+# Distributed under the terms of the Modified BSD License.
+
+"""
+Stitch Widget that allows bidirectional comms from Jupyter and JavaScript.
+"""
+
+from ipywidgets import DOMWidget
+from traitlets import Unicode
+from ._frontend import module_name, module_version
+
+
+class StitchWidget(DOMWidget):
+    """Widget that purely handles communication between an iframe and kernel via postMessage."""
+
+    _model_name = Unicode('StitchModel').tag(sync=True)
+    _model_module = Unicode(module_name).tag(sync=True)
+    _model_module_version = Unicode(module_version).tag(sync=True)
+    _view_name = Unicode('StitchView').tag(sync=True)
+    _view_module = Unicode(module_name).tag(sync=True)
+    _view_module_version = Unicode(module_version).tag(sync=True)
+
+    kernelmsg = Unicode("").tag(sync=True)
+    clientmsg = Unicode("").tag(sync=True)
+    srcdoc = Unicode("<p>srcdoc should be defined by the user</p>").tag(sync=True)
+    initial_height = Unicode("1px").tag(sync=True)
+    initial_width = Unicode("1px").tag(sync=True)
+    initial_border = Unicode("0").tag(sync=True)
diff --git a/packages/python/stitch/stitch/tests/__init__.py b/packages/python/stitch/stitch/tests/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/python/stitch/stitch/tests/conftest.py b/packages/python/stitch/stitch/tests/conftest.py
new file mode 100644
index 000000000..ad3bd1758
--- /dev/null
+++ b/packages/python/stitch/stitch/tests/conftest.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# Copyright (c) Guidance Contributors.
+# Distributed under the terms of the Modified BSD License.
+
+import pytest
+
+from ipykernel.comm import Comm
+from ipywidgets import Widget
+
+class MockComm(Comm):
+    """A mock Comm object.
+
+    Can be used to inspect calls to Comm's open/send/close methods.
+    """
+    comm_id = 'a-b-c-d'
+    kernel = 'Truthy'
+
+    def __init__(self, *args, **kwargs):
+        self.log_open = []
+        self.log_send = []
+        self.log_close = []
+        super(MockComm, self).__init__(*args, **kwargs)
+
+    def open(self, *args, **kwargs):
+        self.log_open.append((args, kwargs))
+
+    def send(self, *args, **kwargs):
+        self.log_send.append((args, kwargs))
+
+    def close(self, *args, **kwargs):
+        self.log_close.append((args, kwargs))
+
+_widget_attrs = {}
+undefined = object()
+
+
+@pytest.fixture
+def mock_comm():
+    _widget_attrs['_comm_default'] = getattr(Widget, '_comm_default', undefined)
+    Widget._comm_default = lambda self: MockComm()
+    _widget_attrs['_ipython_display_'] = Widget._ipython_display_
+    def raise_not_implemented(*args, **kwargs):
+        raise NotImplementedError()
+    Widget._ipython_display_ = raise_not_implemented
+
+    yield MockComm()
+
+    for attr, value in _widget_attrs.items():
+        if value is undefined:
+            delattr(Widget, attr)
+        else:
+            setattr(Widget, attr, value)
diff --git a/packages/python/stitch/stitch/tests/test_example.py b/packages/python/stitch/stitch/tests/test_example.py
new file mode 100644
index 000000000..0d216157a
--- /dev/null
+++ b/packages/python/stitch/stitch/tests/test_example.py
@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# Copyright (c) Guidance Contributors.
+# Distributed under the terms of the Modified BSD License.
+
+import pytest
+
+from ..stitch import StitchWidget
+
+
+def test_example_creation_blank():
+    w = StitchWidget()
+    assert w.kernelmsg == ""
+    assert w.clientmsg == ""
+    assert w.srcdoc == "<p>srcdoc should be defined by the user</p>"
diff --git a/packages/python/stitch/stitch/tests/test_nbextension_path.py b/packages/python/stitch/stitch/tests/test_nbextension_path.py
new file mode 100644
index 000000000..c134480ab
--- /dev/null
+++ b/packages/python/stitch/stitch/tests/test_nbextension_path.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# Copyright (c) Guidance Contributors.
+# Distributed under the terms of the Modified BSD License.
+
+
+def test_nbextension_path():
+    # Check that magic function can be imported from package root:
+    from stitch import _jupyter_nbextension_paths
+    # Ensure that it can be called without incident:
+    path = _jupyter_nbextension_paths()
+    # Some sanity checks:
+    assert len(path) == 1
+    assert isinstance(path[0], dict)
diff --git a/packages/python/stitch/tsconfig.eslint.json b/packages/python/stitch/tsconfig.eslint.json
new file mode 100644
index 000000000..737e3e680
--- /dev/null
+++ b/packages/python/stitch/tsconfig.eslint.json
@@ -0,0 +1,5 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "exclude": []
+}
\ No newline at end of file
diff --git a/packages/python/stitch/tsconfig.json b/packages/python/stitch/tsconfig.json
new file mode 100644
index 000000000..f143a554e
--- /dev/null
+++ b/packages/python/stitch/tsconfig.json
@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "esModuleInterop":true,
+    "lib": ["es2015", "dom"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "noEmitOnError": true,
+    "noUnusedLocals": true,
+    "outDir": "lib",
+    "resolveJsonModule": true,
+    "rootDir": "src",
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "strictPropertyInitialization": false,
+    "target": "es2015",
+    "types": ["jest"]
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+  ],
+  "exclude": ["src/**/__tests__"]
+}
diff --git a/packages/python/stitch/webpack.config.js b/packages/python/stitch/webpack.config.js
new file mode 100644
index 000000000..8faaf089b
--- /dev/null
+++ b/packages/python/stitch/webpack.config.js
@@ -0,0 +1,91 @@
+const path = require('path');
+const version = require('./package.json').version;
+
+// Custom webpack rules
+const rules = [
+  { test: /\.ts$/, loader: 'ts-loader' },
+  { test: /\.js$/, loader: 'source-map-loader' },
+  { test: /\.css$/, use: ['style-loader', 'css-loader']}
+];
+
+// Packages that shouldn't be bundled but loaded at runtime
+const externals = ['@jupyter-widgets/base'];
+
+const resolve = {
+  // Add '.ts' and '.tsx' as resolvable extensions.
+  extensions: [".webpack.js", ".web.js", ".ts", ".js"]
+};
+
+module.exports = [
+  /**
+   * Notebook extension
+   *
+   * This bundle only contains the part of the JavaScript that is run on load of
+   * the notebook.
+   */
+  {
+    entry: './src/extension.ts',
+    output: {
+      filename: 'index.js',
+      path: path.resolve(__dirname, 'stitch', 'nbextension'),
+      libraryTarget: 'amd',
+      publicPath: '',
+    },
+    module: {
+      rules: rules
+    },
+    devtool: 'source-map',
+    externals,
+    resolve,
+  },
+
+  /**
+   * Embeddable stitch bundle
+   *
+   * This bundle is almost identical to the notebook extension bundle. The only
+   * difference is in the configuration of the webpack public path for the
+   * static assets.
+   *
+   * The target bundle is always `dist/index.js`, which is the path required by
+   * the custom widget embedder.
+   */
+  {
+    entry: './src/index.ts',
+    output: {
+        filename: 'index.js',
+        path: path.resolve(__dirname, 'dist'),
+        libraryTarget: 'amd',
+        library: "stitch",
+        publicPath: 'https://unpkg.com/stitch@' + version + '/dist/'
+    },
+    devtool: 'source-map',
+    module: {
+        rules: rules
+    },
+    externals,
+    resolve,
+  },
+
+
+  /**
+   * Documentation widget bundle
+   *
+   * This bundle is used to embed widgets in the package documentation.
+   */
+  {
+    entry: './src/index.ts',
+    output: {
+      filename: 'embed-bundle.js',
+      path: path.resolve(__dirname, 'docs', 'source', '_static'),
+      library: "stitch",
+      libraryTarget: 'amd'
+    },
+    module: {
+      rules: rules
+    },
+    devtool: 'source-map',
+    externals,
+    resolve,
+  }
+
+];
diff --git a/packages/python/stitch/yarn.lock b/packages/python/stitch/yarn.lock
new file mode 100644
index 000000000..b3e0c518f
--- /dev/null
+++ b/packages/python/stitch/yarn.lock
@@ -0,0 +1,8955 @@
+# This file is generated by running "yarn install" inside your project.
+# Manual changes might be lost - proceed with caution!
+
+__metadata:
+  version: 6
+  cacheKey: 8
+
+"@ampproject/remapping@npm:^2.2.0":
+  version: 2.3.0
+  resolution: "@ampproject/remapping@npm:2.3.0"
+  dependencies:
+    "@jridgewell/gen-mapping": ^0.3.5
+    "@jridgewell/trace-mapping": ^0.3.24
+  checksum: d3ad7b89d973df059c4e8e6d7c972cbeb1bb2f18f002a3bd04ae0707da214cb06cc06929b65aa2313b9347463df2914772298bae8b1d7973f246bb3f2ab3e8f0
+  languageName: node
+  linkType: hard
+
+"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.12.13, @babel/code-frame@npm:^7.25.9, @babel/code-frame@npm:^7.26.0, @babel/code-frame@npm:^7.26.2":
+  version: 7.26.2
+  resolution: "@babel/code-frame@npm:7.26.2"
+  dependencies:
+    "@babel/helper-validator-identifier": ^7.25.9
+    js-tokens: ^4.0.0
+    picocolors: ^1.0.0
+  checksum: db13f5c42d54b76c1480916485e6900748bbcb0014a8aca87f50a091f70ff4e0d0a6db63cade75eb41fcc3d2b6ba0a7f89e343def4f96f00269b41b8ab8dd7b8
+  languageName: node
+  linkType: hard
+
+"@babel/compat-data@npm:^7.22.6, @babel/compat-data@npm:^7.25.9, @babel/compat-data@npm:^7.26.0":
+  version: 7.26.3
+  resolution: "@babel/compat-data@npm:7.26.3"
+  checksum: 85c5a9fb365231688c7faeb977f1d659da1c039e17b416f8ef11733f7aebe11fe330dce20c1844cacf243766c1d643d011df1d13cac9eda36c46c6c475693d21
+  languageName: node
+  linkType: hard
+
+"@babel/core@npm:^7.11.6, @babel/core@npm:^7.12.3, @babel/core@npm:^7.23.7, @babel/core@npm:^7.23.9":
+  version: 7.26.0
+  resolution: "@babel/core@npm:7.26.0"
+  dependencies:
+    "@ampproject/remapping": ^2.2.0
+    "@babel/code-frame": ^7.26.0
+    "@babel/generator": ^7.26.0
+    "@babel/helper-compilation-targets": ^7.25.9
+    "@babel/helper-module-transforms": ^7.26.0
+    "@babel/helpers": ^7.26.0
+    "@babel/parser": ^7.26.0
+    "@babel/template": ^7.25.9
+    "@babel/traverse": ^7.25.9
+    "@babel/types": ^7.26.0
+    convert-source-map: ^2.0.0
+    debug: ^4.1.0
+    gensync: ^1.0.0-beta.2
+    json5: ^2.2.3
+    semver: ^6.3.1
+  checksum: b296084cfd818bed8079526af93b5dfa0ba70282532d2132caf71d4060ab190ba26d3184832a45accd82c3c54016985a4109ab9118674347a7e5e9bc464894e6
+  languageName: node
+  linkType: hard
+
+"@babel/generator@npm:^7.26.0, @babel/generator@npm:^7.26.3, @babel/generator@npm:^7.7.2":
+  version: 7.26.3
+  resolution: "@babel/generator@npm:7.26.3"
+  dependencies:
+    "@babel/parser": ^7.26.3
+    "@babel/types": ^7.26.3
+    "@jridgewell/gen-mapping": ^0.3.5
+    "@jridgewell/trace-mapping": ^0.3.25
+    jsesc: ^3.0.2
+  checksum: fb09fa55c66f272badf71c20a3a2cee0fa1a447fed32d1b84f16a668a42aff3e5f5ddc6ed5d832dda1e952187c002ca1a5cdd827022efe591b6ac44cada884ea
+  languageName: node
+  linkType: hard
+
+"@babel/helper-annotate-as-pure@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-annotate-as-pure@npm:7.25.9"
+  dependencies:
+    "@babel/types": ^7.25.9
+  checksum: 41edda10df1ae106a9b4fe617bf7c6df77db992992afd46192534f5cff29f9e49a303231733782dd65c5f9409714a529f215325569f14282046e9d3b7a1ffb6c
+  languageName: node
+  linkType: hard
+
+"@babel/helper-compilation-targets@npm:^7.22.6, @babel/helper-compilation-targets@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-compilation-targets@npm:7.25.9"
+  dependencies:
+    "@babel/compat-data": ^7.25.9
+    "@babel/helper-validator-option": ^7.25.9
+    browserslist: ^4.24.0
+    lru-cache: ^5.1.1
+    semver: ^6.3.1
+  checksum: 3af536e2db358b38f968abdf7d512d425d1018fef2f485d6f131a57a7bcaed32c606b4e148bb230e1508fa42b5b2ac281855a68eb78270f54698c48a83201b9b
+  languageName: node
+  linkType: hard
+
+"@babel/helper-create-class-features-plugin@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-create-class-features-plugin@npm:7.25.9"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.25.9
+    "@babel/helper-member-expression-to-functions": ^7.25.9
+    "@babel/helper-optimise-call-expression": ^7.25.9
+    "@babel/helper-replace-supers": ^7.25.9
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.25.9
+    "@babel/traverse": ^7.25.9
+    semver: ^6.3.1
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 91dd5f203ed04568c70b052e2f26dfaac7c146447196c00b8ecbb6d3d2f3b517abadb985d3321a19d143adaed6fe17f7f79f8f50e0c20e9d8ad83e1027b42424
+  languageName: node
+  linkType: hard
+
+"@babel/helper-create-regexp-features-plugin@npm:^7.18.6, @babel/helper-create-regexp-features-plugin@npm:^7.25.9":
+  version: 7.26.3
+  resolution: "@babel/helper-create-regexp-features-plugin@npm:7.26.3"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.25.9
+    regexpu-core: ^6.2.0
+    semver: ^6.3.1
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 50a27d8ce6da5c2fa0c62c132c4d27cfeb36e3233ff1e5220d643de3dafe49423b507382f0b72a696fce7486014b134c1e742f55438590f9405d26765b009af0
+  languageName: node
+  linkType: hard
+
+"@babel/helper-define-polyfill-provider@npm:^0.6.2, @babel/helper-define-polyfill-provider@npm:^0.6.3":
+  version: 0.6.3
+  resolution: "@babel/helper-define-polyfill-provider@npm:0.6.3"
+  dependencies:
+    "@babel/helper-compilation-targets": ^7.22.6
+    "@babel/helper-plugin-utils": ^7.22.5
+    debug: ^4.1.1
+    lodash.debounce: ^4.0.8
+    resolve: ^1.14.2
+  peerDependencies:
+    "@babel/core": ^7.4.0 || ^8.0.0-0 <8.0.0
+  checksum: 710e6d8a5391736b9f53f09d0494575c2e03de199ad8d1349bc8e514cb85251ea1f1842c2ff44830849d482052ddb42ae931101002a87a263b12f649c2e57c01
+  languageName: node
+  linkType: hard
+
+"@babel/helper-member-expression-to-functions@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-member-expression-to-functions@npm:7.25.9"
+  dependencies:
+    "@babel/traverse": ^7.25.9
+    "@babel/types": ^7.25.9
+  checksum: 8e2f1979b6d596ac2a8cbf17f2cf709180fefc274ac3331408b48203fe19134ed87800774ef18838d0275c3965130bae22980d90caed756b7493631d4b2cf961
+  languageName: node
+  linkType: hard
+
+"@babel/helper-module-imports@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-module-imports@npm:7.25.9"
+  dependencies:
+    "@babel/traverse": ^7.25.9
+    "@babel/types": ^7.25.9
+  checksum: 1b411ce4ca825422ef7065dffae7d8acef52023e51ad096351e3e2c05837e9bf9fca2af9ca7f28dc26d596a588863d0fedd40711a88e350b736c619a80e704e6
+  languageName: node
+  linkType: hard
+
+"@babel/helper-module-transforms@npm:^7.25.9, @babel/helper-module-transforms@npm:^7.26.0":
+  version: 7.26.0
+  resolution: "@babel/helper-module-transforms@npm:7.26.0"
+  dependencies:
+    "@babel/helper-module-imports": ^7.25.9
+    "@babel/helper-validator-identifier": ^7.25.9
+    "@babel/traverse": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 942eee3adf2b387443c247a2c190c17c4fd45ba92a23087abab4c804f40541790d51ad5277e4b5b1ed8d5ba5b62de73857446b7742f835c18ebd350384e63917
+  languageName: node
+  linkType: hard
+
+"@babel/helper-optimise-call-expression@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-optimise-call-expression@npm:7.25.9"
+  dependencies:
+    "@babel/types": ^7.25.9
+  checksum: f09d0ad60c0715b9a60c31841b3246b47d67650c512ce85bbe24a3124f1a4d66377df793af393273bc6e1015b0a9c799626c48e53747581c1582b99167cc65dc
+  languageName: node
+  linkType: hard
+
+"@babel/helper-plugin-utils@npm:^7.0.0, @babel/helper-plugin-utils@npm:^7.10.4, @babel/helper-plugin-utils@npm:^7.12.13, @babel/helper-plugin-utils@npm:^7.14.5, @babel/helper-plugin-utils@npm:^7.18.6, @babel/helper-plugin-utils@npm:^7.22.5, @babel/helper-plugin-utils@npm:^7.25.9, @babel/helper-plugin-utils@npm:^7.8.0":
+  version: 7.25.9
+  resolution: "@babel/helper-plugin-utils@npm:7.25.9"
+  checksum: e19ec8acf0b696756e6d84531f532c5fe508dce57aa68c75572a77798bd04587a844a9a6c8ea7d62d673e21fdc174d091c9097fb29aea1c1b49f9c6eaa80f022
+  languageName: node
+  linkType: hard
+
+"@babel/helper-remap-async-to-generator@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-remap-async-to-generator@npm:7.25.9"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.25.9
+    "@babel/helper-wrap-function": ^7.25.9
+    "@babel/traverse": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: ea37ad9f8f7bcc27c109963b8ebb9d22bac7a5db2a51de199cb560e251d5593fe721e46aab2ca7d3e7a24b0aa4aff0eaf9c7307af9c2fd3a1d84268579073052
+  languageName: node
+  linkType: hard
+
+"@babel/helper-replace-supers@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-replace-supers@npm:7.25.9"
+  dependencies:
+    "@babel/helper-member-expression-to-functions": ^7.25.9
+    "@babel/helper-optimise-call-expression": ^7.25.9
+    "@babel/traverse": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 84f40e12520b7023e52d289bf9d569a06284879fe23bbbacad86bec5d978b2669769f11b073fcfeb1567d8c547168323005fda88607a4681ecaeb4a5cdd48bb9
+  languageName: node
+  linkType: hard
+
+"@babel/helper-skip-transparent-expression-wrappers@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-skip-transparent-expression-wrappers@npm:7.25.9"
+  dependencies:
+    "@babel/traverse": ^7.25.9
+    "@babel/types": ^7.25.9
+  checksum: fdbb5248932198bc26daa6abf0d2ac42cab9c2dbb75b7e9f40d425c8f28f09620b886d40e7f9e4e08ffc7aaa2cefe6fc2c44be7c20e81f7526634702fb615bdc
+  languageName: node
+  linkType: hard
+
+"@babel/helper-string-parser@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-string-parser@npm:7.25.9"
+  checksum: 6435ee0849e101681c1849868278b5aee82686ba2c1e27280e5e8aca6233af6810d39f8e4e693d2f2a44a3728a6ccfd66f72d71826a94105b86b731697cdfa99
+  languageName: node
+  linkType: hard
+
+"@babel/helper-validator-identifier@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-validator-identifier@npm:7.25.9"
+  checksum: 5b85918cb1a92a7f3f508ea02699e8d2422fe17ea8e82acd445006c0ef7520fbf48e3dbcdaf7b0a1d571fc3a2715a29719e5226636cb6042e15fe6ed2a590944
+  languageName: node
+  linkType: hard
+
+"@babel/helper-validator-option@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-validator-option@npm:7.25.9"
+  checksum: 9491b2755948ebbdd68f87da907283698e663b5af2d2b1b02a2765761974b1120d5d8d49e9175b167f16f72748ffceec8c9cf62acfbee73f4904507b246e2b3d
+  languageName: node
+  linkType: hard
+
+"@babel/helper-wrap-function@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-wrap-function@npm:7.25.9"
+  dependencies:
+    "@babel/template": ^7.25.9
+    "@babel/traverse": ^7.25.9
+    "@babel/types": ^7.25.9
+  checksum: 8ec1701e60ae004415800c4a7a188f5564c73b4e4f3fdf58dd3f34a3feaa9753173f39bbd6d02e7ecc974f48155efc7940e62584435b3092c07728ee46a604ea
+  languageName: node
+  linkType: hard
+
+"@babel/helpers@npm:^7.26.0":
+  version: 7.26.0
+  resolution: "@babel/helpers@npm:7.26.0"
+  dependencies:
+    "@babel/template": ^7.25.9
+    "@babel/types": ^7.26.0
+  checksum: d77fe8d45033d6007eadfa440355c1355eed57902d5a302f450827ad3d530343430a21210584d32eef2f216ae463d4591184c6fc60cf205bbf3a884561469200
+  languageName: node
+  linkType: hard
+
+"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.14.7, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.23.9, @babel/parser@npm:^7.25.9, @babel/parser@npm:^7.26.0, @babel/parser@npm:^7.26.3":
+  version: 7.26.3
+  resolution: "@babel/parser@npm:7.26.3"
+  dependencies:
+    "@babel/types": ^7.26.3
+  bin:
+    parser: ./bin/babel-parser.js
+  checksum: e2bff2e9fa6540ee18fecc058bc74837eda2ddcecbe13454667314a93fc0ba26c1fb862c812d84f6d5f225c3bd8d191c3a42d4296e287a882c4e1f82ff2815ff
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-bugfix-firefox-class-in-computed-class-key@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-bugfix-firefox-class-in-computed-class-key@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/traverse": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: b33d37dacf98a9c74f53959999adc37a258057668b62dba557e6865689433c53764673109eaba9102bf73b2ac4db162f0d9b89a6cca6f1b71d12f5908ec11da9
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-bugfix-safari-class-field-initializer-scope@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-bugfix-safari-class-field-initializer-scope@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: d3e14ab1cb9cb50246d20cab9539f2fbd1e7ef1ded73980c8ad7c0561b4d5e0b144d362225f0976d47898e04cbd40f2000e208b0913bd788346cf7791b96af91
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: a9d1ee3fd100d3eb6799a2f2bbd785296f356c531d75c9369f71541811fa324270258a374db103ce159156d006da2f33370330558d0133e6f7584152c34997ca
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.25.9
+    "@babel/plugin-transform-optional-chaining": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.13.0
+  checksum: 5b298b28e156f64de51cdb03a2c5b80c7f978815ef1026f3ae8b9fc48d28bf0a83817d8fbecb61ef8fb94a7201f62cca5103cc6e7b9e8f28e38f766d7905b378
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/traverse": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: c684593952ab1b40dfa4e64e98a07e7227c6db175c21bd0e6d71d2ad5d240fef4e4a984d56f05a494876542a022244fe1c1098f4116109fd90d06615e8a269b1
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-proposal-private-property-in-object@npm:7.21.0-placeholder-for-preset-env.2":
+  version: 7.21.0-placeholder-for-preset-env.2
+  resolution: "@babel/plugin-proposal-private-property-in-object@npm:7.21.0-placeholder-for-preset-env.2"
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: d97745d098b835d55033ff3a7fb2b895b9c5295b08a5759e4f20df325aa385a3e0bc9bd5ad8f2ec554a44d4e6525acfc257b8c5848a1345cb40f26a30e277e91
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-async-generators@npm:^7.8.4":
+  version: 7.8.4
+  resolution: "@babel/plugin-syntax-async-generators@npm:7.8.4"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.8.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 7ed1c1d9b9e5b64ef028ea5e755c0be2d4e5e4e3d6cf7df757b9a8c4cfa4193d268176d0f1f7fbecdda6fe722885c7fda681f480f3741d8a2d26854736f05367
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-bigint@npm:^7.8.3":
+  version: 7.8.3
+  resolution: "@babel/plugin-syntax-bigint@npm:7.8.3"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.8.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3a10849d83e47aec50f367a9e56a6b22d662ddce643334b087f9828f4c3dd73bdc5909aaeabe123fed78515767f9ca43498a0e621c438d1cd2802d7fae3c9648
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-class-properties@npm:^7.12.13":
+  version: 7.12.13
+  resolution: "@babel/plugin-syntax-class-properties@npm:7.12.13"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.12.13
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 24f34b196d6342f28d4bad303612d7ff566ab0a013ce89e775d98d6f832969462e7235f3e7eaf17678a533d4be0ba45d3ae34ab4e5a9dcbda5d98d49e5efa2fc
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-class-static-block@npm:^7.14.5":
+  version: 7.14.5
+  resolution: "@babel/plugin-syntax-class-static-block@npm:7.14.5"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.14.5
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3e80814b5b6d4fe17826093918680a351c2d34398a914ce6e55d8083d72a9bdde4fbaf6a2dcea0e23a03de26dc2917ae3efd603d27099e2b98380345703bf948
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-import-assertions@npm:^7.26.0":
+  version: 7.26.0
+  resolution: "@babel/plugin-syntax-import-assertions@npm:7.26.0"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: b58f2306df4a690ca90b763d832ec05202c50af787158ff8b50cdf3354359710bce2e1eb2b5135fcabf284756ac8eadf09ca74764aa7e76d12a5cac5f6b21e67
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-import-attributes@npm:^7.24.7, @babel/plugin-syntax-import-attributes@npm:^7.26.0":
+  version: 7.26.0
+  resolution: "@babel/plugin-syntax-import-attributes@npm:7.26.0"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: c122aa577166c80ee67f75aebebeef4150a132c4d3109d25d7fc058bf802946f883e330f20b78c1d3e3a5ada631c8780c263d2d01b5dbaecc69efefeedd42916
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-import-meta@npm:^7.10.4":
+  version: 7.10.4
+  resolution: "@babel/plugin-syntax-import-meta@npm:7.10.4"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.10.4
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 166ac1125d10b9c0c430e4156249a13858c0366d38844883d75d27389621ebe651115cb2ceb6dc011534d5055719fa1727b59f39e1ab3ca97820eef3dcab5b9b
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-json-strings@npm:^7.8.3":
+  version: 7.8.3
+  resolution: "@babel/plugin-syntax-json-strings@npm:7.8.3"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.8.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: bf5aea1f3188c9a507e16efe030efb996853ca3cadd6512c51db7233cc58f3ac89ff8c6bdfb01d30843b161cfe7d321e1bf28da82f7ab8d7e6bc5464666f354a
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-jsx@npm:^7.7.2":
+  version: 7.25.9
+  resolution: "@babel/plugin-syntax-jsx@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: bb609d1ffb50b58f0c1bac8810d0e46a4f6c922aa171c458f3a19d66ee545d36e782d3bffbbc1fed0dc65a558bdce1caf5279316583c0fff5a2c1658982a8563
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-logical-assignment-operators@npm:^7.10.4":
+  version: 7.10.4
+  resolution: "@babel/plugin-syntax-logical-assignment-operators@npm:7.10.4"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.10.4
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: aff33577037e34e515911255cdbb1fd39efee33658aa00b8a5fd3a4b903585112d037cce1cc9e4632f0487dc554486106b79ccd5ea63a2e00df4363f6d4ff886
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-nullish-coalescing-operator@npm:^7.8.3":
+  version: 7.8.3
+  resolution: "@babel/plugin-syntax-nullish-coalescing-operator@npm:7.8.3"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.8.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 87aca4918916020d1fedba54c0e232de408df2644a425d153be368313fdde40d96088feed6c4e5ab72aac89be5d07fef2ddf329a15109c5eb65df006bf2580d1
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-numeric-separator@npm:^7.10.4":
+  version: 7.10.4
+  resolution: "@babel/plugin-syntax-numeric-separator@npm:7.10.4"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.10.4
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 01ec5547bd0497f76cc903ff4d6b02abc8c05f301c88d2622b6d834e33a5651aa7c7a3d80d8d57656a4588f7276eba357f6b7e006482f5b564b7a6488de493a1
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-object-rest-spread@npm:^7.8.3":
+  version: 7.8.3
+  resolution: "@babel/plugin-syntax-object-rest-spread@npm:7.8.3"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.8.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: fddcf581a57f77e80eb6b981b10658421bc321ba5f0a5b754118c6a92a5448f12a0c336f77b8abf734841e102e5126d69110a306eadb03ca3e1547cab31f5cbf
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-optional-catch-binding@npm:^7.8.3":
+  version: 7.8.3
+  resolution: "@babel/plugin-syntax-optional-catch-binding@npm:7.8.3"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.8.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 910d90e72bc90ea1ce698e89c1027fed8845212d5ab588e35ef91f13b93143845f94e2539d831dc8d8ededc14ec02f04f7bd6a8179edd43a326c784e7ed7f0b9
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-optional-chaining@npm:^7.8.3":
+  version: 7.8.3
+  resolution: "@babel/plugin-syntax-optional-chaining@npm:7.8.3"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.8.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: eef94d53a1453361553c1f98b68d17782861a04a392840341bc91780838dd4e695209c783631cf0de14c635758beafb6a3a65399846ffa4386bff90639347f30
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-private-property-in-object@npm:^7.14.5":
+  version: 7.14.5
+  resolution: "@babel/plugin-syntax-private-property-in-object@npm:7.14.5"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.14.5
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: b317174783e6e96029b743ccff2a67d63d38756876e7e5d0ba53a322e38d9ca452c13354a57de1ad476b4c066dbae699e0ca157441da611117a47af88985ecda
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-top-level-await@npm:^7.14.5":
+  version: 7.14.5
+  resolution: "@babel/plugin-syntax-top-level-await@npm:7.14.5"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.14.5
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: bbd1a56b095be7820029b209677b194db9b1d26691fe999856462e66b25b281f031f3dfd91b1619e9dcf95bebe336211833b854d0fb8780d618e35667c2d0d7e
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-typescript@npm:^7.7.2":
+  version: 7.25.9
+  resolution: "@babel/plugin-syntax-typescript@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 0e9821e8ba7d660c36c919654e4144a70546942ae184e85b8102f2322451eae102cbfadbcadd52ce077a2b44b400ee52394c616feab7b5b9f791b910e933fd33
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-syntax-unicode-sets-regex@npm:^7.18.6":
+  version: 7.18.6
+  resolution: "@babel/plugin-syntax-unicode-sets-regex@npm:7.18.6"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.18.6
+    "@babel/helper-plugin-utils": ^7.18.6
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: a651d700fe63ff0ddfd7186f4ebc24447ca734f114433139e3c027bc94a900d013cf1ef2e2db8430425ba542e39ae160c3b05f06b59fd4656273a3df97679e9c
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-arrow-functions@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-arrow-functions@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: c29f081224859483accf55fb4d091db2aac0dcd0d7954bac5ca889030cc498d3f771aa20eb2e9cd8310084ec394d85fa084b97faf09298b6bc9541182b3eb5bb
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-async-generator-functions@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-async-generator-functions@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/helper-remap-async-to-generator": ^7.25.9
+    "@babel/traverse": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 41e02c18c2a57de9f274fa2c5a1bf81a20ab5f321db29cc3051512b9c5bdf3f1a8c42f1fc282cb62343c6d50849f992eede954d5f7fb5e7df48ae0c59ea7e054
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-async-to-generator@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-async-to-generator@npm:7.25.9"
+  dependencies:
+    "@babel/helper-module-imports": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/helper-remap-async-to-generator": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: b3ad50fb93c171644d501864620ed23952a46648c4df10dc9c62cc9ad08031b66bd272cfdd708faeee07c23b6251b16f29ce0350473e4c79f0c32178d38ce3a6
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-block-scoped-functions@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-block-scoped-functions@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: bf31896556b33a80f017af3d445ceb532ec0f5ca9d69bc211a963ac92514d172d5c24c5ac319f384d9dfa7f1a4d8dc23032c2fe3e74f98a59467ecd86f7033ae
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-block-scoping@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-block-scoping@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: e869500cfb1995e06e64c9608543b56468639809febfcdd6fcf683bc0bf1be2431cacf2981a168a1a14f4766393e37bc9f7c96d25bc5b5f39a64a8a8ad0bf8e0
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-class-properties@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-class-properties@npm:7.25.9"
+  dependencies:
+    "@babel/helper-create-class-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: a8d69e2c285486b63f49193cbcf7a15e1d3a5f632c1c07d7a97f65306df7f554b30270b7378dde143f8b557d1f8f6336c643377943dec8ec405e4cd11e90b9ea
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-class-static-block@npm:^7.26.0":
+  version: 7.26.0
+  resolution: "@babel/plugin-transform-class-static-block@npm:7.26.0"
+  dependencies:
+    "@babel/helper-create-class-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.12.0
+  checksum: d779d4d3a6f8d363f67fcbd928c15baa72be8d3b86c6d05e0300b50e66e2c4be9e99398b803d13064bc79d90ae36e37a505e3dc8af11904459804dec07660246
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-classes@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-classes@npm:7.25.9"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.25.9
+    "@babel/helper-compilation-targets": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/helper-replace-supers": ^7.25.9
+    "@babel/traverse": ^7.25.9
+    globals: ^11.1.0
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: d12584f72125314cc0fa8c77586ece2888d677788ac75f7393f5da574dfe4e45a556f7e3488fab29c8777ab3e5856d7a2d79f6df02834083aaa9d766440e3c68
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-computed-properties@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-computed-properties@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/template": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: f77fa4bc0c1e0031068172df28852388db6b0f91c268d037905f459607cf1e8ebab00015f9f179f4ad96e11c5f381b635cd5dc4e147a48c7ac79d195ae7542de
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-destructuring@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-destructuring@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 965f63077a904828f4adee91393f83644098533442b8217d5a135c23a759a4c252c714074c965676a60d2c33f610f579a4eeb59ffd783724393af61c0ca45fef
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-dotall-regex@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-dotall-regex@npm:7.25.9"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 8bdf1bb9e6e3a2cc8154ae88a3872faa6dc346d6901994505fb43ac85f858728781f1219f40b67f7bb0687c507450236cb7838ac68d457e65637f98500aa161b
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-duplicate-keys@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-duplicate-keys@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: b553eebc328797ead6be5ba5bdaf2f1222cea8a5bd33fb4ed625975d4f9b510bfb0d688d97e314cd4b4a48b279bea7b3634ad68c1b41ee143c3082db0ae74037
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-duplicate-named-capturing-groups-regex@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-duplicate-named-capturing-groups-regex@npm:7.25.9"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: f7233cf596be8c6843d31951afaf2464a62a610cb89c72c818c044765827fab78403ab8a7d3a6386f838c8df574668e2a48f6c206b1d7da965aff9c6886cb8e6
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-dynamic-import@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-dynamic-import@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: aaca1ccda819be9b2b85af47ba08ddd2210ff2dbea222f26e4cd33f97ab020884bf81a66197e50872721e9daf36ceb5659502c82199884ea74d5d75ecda5c58b
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-exponentiation-operator@npm:^7.25.9":
+  version: 7.26.3
+  resolution: "@babel/plugin-transform-exponentiation-operator@npm:7.26.3"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: b369ffad07e02e259c43a09d309a5ca86cb9da6b43b1df6256463a810b172cedc4254742605eec0fc2418371c3f7430430f5abd36f21717281e79142308c13ba
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-export-namespace-from@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-export-namespace-from@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 4dfe8df86c5b1d085d591290874bb2d78a9063090d71567ed657a418010ad333c3f48af2c974b865f53bbb718987a065f89828d43279a7751db1a56c9229078d
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-for-of@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-for-of@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 41b56e70256a29fc26ed7fb95ece062d7ec2f3b6ea8f0686349ffd004cd4816132085ee21165b89c502ee7161cb7cfb12510961638851357945dc7bc546475b7
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-function-name@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-function-name@npm:7.25.9"
+  dependencies:
+    "@babel/helper-compilation-targets": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/traverse": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: a8d7c8d019a6eb57eab5ca1be3e3236f175557d55b1f3b11f8ad7999e3fbb1cf37905fd8cb3a349bffb4163a558e9f33b63f631597fdc97c858757deac1b2fd7
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-json-strings@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-json-strings@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: e2498d84761cfd05aaea53799933d55af309c9d6204e66b38778792d171e4d1311ad34f334259a3aa3407dd0446f6bd3e390a1fcb8ce2e42fe5aabed0e41bee1
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-literals@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-literals@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3cca75823a38aab599bc151b0fa4d816b5e1b62d6e49c156aa90436deb6e13649f5505973151a10418b64f3f9d1c3da53e38a186402e0ed7ad98e482e70c0c14
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-logical-assignment-operators@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-logical-assignment-operators@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 8c6febb4ac53852314d28b5e2c23d5dbbff7bf1e57d61f9672e0d97531ef7778b3f0ad698dcf1179f5486e626c77127508916a65eb846a89e98a92f70ed3537b
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-member-expression-literals@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-member-expression-literals@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: db92041ae87b8f59f98b50359e0bb172480f6ba22e5e76b13bdfe07122cbf0daa9cd8ad2e78dcb47939938fed88ad57ab5989346f64b3a16953fc73dea3a9b1f
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-modules-amd@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-modules-amd@npm:7.25.9"
+  dependencies:
+    "@babel/helper-module-transforms": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: baad1f6fd0e0d38e9a9c1086a06abdc014c4c653fd452337cadfe23fb5bd8bf4368d1bc433a5ac8e6421bc0732ebb7c044cf3fb39c1b7ebe967d66e26c4e5cec
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-modules-commonjs@npm:^7.25.9":
+  version: 7.26.3
+  resolution: "@babel/plugin-transform-modules-commonjs@npm:7.26.3"
+  dependencies:
+    "@babel/helper-module-transforms": ^7.26.0
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 0ac9aa4e5fe9fe34b58ee174881631e5e1c89eee5b1ebfd1147934686be92fc5fbfdc11119f0b607b3743d36a1cbcb7c36f18e0dd4424d6d7b749b1b9a18808a
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-modules-systemjs@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-modules-systemjs@npm:7.25.9"
+  dependencies:
+    "@babel/helper-module-transforms": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/helper-validator-identifier": ^7.25.9
+    "@babel/traverse": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: bf446202f372ba92dc0db32b24b56225b6e3ad3b227e31074de8b86fdec01c273ae2536873e38dbe3ceb1cd0894209343adeaa37df208e3fa88c0c7dffec7924
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-modules-umd@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-modules-umd@npm:7.25.9"
+  dependencies:
+    "@babel/helper-module-transforms": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 946db66be5f04ab9ee56c424b00257276ec094aa2f148508927e6085239f76b00304fa1e33026d29eccdbe312efea15ca3d92e74a12689d7f0cdd9a7ba1a6c54
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-named-capturing-groups-regex@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-named-capturing-groups-regex@npm:7.25.9"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 434346ba05cf74e3f4704b3bdd439287b95cd2a8676afcdc607810b8c38b6f4798cd69c1419726b2e4c7204e62e4a04d31b0360e91ca57a930521c9211e07789
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-new-target@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-new-target@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: f8113539919aafce52f07b2bd182c771a476fe1d5d96d813460b33a16f173f038929369c595572cadc1f7bd8cb816ce89439d056e007770ddd7b7a0878e7895f
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-nullish-coalescing-operator@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-nullish-coalescing-operator@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 26e03b1c2c0408cc300e46d8f8cb639653ff3a7b03456d0d8afbb53c44f33a89323f51d99991dade3a5676921119bbdf869728bb7911799b5ef99ffafa2cdd24
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-numeric-separator@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-numeric-separator@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 0528ef041ed88e8c3f51624ee87b8182a7f246fe4013f0572788e0727d20795b558f2b82e3989b5dd416cbd339500f0d88857de41b6d3b6fdacb1d5344bcc5b1
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-object-rest-spread@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-object-rest-spread@npm:7.25.9"
+  dependencies:
+    "@babel/helper-compilation-targets": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/plugin-transform-parameters": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: a8ff73e1c46a03056b3a2236bafd6b3a4b83da93afe7ee24a50d0a8088150bf85bc5e5977daa04e66ff5fb7613d02d63ad49b91ebb64cf3f3022598d722e3a7a
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-object-super@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-object-super@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/helper-replace-supers": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 1817b5d8b80e451ae1ad9080cca884f4f16df75880a158947df76a2ed8ab404d567a7dce71dd8051ef95f90fbe3513154086a32aba55cc76027f6cbabfbd7f98
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-optional-catch-binding@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-optional-catch-binding@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: b46a8d1e91829f3db5c252583eb00d05a779b4660abeea5500fda0f8ffa3584fd18299443c22f7fddf0ed9dfdb73c782c43b445dc468d4f89803f2356963b406
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-optional-chaining@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-optional-chaining@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: f1642a7094456067e82b176e1e9fd426fda7ed9df54cb6d10109fc512b622bf4b3c83acc5875125732b8622565107fdbe2d60fe3ec8685e1d1c22c38c1b57782
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-parameters@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-parameters@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: d7ba2a7d05edbc85aed741289b0ff3d6289a1c25d82ac4be32c565f88a66391f46631aad59ceeed40824037f7eeaa7a0de1998db491f50e65a565cd964f78786
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-private-methods@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-private-methods@npm:7.25.9"
+  dependencies:
+    "@babel/helper-create-class-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 6e3671b352c267847c53a170a1937210fa8151764d70d25005e711ef9b21969aaf422acc14f9f7fb86bc0e4ec43e7aefcc0ad9196ae02d262ec10f509f126a58
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-private-property-in-object@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-private-property-in-object@npm:7.25.9"
+  dependencies:
+    "@babel/helper-annotate-as-pure": ^7.25.9
+    "@babel/helper-create-class-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 9ce3e983fea9b9ba677c192aa065c0b42ebdc7774be4c02135df09029ad92a55c35b004650c75952cb64d650872ed18f13ab64422c6fc891d06333762caa8a0a
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-property-literals@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-property-literals@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 436046ab07d54a9b44a384eeffec701d4e959a37a7547dda72e069e751ca7ff753d1782a8339e354b97c78a868b49ea97bf41bf5a44c6d7a3c0a05ad40eeb49c
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-regenerator@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-regenerator@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+    regenerator-transform: ^0.15.2
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 1c09e8087b476c5967282c9790fb8710e065eda77c60f6cb5da541edd59ded9d003d96f8ef640928faab4a0b35bf997673499a194973da4f0c97f0935807a482
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-regexp-modifiers@npm:^7.26.0":
+  version: 7.26.0
+  resolution: "@babel/plugin-transform-regexp-modifiers@npm:7.26.0"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 726deca486bbd4b176f8a966eb0f4aabc19d9def3b8dabb8b3a656778eca0df1fda3f3c92b213aa5a184232fdafd5b7bd73b4e24ca4345c498ef6baff2bda4e1
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-reserved-words@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-reserved-words@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 8beda04481b25767acbd1f6b9ef7b3a9c12fbd9dcb24df45a6ad120e1dc4b247c073db60ac742f9093657d6d8c050501fc0606af042f81a3bb6a3ff862cddc47
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-shorthand-properties@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-shorthand-properties@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: f774995d58d4e3a992b732cf3a9b8823552d471040e280264dd15e0735433d51b468fef04d75853d061309389c66bda10ce1b298297ce83999220eb0ad62741d
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-spread@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-spread@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/helper-skip-transparent-expression-wrappers": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 2403a5d49171b7714d5e5ecb1f598c61575a4dbe5e33e5a5f08c0ea990b75e693ca1ea983b6a96b2e3e5e7da48c8238333f525e47498c53b577c5d094d964c06
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-sticky-regex@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-sticky-regex@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 7454b00844dbe924030dd15e2b3615b36e196500c4c47e98dabc6b37a054c5b1038ecd437e910aabf0e43bf56b973cb148d3437d50f6e2332d8309568e3e979b
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-template-literals@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-template-literals@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 92eb1d6e2d95bd24abbb74fa7640d02b66ff6214e0bb616d7fda298a7821ce15132a4265d576a3502a347a3c9e94b6c69ed265bb0784664592fa076785a3d16a
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-typeof-symbol@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-typeof-symbol@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 3f9458840d96f61502f0e9dfaae3efe8325fa0b2151e24ea0d41307f28cdd166905419f5a43447ce0f1ae4bfd001f3906b658839a60269c254168164090b4c73
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-unicode-escapes@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-unicode-escapes@npm:7.25.9"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: be067e07488d804e3e82d7771f23666539d2ae5af03bf6eb8480406adf3dabd776e60c1fd5c6078dc5714b73cd80bbaca70e71d4f5d154c5c57200581602ca2f
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-unicode-property-regex@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-unicode-property-regex@npm:7.25.9"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 201f6f46c1beb399e79aa208b94c5d54412047511795ce1e790edcd189cef73752e6a099fdfc01b3ad12205f139ae344143b62f21f44bbe02338a95e8506a911
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-unicode-regex@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-unicode-regex@npm:7.25.9"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: e8baae867526e179467c6ef5280d70390fa7388f8763a19a27c21302dd59b121032568be080749514b097097ceb9af716bf4b90638f1b3cf689aa837ba20150f
+  languageName: node
+  linkType: hard
+
+"@babel/plugin-transform-unicode-sets-regex@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-transform-unicode-sets-regex@npm:7.25.9"
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 4445ef20de687cb4dcc95169742a8d9013d680aa5eee9186d8e25875bbfa7ee5e2de26a91177ccf70b1db518e36886abcd44750d28db5d7a9539f0efa6839f4b
+  languageName: node
+  linkType: hard
+
+"@babel/preset-env@npm:^7.23.8":
+  version: 7.26.0
+  resolution: "@babel/preset-env@npm:7.26.0"
+  dependencies:
+    "@babel/compat-data": ^7.26.0
+    "@babel/helper-compilation-targets": ^7.25.9
+    "@babel/helper-plugin-utils": ^7.25.9
+    "@babel/helper-validator-option": ^7.25.9
+    "@babel/plugin-bugfix-firefox-class-in-computed-class-key": ^7.25.9
+    "@babel/plugin-bugfix-safari-class-field-initializer-scope": ^7.25.9
+    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": ^7.25.9
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": ^7.25.9
+    "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": ^7.25.9
+    "@babel/plugin-proposal-private-property-in-object": 7.21.0-placeholder-for-preset-env.2
+    "@babel/plugin-syntax-import-assertions": ^7.26.0
+    "@babel/plugin-syntax-import-attributes": ^7.26.0
+    "@babel/plugin-syntax-unicode-sets-regex": ^7.18.6
+    "@babel/plugin-transform-arrow-functions": ^7.25.9
+    "@babel/plugin-transform-async-generator-functions": ^7.25.9
+    "@babel/plugin-transform-async-to-generator": ^7.25.9
+    "@babel/plugin-transform-block-scoped-functions": ^7.25.9
+    "@babel/plugin-transform-block-scoping": ^7.25.9
+    "@babel/plugin-transform-class-properties": ^7.25.9
+    "@babel/plugin-transform-class-static-block": ^7.26.0
+    "@babel/plugin-transform-classes": ^7.25.9
+    "@babel/plugin-transform-computed-properties": ^7.25.9
+    "@babel/plugin-transform-destructuring": ^7.25.9
+    "@babel/plugin-transform-dotall-regex": ^7.25.9
+    "@babel/plugin-transform-duplicate-keys": ^7.25.9
+    "@babel/plugin-transform-duplicate-named-capturing-groups-regex": ^7.25.9
+    "@babel/plugin-transform-dynamic-import": ^7.25.9
+    "@babel/plugin-transform-exponentiation-operator": ^7.25.9
+    "@babel/plugin-transform-export-namespace-from": ^7.25.9
+    "@babel/plugin-transform-for-of": ^7.25.9
+    "@babel/plugin-transform-function-name": ^7.25.9
+    "@babel/plugin-transform-json-strings": ^7.25.9
+    "@babel/plugin-transform-literals": ^7.25.9
+    "@babel/plugin-transform-logical-assignment-operators": ^7.25.9
+    "@babel/plugin-transform-member-expression-literals": ^7.25.9
+    "@babel/plugin-transform-modules-amd": ^7.25.9
+    "@babel/plugin-transform-modules-commonjs": ^7.25.9
+    "@babel/plugin-transform-modules-systemjs": ^7.25.9
+    "@babel/plugin-transform-modules-umd": ^7.25.9
+    "@babel/plugin-transform-named-capturing-groups-regex": ^7.25.9
+    "@babel/plugin-transform-new-target": ^7.25.9
+    "@babel/plugin-transform-nullish-coalescing-operator": ^7.25.9
+    "@babel/plugin-transform-numeric-separator": ^7.25.9
+    "@babel/plugin-transform-object-rest-spread": ^7.25.9
+    "@babel/plugin-transform-object-super": ^7.25.9
+    "@babel/plugin-transform-optional-catch-binding": ^7.25.9
+    "@babel/plugin-transform-optional-chaining": ^7.25.9
+    "@babel/plugin-transform-parameters": ^7.25.9
+    "@babel/plugin-transform-private-methods": ^7.25.9
+    "@babel/plugin-transform-private-property-in-object": ^7.25.9
+    "@babel/plugin-transform-property-literals": ^7.25.9
+    "@babel/plugin-transform-regenerator": ^7.25.9
+    "@babel/plugin-transform-regexp-modifiers": ^7.26.0
+    "@babel/plugin-transform-reserved-words": ^7.25.9
+    "@babel/plugin-transform-shorthand-properties": ^7.25.9
+    "@babel/plugin-transform-spread": ^7.25.9
+    "@babel/plugin-transform-sticky-regex": ^7.25.9
+    "@babel/plugin-transform-template-literals": ^7.25.9
+    "@babel/plugin-transform-typeof-symbol": ^7.25.9
+    "@babel/plugin-transform-unicode-escapes": ^7.25.9
+    "@babel/plugin-transform-unicode-property-regex": ^7.25.9
+    "@babel/plugin-transform-unicode-regex": ^7.25.9
+    "@babel/plugin-transform-unicode-sets-regex": ^7.25.9
+    "@babel/preset-modules": 0.1.6-no-external-plugins
+    babel-plugin-polyfill-corejs2: ^0.4.10
+    babel-plugin-polyfill-corejs3: ^0.10.6
+    babel-plugin-polyfill-regenerator: ^0.6.1
+    core-js-compat: ^3.38.1
+    semver: ^6.3.1
+  peerDependencies:
+    "@babel/core": ^7.0.0-0
+  checksum: 0c3e2b3758cc0347dcf5551b5209db702764183dce66ff20bffceff6486c090bef9175f5f7d1e68cfe5584f0d817b2aab25ab5992058a7998f061f244c8caf5f
+  languageName: node
+  linkType: hard
+
+"@babel/preset-modules@npm:0.1.6-no-external-plugins":
+  version: 0.1.6-no-external-plugins
+  resolution: "@babel/preset-modules@npm:0.1.6-no-external-plugins"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.0.0
+    "@babel/types": ^7.4.4
+    esutils: ^2.0.2
+  peerDependencies:
+    "@babel/core": ^7.0.0-0 || ^8.0.0-0 <8.0.0
+  checksum: 4855e799bc50f2449fb5210f78ea9e8fd46cf4f242243f1e2ed838e2bd702e25e73e822e7f8447722a5f4baa5e67a8f7a0e403f3e7ce04540ff743a9c411c375
+  languageName: node
+  linkType: hard
+
+"@babel/runtime@npm:^7.8.4":
+  version: 7.26.0
+  resolution: "@babel/runtime@npm:7.26.0"
+  dependencies:
+    regenerator-runtime: ^0.14.0
+  checksum: c8e2c0504ab271b3467a261a8f119bf2603eb857a0d71e37791f4e3fae00f681365073cc79f141ddaa90c6077c60ba56448004ad5429d07ac73532be9f7cf28a
+  languageName: node
+  linkType: hard
+
+"@babel/template@npm:^7.25.9, @babel/template@npm:^7.3.3":
+  version: 7.25.9
+  resolution: "@babel/template@npm:7.25.9"
+  dependencies:
+    "@babel/code-frame": ^7.25.9
+    "@babel/parser": ^7.25.9
+    "@babel/types": ^7.25.9
+  checksum: 103641fea19c7f4e82dc913aa6b6ac157112a96d7c724d513288f538b84bae04fb87b1f1e495ac1736367b1bc30e10f058b30208fb25f66038e1f1eb4e426472
+  languageName: node
+  linkType: hard
+
+"@babel/traverse@npm:^7.25.9":
+  version: 7.26.4
+  resolution: "@babel/traverse@npm:7.26.4"
+  dependencies:
+    "@babel/code-frame": ^7.26.2
+    "@babel/generator": ^7.26.3
+    "@babel/parser": ^7.26.3
+    "@babel/template": ^7.25.9
+    "@babel/types": ^7.26.3
+    debug: ^4.3.1
+    globals: ^11.1.0
+  checksum: dcdf51b27ab640291f968e4477933465c2910bfdcbcff8f5315d1f29b8ff861864f363e84a71fb489f5e9708e8b36b7540608ce019aa5e57ef7a4ba537e62700
+  languageName: node
+  linkType: hard
+
+"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.25.9, @babel/types@npm:^7.26.0, @babel/types@npm:^7.26.3, @babel/types@npm:^7.3.3, @babel/types@npm:^7.4.4":
+  version: 7.26.3
+  resolution: "@babel/types@npm:7.26.3"
+  dependencies:
+    "@babel/helper-string-parser": ^7.25.9
+    "@babel/helper-validator-identifier": ^7.25.9
+  checksum: 195f428080dcaadbcecc9445df7f91063beeaa91b49ccd78f38a5af6b75a6a58391d0c6614edb1ea322e57889a1684a0aab8e667951f820196901dd341f931e9
+  languageName: node
+  linkType: hard
+
+"@bcoe/v8-coverage@npm:^0.2.3":
+  version: 0.2.3
+  resolution: "@bcoe/v8-coverage@npm:0.2.3"
+  checksum: 850f9305536d0f2bd13e9e0881cb5f02e4f93fad1189f7b2d4bebf694e3206924eadee1068130d43c11b750efcc9405f88a8e42ef098b6d75239c0f047de1a27
+  languageName: node
+  linkType: hard
+
+"@discoveryjs/json-ext@npm:^0.5.0":
+  version: 0.5.7
+  resolution: "@discoveryjs/json-ext@npm:0.5.7"
+  checksum: 2176d301cc258ea5c2324402997cf8134ebb212469c0d397591636cea8d3c02f2b3cf9fd58dcb748c7a0dade77ebdc1b10284fa63e608c033a1db52fddc69918
+  languageName: node
+  linkType: hard
+
+"@eslint-community/eslint-utils@npm:^4.2.0, @eslint-community/eslint-utils@npm:^4.4.0":
+  version: 4.4.1
+  resolution: "@eslint-community/eslint-utils@npm:4.4.1"
+  dependencies:
+    eslint-visitor-keys: ^3.4.3
+  peerDependencies:
+    eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+  checksum: a7ffc838eb6a9ef594cda348458ccf38f34439ac77dc090fa1c120024bcd4eb911dfd74d5ef44d42063e7949fa7c5123ce714a015c4abb917d4124be1bd32bfe
+  languageName: node
+  linkType: hard
+
+"@eslint-community/regexpp@npm:^4.5.1, @eslint-community/regexpp@npm:^4.6.1":
+  version: 4.12.1
+  resolution: "@eslint-community/regexpp@npm:4.12.1"
+  checksum: 0d628680e204bc316d545b4993d3658427ca404ae646ce541fcc65306b8c712c340e5e573e30fb9f85f4855c0c5f6dca9868931f2fcced06417fbe1a0c6cd2d6
+  languageName: node
+  linkType: hard
+
+"@eslint/eslintrc@npm:^2.1.4":
+  version: 2.1.4
+  resolution: "@eslint/eslintrc@npm:2.1.4"
+  dependencies:
+    ajv: ^6.12.4
+    debug: ^4.3.2
+    espree: ^9.6.0
+    globals: ^13.19.0
+    ignore: ^5.2.0
+    import-fresh: ^3.2.1
+    js-yaml: ^4.1.0
+    minimatch: ^3.1.2
+    strip-json-comments: ^3.1.1
+  checksum: 10957c7592b20ca0089262d8c2a8accbad14b4f6507e35416c32ee6b4dbf9cad67dfb77096bbd405405e9ada2b107f3797fe94362e1c55e0b09d6e90dd149127
+  languageName: node
+  linkType: hard
+
+"@eslint/js@npm:8.57.1":
+  version: 8.57.1
+  resolution: "@eslint/js@npm:8.57.1"
+  checksum: 2afb77454c06e8316793d2e8e79a0154854d35e6782a1217da274ca60b5044d2c69d6091155234ed0551a1e408f86f09dd4ece02752c59568fa403e60611e880
+  languageName: node
+  linkType: hard
+
+"@humanwhocodes/config-array@npm:^0.13.0":
+  version: 0.13.0
+  resolution: "@humanwhocodes/config-array@npm:0.13.0"
+  dependencies:
+    "@humanwhocodes/object-schema": ^2.0.3
+    debug: ^4.3.1
+    minimatch: ^3.0.5
+  checksum: eae69ff9134025dd2924f0b430eb324981494be26f0fddd267a33c28711c4db643242cf9fddf7dadb9d16c96b54b2d2c073e60a56477df86e0173149313bd5d6
+  languageName: node
+  linkType: hard
+
+"@humanwhocodes/module-importer@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "@humanwhocodes/module-importer@npm:1.0.1"
+  checksum: 0fd22007db8034a2cdf2c764b140d37d9020bbfce8a49d3ec5c05290e77d4b0263b1b972b752df8c89e5eaa94073408f2b7d977aed131faf6cf396ebb5d7fb61
+  languageName: node
+  linkType: hard
+
+"@humanwhocodes/object-schema@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "@humanwhocodes/object-schema@npm:2.0.3"
+  checksum: d3b78f6c5831888c6ecc899df0d03bcc25d46f3ad26a11d7ea52944dc36a35ef543fad965322174238d677a43d5c694434f6607532cff7077062513ad7022631
+  languageName: node
+  linkType: hard
+
+"@isaacs/cliui@npm:^8.0.2":
+  version: 8.0.2
+  resolution: "@isaacs/cliui@npm:8.0.2"
+  dependencies:
+    string-width: ^5.1.2
+    string-width-cjs: "npm:string-width@^4.2.0"
+    strip-ansi: ^7.0.1
+    strip-ansi-cjs: "npm:strip-ansi@^6.0.1"
+    wrap-ansi: ^8.1.0
+    wrap-ansi-cjs: "npm:wrap-ansi@^7.0.0"
+  checksum: 4a473b9b32a7d4d3cfb7a614226e555091ff0c5a29a1734c28c72a182c2f6699b26fc6b5c2131dfd841e86b185aea714c72201d7c98c2fba5f17709333a67aeb
+  languageName: node
+  linkType: hard
+
+"@isaacs/fs-minipass@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "@isaacs/fs-minipass@npm:4.0.1"
+  dependencies:
+    minipass: ^7.0.4
+  checksum: 5d36d289960e886484362d9eb6a51d1ea28baed5f5d0140bbe62b99bac52eaf06cc01c2bc0d3575977962f84f6b2c4387b043ee632216643d4787b0999465bf2
+  languageName: node
+  linkType: hard
+
+"@istanbuljs/load-nyc-config@npm:^1.0.0":
+  version: 1.1.0
+  resolution: "@istanbuljs/load-nyc-config@npm:1.1.0"
+  dependencies:
+    camelcase: ^5.3.1
+    find-up: ^4.1.0
+    get-package-type: ^0.1.0
+    js-yaml: ^3.13.1
+    resolve-from: ^5.0.0
+  checksum: d578da5e2e804d5c93228450a1380e1a3c691de4953acc162f387b717258512a3e07b83510a936d9fab03eac90817473917e24f5d16297af3867f59328d58568
+  languageName: node
+  linkType: hard
+
+"@istanbuljs/schema@npm:^0.1.2, @istanbuljs/schema@npm:^0.1.3":
+  version: 0.1.3
+  resolution: "@istanbuljs/schema@npm:0.1.3"
+  checksum: 5282759d961d61350f33d9118d16bcaed914ebf8061a52f4fa474b2cb08720c9c81d165e13b82f2e5a8a212cc5af482f0c6fc1ac27b9e067e5394c9a6ed186c9
+  languageName: node
+  linkType: hard
+
+"@jest/console@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/console@npm:29.7.0"
+  dependencies:
+    "@jest/types": ^29.6.3
+    "@types/node": "*"
+    chalk: ^4.0.0
+    jest-message-util: ^29.7.0
+    jest-util: ^29.7.0
+    slash: ^3.0.0
+  checksum: 0e3624e32c5a8e7361e889db70b170876401b7d70f509a2538c31d5cd50deb0c1ae4b92dc63fe18a0902e0a48c590c21d53787a0df41a52b34fa7cab96c384d6
+  languageName: node
+  linkType: hard
+
+"@jest/core@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/core@npm:29.7.0"
+  dependencies:
+    "@jest/console": ^29.7.0
+    "@jest/reporters": ^29.7.0
+    "@jest/test-result": ^29.7.0
+    "@jest/transform": ^29.7.0
+    "@jest/types": ^29.6.3
+    "@types/node": "*"
+    ansi-escapes: ^4.2.1
+    chalk: ^4.0.0
+    ci-info: ^3.2.0
+    exit: ^0.1.2
+    graceful-fs: ^4.2.9
+    jest-changed-files: ^29.7.0
+    jest-config: ^29.7.0
+    jest-haste-map: ^29.7.0
+    jest-message-util: ^29.7.0
+    jest-regex-util: ^29.6.3
+    jest-resolve: ^29.7.0
+    jest-resolve-dependencies: ^29.7.0
+    jest-runner: ^29.7.0
+    jest-runtime: ^29.7.0
+    jest-snapshot: ^29.7.0
+    jest-util: ^29.7.0
+    jest-validate: ^29.7.0
+    jest-watcher: ^29.7.0
+    micromatch: ^4.0.4
+    pretty-format: ^29.7.0
+    slash: ^3.0.0
+    strip-ansi: ^6.0.0
+  peerDependencies:
+    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+  peerDependenciesMeta:
+    node-notifier:
+      optional: true
+  checksum: af759c9781cfc914553320446ce4e47775ae42779e73621c438feb1e4231a5d4862f84b1d8565926f2d1aab29b3ec3dcfdc84db28608bdf5f29867124ebcfc0d
+  languageName: node
+  linkType: hard
+
+"@jest/environment@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/environment@npm:29.7.0"
+  dependencies:
+    "@jest/fake-timers": ^29.7.0
+    "@jest/types": ^29.6.3
+    "@types/node": "*"
+    jest-mock: ^29.7.0
+  checksum: 6fb398143b2543d4b9b8d1c6dbce83fa5247f84f550330604be744e24c2bd2178bb893657d62d1b97cf2f24baf85c450223f8237cccb71192c36a38ea2272934
+  languageName: node
+  linkType: hard
+
+"@jest/expect-utils@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/expect-utils@npm:29.7.0"
+  dependencies:
+    jest-get-type: ^29.6.3
+  checksum: 75eb177f3d00b6331bcaa057e07c0ccb0733a1d0a1943e1d8db346779039cb7f103789f16e502f888a3096fb58c2300c38d1f3748b36a7fa762eb6f6d1b160ed
+  languageName: node
+  linkType: hard
+
+"@jest/expect@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/expect@npm:29.7.0"
+  dependencies:
+    expect: ^29.7.0
+    jest-snapshot: ^29.7.0
+  checksum: a01cb85fd9401bab3370618f4b9013b90c93536562222d920e702a0b575d239d74cecfe98010aaec7ad464f67cf534a353d92d181646a4b792acaa7e912ae55e
+  languageName: node
+  linkType: hard
+
+"@jest/fake-timers@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/fake-timers@npm:29.7.0"
+  dependencies:
+    "@jest/types": ^29.6.3
+    "@sinonjs/fake-timers": ^10.0.2
+    "@types/node": "*"
+    jest-message-util: ^29.7.0
+    jest-mock: ^29.7.0
+    jest-util: ^29.7.0
+  checksum: caf2bbd11f71c9241b458d1b5a66cbe95debc5a15d96442444b5d5c7ba774f523c76627c6931cca5e10e76f0d08761f6f1f01a608898f4751a0eee54fc3d8d00
+  languageName: node
+  linkType: hard
+
+"@jest/globals@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/globals@npm:29.7.0"
+  dependencies:
+    "@jest/environment": ^29.7.0
+    "@jest/expect": ^29.7.0
+    "@jest/types": ^29.6.3
+    jest-mock: ^29.7.0
+  checksum: 97dbb9459135693ad3a422e65ca1c250f03d82b2a77f6207e7fa0edd2c9d2015fbe4346f3dc9ebff1678b9d8da74754d4d440b7837497f8927059c0642a22123
+  languageName: node
+  linkType: hard
+
+"@jest/reporters@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/reporters@npm:29.7.0"
+  dependencies:
+    "@bcoe/v8-coverage": ^0.2.3
+    "@jest/console": ^29.7.0
+    "@jest/test-result": ^29.7.0
+    "@jest/transform": ^29.7.0
+    "@jest/types": ^29.6.3
+    "@jridgewell/trace-mapping": ^0.3.18
+    "@types/node": "*"
+    chalk: ^4.0.0
+    collect-v8-coverage: ^1.0.0
+    exit: ^0.1.2
+    glob: ^7.1.3
+    graceful-fs: ^4.2.9
+    istanbul-lib-coverage: ^3.0.0
+    istanbul-lib-instrument: ^6.0.0
+    istanbul-lib-report: ^3.0.0
+    istanbul-lib-source-maps: ^4.0.0
+    istanbul-reports: ^3.1.3
+    jest-message-util: ^29.7.0
+    jest-util: ^29.7.0
+    jest-worker: ^29.7.0
+    slash: ^3.0.0
+    string-length: ^4.0.1
+    strip-ansi: ^6.0.0
+    v8-to-istanbul: ^9.0.1
+  peerDependencies:
+    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+  peerDependenciesMeta:
+    node-notifier:
+      optional: true
+  checksum: 7eadabd62cc344f629024b8a268ecc8367dba756152b761bdcb7b7e570a3864fc51b2a9810cd310d85e0a0173ef002ba4528d5ea0329fbf66ee2a3ada9c40455
+  languageName: node
+  linkType: hard
+
+"@jest/schemas@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "@jest/schemas@npm:29.6.3"
+  dependencies:
+    "@sinclair/typebox": ^0.27.8
+  checksum: 910040425f0fc93cd13e68c750b7885590b8839066dfa0cd78e7def07bbb708ad869381f725945d66f2284de5663bbecf63e8fdd856e2ae6e261ba30b1687e93
+  languageName: node
+  linkType: hard
+
+"@jest/source-map@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "@jest/source-map@npm:29.6.3"
+  dependencies:
+    "@jridgewell/trace-mapping": ^0.3.18
+    callsites: ^3.0.0
+    graceful-fs: ^4.2.9
+  checksum: bcc5a8697d471396c0003b0bfa09722c3cd879ad697eb9c431e6164e2ea7008238a01a07193dfe3cbb48b1d258eb7251f6efcea36f64e1ebc464ea3c03ae2deb
+  languageName: node
+  linkType: hard
+
+"@jest/test-result@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/test-result@npm:29.7.0"
+  dependencies:
+    "@jest/console": ^29.7.0
+    "@jest/types": ^29.6.3
+    "@types/istanbul-lib-coverage": ^2.0.0
+    collect-v8-coverage: ^1.0.0
+  checksum: 67b6317d526e335212e5da0e768e3b8ab8a53df110361b80761353ad23b6aea4432b7c5665bdeb87658ea373b90fb1afe02ed3611ef6c858c7fba377505057fa
+  languageName: node
+  linkType: hard
+
+"@jest/test-sequencer@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/test-sequencer@npm:29.7.0"
+  dependencies:
+    "@jest/test-result": ^29.7.0
+    graceful-fs: ^4.2.9
+    jest-haste-map: ^29.7.0
+    slash: ^3.0.0
+  checksum: 73f43599017946be85c0b6357993b038f875b796e2f0950487a82f4ebcb115fa12131932dd9904026b4ad8be131fe6e28bd8d0aa93b1563705185f9804bff8bd
+  languageName: node
+  linkType: hard
+
+"@jest/transform@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "@jest/transform@npm:29.7.0"
+  dependencies:
+    "@babel/core": ^7.11.6
+    "@jest/types": ^29.6.3
+    "@jridgewell/trace-mapping": ^0.3.18
+    babel-plugin-istanbul: ^6.1.1
+    chalk: ^4.0.0
+    convert-source-map: ^2.0.0
+    fast-json-stable-stringify: ^2.1.0
+    graceful-fs: ^4.2.9
+    jest-haste-map: ^29.7.0
+    jest-regex-util: ^29.6.3
+    jest-util: ^29.7.0
+    micromatch: ^4.0.4
+    pirates: ^4.0.4
+    slash: ^3.0.0
+    write-file-atomic: ^4.0.2
+  checksum: 0f8ac9f413903b3cb6d240102db848f2a354f63971ab885833799a9964999dd51c388162106a807f810071f864302cdd8e3f0c241c29ce02d85a36f18f3f40ab
+  languageName: node
+  linkType: hard
+
+"@jest/types@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "@jest/types@npm:29.6.3"
+  dependencies:
+    "@jest/schemas": ^29.6.3
+    "@types/istanbul-lib-coverage": ^2.0.0
+    "@types/istanbul-reports": ^3.0.0
+    "@types/node": "*"
+    "@types/yargs": ^17.0.8
+    chalk: ^4.0.0
+  checksum: a0bcf15dbb0eca6bdd8ce61a3fb055349d40268622a7670a3b2eb3c3dbafe9eb26af59938366d520b86907b9505b0f9b29b85cec11579a9e580694b87cd90fcc
+  languageName: node
+  linkType: hard
+
+"@jridgewell/gen-mapping@npm:^0.3.5":
+  version: 0.3.8
+  resolution: "@jridgewell/gen-mapping@npm:0.3.8"
+  dependencies:
+    "@jridgewell/set-array": ^1.2.1
+    "@jridgewell/sourcemap-codec": ^1.4.10
+    "@jridgewell/trace-mapping": ^0.3.24
+  checksum: c0687b5227461717aa537fe71a42e356bcd1c43293b3353796a148bf3b0d6f59109def46c22f05b60e29a46f19b2e4676d027959a7c53a6c92b9d5b0d87d0420
+  languageName: node
+  linkType: hard
+
+"@jridgewell/resolve-uri@npm:^3.1.0":
+  version: 3.1.2
+  resolution: "@jridgewell/resolve-uri@npm:3.1.2"
+  checksum: 83b85f72c59d1c080b4cbec0fef84528963a1b5db34e4370fa4bd1e3ff64a0d80e0cee7369d11d73c704e0286fb2865b530acac7a871088fbe92b5edf1000870
+  languageName: node
+  linkType: hard
+
+"@jridgewell/set-array@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "@jridgewell/set-array@npm:1.2.1"
+  checksum: 832e513a85a588f8ed4f27d1279420d8547743cc37fcad5a5a76fc74bb895b013dfe614d0eed9cb860048e6546b798f8f2652020b4b2ba0561b05caa8c654b10
+  languageName: node
+  linkType: hard
+
+"@jridgewell/source-map@npm:^0.3.3":
+  version: 0.3.6
+  resolution: "@jridgewell/source-map@npm:0.3.6"
+  dependencies:
+    "@jridgewell/gen-mapping": ^0.3.5
+    "@jridgewell/trace-mapping": ^0.3.25
+  checksum: c9dc7d899397df95e3c9ec287b93c0b56f8e4453cd20743e2b9c8e779b1949bc3cccf6c01bb302779e46560eb45f62ea38d19fedd25370d814734268450a9f30
+  languageName: node
+  linkType: hard
+
+"@jridgewell/sourcemap-codec@npm:^1.4.10, @jridgewell/sourcemap-codec@npm:^1.4.14":
+  version: 1.5.0
+  resolution: "@jridgewell/sourcemap-codec@npm:1.5.0"
+  checksum: 05df4f2538b3b0f998ea4c1cd34574d0feba216fa5d4ccaef0187d12abf82eafe6021cec8b49f9bb4d90f2ba4582ccc581e72986a5fcf4176ae0cfeb04cf52ec
+  languageName: node
+  linkType: hard
+
+"@jridgewell/trace-mapping@npm:^0.3.12, @jridgewell/trace-mapping@npm:^0.3.18, @jridgewell/trace-mapping@npm:^0.3.24, @jridgewell/trace-mapping@npm:^0.3.25":
+  version: 0.3.25
+  resolution: "@jridgewell/trace-mapping@npm:0.3.25"
+  dependencies:
+    "@jridgewell/resolve-uri": ^3.1.0
+    "@jridgewell/sourcemap-codec": ^1.4.14
+  checksum: 9d3c40d225e139987b50c48988f8717a54a8c994d8a948ee42e1412e08988761d0754d7d10b803061cc3aebf35f92a5dbbab493bd0e1a9ef9e89a2130e83ba34
+  languageName: node
+  linkType: hard
+
+"@jupyter-widgets/base-manager@npm:^1.0.7":
+  version: 1.0.11
+  resolution: "@jupyter-widgets/base-manager@npm:1.0.11"
+  dependencies:
+    "@jupyter-widgets/base": ^6.0.10
+    "@jupyterlab/services": ^6.0.0 || ^7.0.0
+    "@lumino/coreutils": ^1.11.1 || ^2
+    base64-js: ^1.2.1
+    sanitize-html: ^2.3
+  checksum: 04ef40b05f38ac081cae63c5201a09c30c587df8039671e4d11b16fd911171bd3507deb7b2bc7d7f0e7805bfedb7fee77ebd2560606d6570659c669abc19e374
+  languageName: node
+  linkType: hard
+
+"@jupyter-widgets/base@npm:^1.1.10 || ^2 || ^3 || ^4 || ^5 || ^6, @jupyter-widgets/base@npm:^6.0.10":
+  version: 6.0.10
+  resolution: "@jupyter-widgets/base@npm:6.0.10"
+  dependencies:
+    "@jupyterlab/services": ^6.0.0 || ^7.0.0
+    "@lumino/coreutils": ^1.11.1 || ^2.1
+    "@lumino/messaging": ^1.10.1 || ^2.1
+    "@lumino/widgets": ^1.30.0 || ^2.1
+    "@types/backbone": 1.4.14
+    "@types/lodash": ^4.14.134
+    backbone: 1.4.0
+    jquery: ^3.1.1
+    lodash: ^4.17.4
+  checksum: 423f96bf6bee953f9347e7fb85a89bbae5f4040a91ab6d6769bc72b1f9752b388cb3b9ede68032133c4c567fc411d06ced290e0bfb80d3c348caa0eaf81cab9b
+  languageName: node
+  linkType: hard
+
+"@jupyter/ydoc@npm:^3.0.0":
+  version: 3.0.2
+  resolution: "@jupyter/ydoc@npm:3.0.2"
+  dependencies:
+    "@jupyterlab/nbformat": ^3.0.0 || ^4.0.0-alpha.21 || ^4.0.0
+    "@lumino/coreutils": ^1.11.0 || ^2.0.0
+    "@lumino/disposable": ^1.10.0 || ^2.0.0
+    "@lumino/signaling": ^1.10.0 || ^2.0.0
+    y-protocols: ^1.0.5
+    yjs: ^13.5.40
+  checksum: 770f73459635c74bd0e5cacdca1ea1f77ee8efd6e7cd58f0ccbb167ae8374e73118620f4f3628646281160a7bc7389f374bd2106f1e799bdc8f78cad0ce05b28
+  languageName: node
+  linkType: hard
+
+"@jupyterlab/builder@npm:^4.0.11":
+  version: 4.3.4
+  resolution: "@jupyterlab/builder@npm:4.3.4"
+  dependencies:
+    "@lumino/algorithm": ^2.0.2
+    "@lumino/application": ^2.4.1
+    "@lumino/commands": ^2.3.1
+    "@lumino/coreutils": ^2.2.0
+    "@lumino/disposable": ^2.1.3
+    "@lumino/domutils": ^2.0.2
+    "@lumino/dragdrop": ^2.1.5
+    "@lumino/messaging": ^2.0.2
+    "@lumino/properties": ^2.0.2
+    "@lumino/signaling": ^2.1.3
+    "@lumino/virtualdom": ^2.0.2
+    "@lumino/widgets": ^2.5.0
+    ajv: ^8.12.0
+    commander: ^9.4.1
+    css-loader: ^6.7.1
+    duplicate-package-checker-webpack-plugin: ^3.0.0
+    fs-extra: ^10.1.0
+    glob: ~7.1.6
+    license-webpack-plugin: ^2.3.14
+    mini-css-extract-plugin: ^2.7.0
+    mini-svg-data-uri: ^1.4.4
+    path-browserify: ^1.0.0
+    process: ^0.11.10
+    source-map-loader: ~1.0.2
+    style-loader: ~3.3.1
+    supports-color: ^7.2.0
+    terser-webpack-plugin: ^5.3.7
+    webpack: ^5.76.1
+    webpack-cli: ^5.0.1
+    webpack-merge: ^5.8.0
+    worker-loader: ^3.0.2
+  bin:
+    build-labextension: lib/build-labextension.js
+  checksum: fd495abe59afb1ad52f83e97cd79870dc6d5f879f706f02c6746e7a37e6f00af3a5d2fdc879a384048fa966d0160831369b3ae91115dcf903474709064046026
+  languageName: node
+  linkType: hard
+
+"@jupyterlab/coreutils@npm:^6.3.4":
+  version: 6.3.4
+  resolution: "@jupyterlab/coreutils@npm:6.3.4"
+  dependencies:
+    "@lumino/coreutils": ^2.2.0
+    "@lumino/disposable": ^2.1.3
+    "@lumino/signaling": ^2.1.3
+    minimist: ~1.2.0
+    path-browserify: ^1.0.0
+    url-parse: ~1.5.4
+  checksum: 3db39307315acb29dd606d02d5fcc6c09a57556aa0d41ba439a0577cf69c7338a90ae99e1106ebd20d842861ebda39266a910644e5a41301f62a03bb33cc4555
+  languageName: node
+  linkType: hard
+
+"@jupyterlab/nbformat@npm:^3.0.0 || ^4.0.0-alpha.21 || ^4.0.0, @jupyterlab/nbformat@npm:^4.3.4":
+  version: 4.3.4
+  resolution: "@jupyterlab/nbformat@npm:4.3.4"
+  dependencies:
+    "@lumino/coreutils": ^2.2.0
+  checksum: 7c2b2bf9ce1632b8d4b0aa415e19c5b25e0fb155457cdd9fed9d7a162e477e728fefdef07d18ac25aa8ac1223534615abbc0e1f7d58c0607dc66326d694a8823
+  languageName: node
+  linkType: hard
+
+"@jupyterlab/services@npm:^6.0.0 || ^7.0.0":
+  version: 7.3.4
+  resolution: "@jupyterlab/services@npm:7.3.4"
+  dependencies:
+    "@jupyter/ydoc": ^3.0.0
+    "@jupyterlab/coreutils": ^6.3.4
+    "@jupyterlab/nbformat": ^4.3.4
+    "@jupyterlab/settingregistry": ^4.3.4
+    "@jupyterlab/statedb": ^4.3.4
+    "@lumino/coreutils": ^2.2.0
+    "@lumino/disposable": ^2.1.3
+    "@lumino/polling": ^2.1.3
+    "@lumino/properties": ^2.0.2
+    "@lumino/signaling": ^2.1.3
+    ws: ^8.11.0
+  checksum: e962b30171ce94c6d9e60d8d06169fd6e7aa9178804b8e14e539dabac6bc04ac29a257be7b8a82c3b479291659738a55da73e2080c6dea3d986bbcc6f4e00850
+  languageName: node
+  linkType: hard
+
+"@jupyterlab/settingregistry@npm:^4.3.4":
+  version: 4.3.4
+  resolution: "@jupyterlab/settingregistry@npm:4.3.4"
+  dependencies:
+    "@jupyterlab/nbformat": ^4.3.4
+    "@jupyterlab/statedb": ^4.3.4
+    "@lumino/commands": ^2.3.1
+    "@lumino/coreutils": ^2.2.0
+    "@lumino/disposable": ^2.1.3
+    "@lumino/signaling": ^2.1.3
+    "@rjsf/utils": ^5.13.4
+    ajv: ^8.12.0
+    json5: ^2.2.3
+  peerDependencies:
+    react: ">=16"
+  checksum: e6e89174535d10268d70f9c5731bbb1ee6614d8cf87a73d5c4c3b40e6d051ecebb03ec23c508132fe3714473a0667b337674db07759d487b2fb679ca99fd8f35
+  languageName: node
+  linkType: hard
+
+"@jupyterlab/statedb@npm:^4.3.4":
+  version: 4.3.4
+  resolution: "@jupyterlab/statedb@npm:4.3.4"
+  dependencies:
+    "@lumino/commands": ^2.3.1
+    "@lumino/coreutils": ^2.2.0
+    "@lumino/disposable": ^2.1.3
+    "@lumino/properties": ^2.0.2
+    "@lumino/signaling": ^2.1.3
+  checksum: dfb6e3904ca8898bf69d188448559b7356fdac8e579f8214779be7ba709db82372dc2836f245ff3f9c3ff8e382fa82abd354613e5cd89c60348b3d4f7597bf1c
+  languageName: node
+  linkType: hard
+
+"@lumino/algorithm@npm:^1.9.2":
+  version: 1.9.2
+  resolution: "@lumino/algorithm@npm:1.9.2"
+  checksum: a89e7c63504236119634858e271db1cc649684d30ced5a6ebe2788af7c0837f1e05a6fd3047d8525eb756c42ce137f76b3688f75fd3ef915b71cd4f213dfbb96
+  languageName: node
+  linkType: hard
+
+"@lumino/algorithm@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@lumino/algorithm@npm:2.0.2"
+  checksum: 34b25684b845f1bdbf78ca45ebd99a97b67b2992440c9643aafe5fc5a99fae1ddafa9e5890b246b233dc3a12d9f66aa84afe4a2aac44cf31071348ed217740db
+  languageName: node
+  linkType: hard
+
+"@lumino/application@npm:^2.3.0, @lumino/application@npm:^2.4.1":
+  version: 2.4.1
+  resolution: "@lumino/application@npm:2.4.1"
+  dependencies:
+    "@lumino/commands": ^2.3.1
+    "@lumino/coreutils": ^2.2.0
+    "@lumino/widgets": ^2.5.0
+  checksum: b7166d1bf4f0e3cc945d984b4057a4cd106d38df6cb4c6f1259c75484e2b976018aca55f169fa4af7dd174ce7117be1920966bef0fb7cba756f503f0df1d211e
+  languageName: node
+  linkType: hard
+
+"@lumino/collections@npm:^1.9.3":
+  version: 1.9.3
+  resolution: "@lumino/collections@npm:1.9.3"
+  dependencies:
+    "@lumino/algorithm": ^1.9.2
+  checksum: 1c87a12743eddd6f6b593e47945a5645e2f99ad61c5192499b0745e48ee9aff263c7145541e77dfeea4c9f50bdd017fddfa47bfc60e718de4f28533ce45bf8c3
+  languageName: node
+  linkType: hard
+
+"@lumino/collections@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@lumino/collections@npm:2.0.2"
+  dependencies:
+    "@lumino/algorithm": ^2.0.2
+  checksum: e8bb2068a3741940e0dd396fa729c3c9d12458b41b7c2a9d171c5c034e69fb5834116a824094a8aa4182397e13abace06025ed5032a755ea85b976eae74ee9a9
+  languageName: node
+  linkType: hard
+
+"@lumino/commands@npm:^2.3.1":
+  version: 2.3.1
+  resolution: "@lumino/commands@npm:2.3.1"
+  dependencies:
+    "@lumino/algorithm": ^2.0.2
+    "@lumino/coreutils": ^2.2.0
+    "@lumino/disposable": ^2.1.3
+    "@lumino/domutils": ^2.0.2
+    "@lumino/keyboard": ^2.0.2
+    "@lumino/signaling": ^2.1.3
+    "@lumino/virtualdom": ^2.0.2
+  checksum: 83bc6d66de37e58582b00f70ce66e797c9fcf84e36041c6881631ed0d281305e2a49927f5b2fe6c5c965733f3cd6fb4a233c7b7967fc050497024a941659bd65
+  languageName: node
+  linkType: hard
+
+"@lumino/coreutils@npm:^1.11.0 || ^2.0.0, @lumino/coreutils@npm:^1.11.1 || ^2, @lumino/coreutils@npm:^1.11.1 || ^2.1, @lumino/coreutils@npm:^2.2.0":
+  version: 2.2.0
+  resolution: "@lumino/coreutils@npm:2.2.0"
+  dependencies:
+    "@lumino/algorithm": ^2.0.2
+  checksum: 345fcd5d7493d745831dd944edfbd8eda06cc59a117e71023fc97ce53badd697be2bd51671f071f5ff0064f75f104575d9695f116a07517bafbedd38e5c7a785
+  languageName: node
+  linkType: hard
+
+"@lumino/disposable@npm:^1.10.0 || ^2.0.0, @lumino/disposable@npm:^2.1.3":
+  version: 2.1.3
+  resolution: "@lumino/disposable@npm:2.1.3"
+  dependencies:
+    "@lumino/signaling": ^2.1.3
+  checksum: b9a346fa2752b3cd1b053cb637ee173501d33082a73423429070e8acc508b034ea0babdae0549b923cbdd287ee1fc7f6159f0539c9fff7574393a214eef07c57
+  languageName: node
+  linkType: hard
+
+"@lumino/domutils@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@lumino/domutils@npm:2.0.2"
+  checksum: 037b8d0b62af43887fd7edd506fa551e2af104a4b46d62e6fef256e16754dba40d351513beb5083834d468b2c7806aae0fe205fd6aac8ef24759451ee998bbd9
+  languageName: node
+  linkType: hard
+
+"@lumino/dragdrop@npm:^2.1.5":
+  version: 2.1.5
+  resolution: "@lumino/dragdrop@npm:2.1.5"
+  dependencies:
+    "@lumino/coreutils": ^2.2.0
+    "@lumino/disposable": ^2.1.3
+  checksum: 48e34bea73186dcde4565fa68cd25067b7f5fe910813d28da9ab3c5392bfaa0b26aab1290635dc953d85bbb139da7ac1ffc040a5d5777d58fd087975dd4b5ef7
+  languageName: node
+  linkType: hard
+
+"@lumino/keyboard@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@lumino/keyboard@npm:2.0.2"
+  checksum: 198e8c17825c9a831fa0770f58a71574b936acb0f0bbbe7f8feb73d89686dda7ff41fcb02d12b401f5d462b45fe0bba24f7f38befb7cefe0826576559f0bee6d
+  languageName: node
+  linkType: hard
+
+"@lumino/messaging@npm:^1.10.1 || ^2.1":
+  version: 1.10.3
+  resolution: "@lumino/messaging@npm:1.10.3"
+  dependencies:
+    "@lumino/algorithm": ^1.9.2
+    "@lumino/collections": ^1.9.3
+  checksum: 1131e80379fa9b8a9b5d3418c90e25d4be48e2c92ec711518190772f9e8845a695bef45daddd06a129168cf6f158c8ad80ae86cb245f566e9195bbd9a0843b7a
+  languageName: node
+  linkType: hard
+
+"@lumino/messaging@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@lumino/messaging@npm:2.0.2"
+  dependencies:
+    "@lumino/algorithm": ^2.0.2
+    "@lumino/collections": ^2.0.2
+  checksum: 66abd8c473026123589dc22f2ce8f85da10e0b1a05c05ed9b2011035721da5f751cc7ef63b628877f446a78a4287e26ad1450efbeaf0c2e03b1d08be9abaca4d
+  languageName: node
+  linkType: hard
+
+"@lumino/polling@npm:^2.1.3":
+  version: 2.1.3
+  resolution: "@lumino/polling@npm:2.1.3"
+  dependencies:
+    "@lumino/coreutils": ^2.2.0
+    "@lumino/disposable": ^2.1.3
+    "@lumino/signaling": ^2.1.3
+  checksum: 2c94dbc2339dd06b3b89a3a690d23576ce095f92bf1f614557dcaeb1c1a8a707b2a18d78c03e5fd7376a43e3f393cc4fec42a65580ae4b67c6630ea86cecbac6
+  languageName: node
+  linkType: hard
+
+"@lumino/properties@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@lumino/properties@npm:2.0.2"
+  checksum: cbe802bd49ced7e13e50b1d89b82e0f03fb44a590c704e6b9343226498b21d8abfe119b024209e79876b4fc0938dbf85e964c6c4cd5bbdd4d7ba41ce0fb69f3f
+  languageName: node
+  linkType: hard
+
+"@lumino/signaling@npm:^1.10.0 || ^2.0.0, @lumino/signaling@npm:^2.1.3":
+  version: 2.1.3
+  resolution: "@lumino/signaling@npm:2.1.3"
+  dependencies:
+    "@lumino/algorithm": ^2.0.2
+    "@lumino/coreutils": ^2.2.0
+  checksum: ce59383bd75fe30df5800e0442dbc4193cc6778e2530b9be0f484d159f1d8668be5c6ee92cee9df36d5a0c3dbd9126d0479a82581dee1df889d5c9f922d3328d
+  languageName: node
+  linkType: hard
+
+"@lumino/virtualdom@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@lumino/virtualdom@npm:2.0.2"
+  dependencies:
+    "@lumino/algorithm": ^2.0.2
+  checksum: 0e1220d5b3b2441e7668f3542a6341e015bdbea0c8bd6d4be962009386c034336540732596d5dedcd54ca57fbde61c2942549129a3e1b0fccb1aa143685fcd15
+  languageName: node
+  linkType: hard
+
+"@lumino/widgets@npm:^1.30.0 || ^2.1, @lumino/widgets@npm:^2.3.1, @lumino/widgets@npm:^2.5.0":
+  version: 2.5.0
+  resolution: "@lumino/widgets@npm:2.5.0"
+  dependencies:
+    "@lumino/algorithm": ^2.0.2
+    "@lumino/commands": ^2.3.1
+    "@lumino/coreutils": ^2.2.0
+    "@lumino/disposable": ^2.1.3
+    "@lumino/domutils": ^2.0.2
+    "@lumino/dragdrop": ^2.1.5
+    "@lumino/keyboard": ^2.0.2
+    "@lumino/messaging": ^2.0.2
+    "@lumino/properties": ^2.0.2
+    "@lumino/signaling": ^2.1.3
+    "@lumino/virtualdom": ^2.0.2
+  checksum: c5055e42b0b7d5d9a0c29d14c7053478cbdef057525e262ccd59c987971364d5462ed1a59d5008b889cf5ecc6810e90c681364239500b9c8ee0ae4624d60df84
+  languageName: node
+  linkType: hard
+
+"@nodelib/fs.scandir@npm:2.1.5":
+  version: 2.1.5
+  resolution: "@nodelib/fs.scandir@npm:2.1.5"
+  dependencies:
+    "@nodelib/fs.stat": 2.0.5
+    run-parallel: ^1.1.9
+  checksum: a970d595bd23c66c880e0ef1817791432dbb7acbb8d44b7e7d0e7a22f4521260d4a83f7f9fd61d44fda4610105577f8f58a60718105fb38352baed612fd79e59
+  languageName: node
+  linkType: hard
+
+"@nodelib/fs.stat@npm:2.0.5, @nodelib/fs.stat@npm:^2.0.2":
+  version: 2.0.5
+  resolution: "@nodelib/fs.stat@npm:2.0.5"
+  checksum: 012480b5ca9d97bff9261571dbbec7bbc6033f69cc92908bc1ecfad0792361a5a1994bc48674b9ef76419d056a03efadfce5a6cf6dbc0a36559571a7a483f6f0
+  languageName: node
+  linkType: hard
+
+"@nodelib/fs.walk@npm:^1.2.3, @nodelib/fs.walk@npm:^1.2.8":
+  version: 1.2.8
+  resolution: "@nodelib/fs.walk@npm:1.2.8"
+  dependencies:
+    "@nodelib/fs.scandir": 2.1.5
+    fastq: ^1.6.0
+  checksum: 190c643f156d8f8f277bf2a6078af1ffde1fd43f498f187c2db24d35b4b4b5785c02c7dc52e356497b9a1b65b13edc996de08de0b961c32844364da02986dc53
+  languageName: node
+  linkType: hard
+
+"@npmcli/agent@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "@npmcli/agent@npm:3.0.0"
+  dependencies:
+    agent-base: ^7.1.0
+    http-proxy-agent: ^7.0.0
+    https-proxy-agent: ^7.0.1
+    lru-cache: ^10.0.1
+    socks-proxy-agent: ^8.0.3
+  checksum: e8fc25d536250ed3e669813b36e8c6d805628b472353c57afd8c4fde0fcfcf3dda4ffe22f7af8c9070812ec2e7a03fb41d7151547cef3508efe661a5a3add20f
+  languageName: node
+  linkType: hard
+
+"@npmcli/fs@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "@npmcli/fs@npm:4.0.0"
+  dependencies:
+    semver: ^7.3.5
+  checksum: 68951c589e9a4328698a35fd82fe71909a257d6f2ede0434d236fa55634f0fbcad9bb8755553ce5849bd25ee6f019f4d435921ac715c853582c4a7f5983c8d4a
+  languageName: node
+  linkType: hard
+
+"@pkgjs/parseargs@npm:^0.11.0":
+  version: 0.11.0
+  resolution: "@pkgjs/parseargs@npm:0.11.0"
+  checksum: 6ad6a00fc4f2f2cfc6bff76fb1d88b8ee20bc0601e18ebb01b6d4be583733a860239a521a7fbca73b612e66705078809483549d2b18f370eb346c5155c8e4a0f
+  languageName: node
+  linkType: hard
+
+"@pkgr/core@npm:^0.1.0":
+  version: 0.1.1
+  resolution: "@pkgr/core@npm:0.1.1"
+  checksum: 6f25fd2e3008f259c77207ac9915b02f1628420403b2630c92a07ff963129238c9262afc9e84344c7a23b5cc1f3965e2cd17e3798219f5fd78a63d144d3cceba
+  languageName: node
+  linkType: hard
+
+"@rjsf/utils@npm:^5.13.4":
+  version: 5.23.2
+  resolution: "@rjsf/utils@npm:5.23.2"
+  dependencies:
+    json-schema-merge-allof: ^0.8.1
+    jsonpointer: ^5.0.1
+    lodash: ^4.17.21
+    lodash-es: ^4.17.21
+    react-is: ^18.2.0
+  peerDependencies:
+    react: ^16.14.0 || >=17
+  checksum: 16980013258bab7accaff961c533e4bb8e3326c37a84670a7667b2a10c1ca395451eb51a6cf819ccbafb1aa8838df325ff1f314b410bb186fef98856135e1a06
+  languageName: node
+  linkType: hard
+
+"@sinclair/typebox@npm:^0.27.8":
+  version: 0.27.8
+  resolution: "@sinclair/typebox@npm:0.27.8"
+  checksum: 00bd7362a3439021aa1ea51b0e0d0a0e8ca1351a3d54c606b115fdcc49b51b16db6e5f43b4fe7a28c38688523e22a94d49dd31168868b655f0d4d50f032d07a1
+  languageName: node
+  linkType: hard
+
+"@sinonjs/commons@npm:^3.0.0":
+  version: 3.0.1
+  resolution: "@sinonjs/commons@npm:3.0.1"
+  dependencies:
+    type-detect: 4.0.8
+  checksum: a7c3e7cc612352f4004873747d9d8b2d4d90b13a6d483f685598c945a70e734e255f1ca5dc49702515533c403b32725defff148177453b3f3915bcb60e9d4601
+  languageName: node
+  linkType: hard
+
+"@sinonjs/fake-timers@npm:^10.0.2":
+  version: 10.3.0
+  resolution: "@sinonjs/fake-timers@npm:10.3.0"
+  dependencies:
+    "@sinonjs/commons": ^3.0.0
+  checksum: 614d30cb4d5201550c940945d44c9e0b6d64a888ff2cd5b357f95ad6721070d6b8839cd10e15b76bf5e14af0bcc1d8f9ec00d49a46318f1f669a4bec1d7f3148
+  languageName: node
+  linkType: hard
+
+"@tootallnate/once@npm:2":
+  version: 2.0.0
+  resolution: "@tootallnate/once@npm:2.0.0"
+  checksum: ad87447820dd3f24825d2d947ebc03072b20a42bfc96cbafec16bff8bbda6c1a81fcb0be56d5b21968560c5359a0af4038a68ba150c3e1694fe4c109a063bed8
+  languageName: node
+  linkType: hard
+
+"@types/babel__core@npm:^7.1.14":
+  version: 7.20.5
+  resolution: "@types/babel__core@npm:7.20.5"
+  dependencies:
+    "@babel/parser": ^7.20.7
+    "@babel/types": ^7.20.7
+    "@types/babel__generator": "*"
+    "@types/babel__template": "*"
+    "@types/babel__traverse": "*"
+  checksum: a3226f7930b635ee7a5e72c8d51a357e799d19cbf9d445710fa39ab13804f79ab1a54b72ea7d8e504659c7dfc50675db974b526142c754398d7413aa4bc30845
+  languageName: node
+  linkType: hard
+
+"@types/babel__generator@npm:*":
+  version: 7.6.8
+  resolution: "@types/babel__generator@npm:7.6.8"
+  dependencies:
+    "@babel/types": ^7.0.0
+  checksum: 5b332ea336a2efffbdeedb92b6781949b73498606ddd4205462f7d96dafd45ff3618770b41de04c4881e333dd84388bfb8afbdf6f2764cbd98be550d85c6bb48
+  languageName: node
+  linkType: hard
+
+"@types/babel__template@npm:*":
+  version: 7.4.4
+  resolution: "@types/babel__template@npm:7.4.4"
+  dependencies:
+    "@babel/parser": ^7.1.0
+    "@babel/types": ^7.0.0
+  checksum: d7a02d2a9b67e822694d8e6a7ddb8f2b71a1d6962dfd266554d2513eefbb205b33ca71a0d163b1caea3981ccf849211f9964d8bd0727124d18ace45aa6c9ae29
+  languageName: node
+  linkType: hard
+
+"@types/babel__traverse@npm:*, @types/babel__traverse@npm:^7.0.6":
+  version: 7.20.6
+  resolution: "@types/babel__traverse@npm:7.20.6"
+  dependencies:
+    "@babel/types": ^7.20.7
+  checksum: 2bdc65eb62232c2d5c1086adeb0c31e7980e6fd7e50a3483b4a724a1a1029c84d9cb59749cf8de612f9afa2bc14c85b8f50e64e21f8a4398fa77eb9059a4283c
+  languageName: node
+  linkType: hard
+
+"@types/backbone@npm:1.4.14":
+  version: 1.4.14
+  resolution: "@types/backbone@npm:1.4.14"
+  dependencies:
+    "@types/jquery": "*"
+    "@types/underscore": "*"
+  checksum: 4f44bfb71d75332b5de610be7687f4ae523ad4ef02da844a828403b534b6a94a6288b32cab64371d0ad526e35cfed511652ac53af22d0b9caaac3f4cfb4375dd
+  languageName: node
+  linkType: hard
+
+"@types/eslint-scope@npm:^3.7.7":
+  version: 3.7.7
+  resolution: "@types/eslint-scope@npm:3.7.7"
+  dependencies:
+    "@types/eslint": "*"
+    "@types/estree": "*"
+  checksum: e2889a124aaab0b89af1bab5959847c5bec09809209255de0e63b9f54c629a94781daa04adb66bffcdd742f5e25a17614fb933965093c0eea64aacda4309380e
+  languageName: node
+  linkType: hard
+
+"@types/eslint@npm:*":
+  version: 9.6.1
+  resolution: "@types/eslint@npm:9.6.1"
+  dependencies:
+    "@types/estree": "*"
+    "@types/json-schema": "*"
+  checksum: c286e79707ab604b577cf8ce51d9bbb9780e3d6a68b38a83febe13fa05b8012c92de17c28532fac2b03d3c460123f5055d603a579685325246ca1c86828223e0
+  languageName: node
+  linkType: hard
+
+"@types/estree@npm:*, @types/estree@npm:^1.0.6":
+  version: 1.0.6
+  resolution: "@types/estree@npm:1.0.6"
+  checksum: 8825d6e729e16445d9a1dd2fb1db2edc5ed400799064cd4d028150701031af012ba30d6d03fe9df40f4d7a437d0de6d2b256020152b7b09bde9f2e420afdffd9
+  languageName: node
+  linkType: hard
+
+"@types/graceful-fs@npm:^4.1.3":
+  version: 4.1.9
+  resolution: "@types/graceful-fs@npm:4.1.9"
+  dependencies:
+    "@types/node": "*"
+  checksum: 79d746a8f053954bba36bd3d94a90c78de995d126289d656fb3271dd9f1229d33f678da04d10bce6be440494a5a73438e2e363e92802d16b8315b051036c5256
+  languageName: node
+  linkType: hard
+
+"@types/istanbul-lib-coverage@npm:*, @types/istanbul-lib-coverage@npm:^2.0.0, @types/istanbul-lib-coverage@npm:^2.0.1":
+  version: 2.0.6
+  resolution: "@types/istanbul-lib-coverage@npm:2.0.6"
+  checksum: 3feac423fd3e5449485afac999dcfcb3d44a37c830af898b689fadc65d26526460bedb889db278e0d4d815a670331796494d073a10ee6e3a6526301fe7415778
+  languageName: node
+  linkType: hard
+
+"@types/istanbul-lib-report@npm:*":
+  version: 3.0.3
+  resolution: "@types/istanbul-lib-report@npm:3.0.3"
+  dependencies:
+    "@types/istanbul-lib-coverage": "*"
+  checksum: b91e9b60f865ff08cb35667a427b70f6c2c63e88105eadd29a112582942af47ed99c60610180aa8dcc22382fa405033f141c119c69b95db78c4c709fbadfeeb4
+  languageName: node
+  linkType: hard
+
+"@types/istanbul-reports@npm:^3.0.0":
+  version: 3.0.4
+  resolution: "@types/istanbul-reports@npm:3.0.4"
+  dependencies:
+    "@types/istanbul-lib-report": "*"
+  checksum: 93eb18835770b3431f68ae9ac1ca91741ab85f7606f310a34b3586b5a34450ec038c3eed7ab19266635499594de52ff73723a54a72a75b9f7d6a956f01edee95
+  languageName: node
+  linkType: hard
+
+"@types/jest@npm:^29.5.11":
+  version: 29.5.14
+  resolution: "@types/jest@npm:29.5.14"
+  dependencies:
+    expect: ^29.0.0
+    pretty-format: ^29.0.0
+  checksum: 18dba4623f26661641d757c63da2db45e9524c9be96a29ef713c703a9a53792df9ecee9f7365a0858ddbd6440d98fe6b65ca67895ca5884b73cbc7ffc11f3838
+  languageName: node
+  linkType: hard
+
+"@types/jquery@npm:*":
+  version: 3.5.32
+  resolution: "@types/jquery@npm:3.5.32"
+  dependencies:
+    "@types/sizzle": "*"
+  checksum: 7fe7251bda3fc9d80417ef7c88ad963ccb591706bca2fb84ea5d9600498a8f9911c32302f28fd1910bb212c34193f38f63818757a9833b70e1f46c3a98a17625
+  languageName: node
+  linkType: hard
+
+"@types/jsdom@npm:^20.0.0":
+  version: 20.0.1
+  resolution: "@types/jsdom@npm:20.0.1"
+  dependencies:
+    "@types/node": "*"
+    "@types/tough-cookie": "*"
+    parse5: ^7.0.0
+  checksum: d55402c5256ef451f93a6e3d3881f98339fe73a5ac2030588df056d6835df8367b5a857b48d27528289057e26dcdd3f502edc00cb877c79174cb3a4c7f2198c1
+  languageName: node
+  linkType: hard
+
+"@types/json-schema@npm:*, @types/json-schema@npm:^7.0.12, @types/json-schema@npm:^7.0.5, @types/json-schema@npm:^7.0.8, @types/json-schema@npm:^7.0.9":
+  version: 7.0.15
+  resolution: "@types/json-schema@npm:7.0.15"
+  checksum: 97ed0cb44d4070aecea772b7b2e2ed971e10c81ec87dd4ecc160322ffa55ff330dace1793489540e3e318d90942064bb697cc0f8989391797792d919737b3b98
+  languageName: node
+  linkType: hard
+
+"@types/lodash@npm:^4.14.134":
+  version: 4.17.13
+  resolution: "@types/lodash@npm:4.17.13"
+  checksum: d0bf8fbd950be71946e0076b30fd40d492293baea75f05931b6b5b906fd62583708c6229abdb95b30205ad24ce1ed2f48bc9d419364f682320edd03405cc0c7e
+  languageName: node
+  linkType: hard
+
+"@types/node@npm:*":
+  version: 22.10.2
+  resolution: "@types/node@npm:22.10.2"
+  dependencies:
+    undici-types: ~6.20.0
+  checksum: b22401e6e7d1484e437d802c72f5560e18100b1257b9ad0574d6fe05bebe4dbcb620ea68627d1f1406775070d29ace8b6b51f57e7b1c7b8bafafe6da7f29c843
+  languageName: node
+  linkType: hard
+
+"@types/semver@npm:^7.5.0":
+  version: 7.5.8
+  resolution: "@types/semver@npm:7.5.8"
+  checksum: ea6f5276f5b84c55921785a3a27a3cd37afee0111dfe2bcb3e03c31819c197c782598f17f0b150a69d453c9584cd14c4c4d7b9a55d2c5e6cacd4d66fdb3b3663
+  languageName: node
+  linkType: hard
+
+"@types/sizzle@npm:*":
+  version: 2.3.9
+  resolution: "@types/sizzle@npm:2.3.9"
+  checksum: 413811a79e7e9f1d8f47e6047ae0aea1530449d612304cdda1c30018e3d053b8544861ec2c70bdeca75a0a010192e6bb78efc6fb4caaafdd65c4eee90066686a
+  languageName: node
+  linkType: hard
+
+"@types/source-list-map@npm:*":
+  version: 0.1.6
+  resolution: "@types/source-list-map@npm:0.1.6"
+  checksum: 9cd294c121f1562062de5d241fe4d10780b1131b01c57434845fe50968e9dcf67ede444591c2b1ad6d3f9b6bc646ac02cc8f51a3577c795f9c64cf4573dcc6b1
+  languageName: node
+  linkType: hard
+
+"@types/stack-utils@npm:^2.0.0":
+  version: 2.0.3
+  resolution: "@types/stack-utils@npm:2.0.3"
+  checksum: 72576cc1522090fe497337c2b99d9838e320659ac57fa5560fcbdcbafcf5d0216c6b3a0a8a4ee4fdb3b1f5e3420aa4f6223ab57b82fef3578bec3206425c6cf5
+  languageName: node
+  linkType: hard
+
+"@types/tough-cookie@npm:*":
+  version: 4.0.5
+  resolution: "@types/tough-cookie@npm:4.0.5"
+  checksum: f19409d0190b179331586365912920d192733112a195e870c7f18d20ac8adb7ad0b0ff69dad430dba8bc2be09593453a719cfea92dc3bda19748fd158fe1498d
+  languageName: node
+  linkType: hard
+
+"@types/underscore@npm:*":
+  version: 1.13.0
+  resolution: "@types/underscore@npm:1.13.0"
+  checksum: 1411cbeb1b743629d504fcb2037b393d11eb207459b9d560f71304183115e30ba145f83b819ffcc8a0d5d4eccfb76bebb0ef7aab8f96a04d88d99ff9dfe503c6
+  languageName: node
+  linkType: hard
+
+"@types/webpack-env@npm:^1.18.4":
+  version: 1.18.5
+  resolution: "@types/webpack-env@npm:1.18.5"
+  checksum: 4ca8eb4c44e1e1807c3e245442fce7aaf2816a163056de9436bbac44cc47c8bc5b1c9a330dc05748d6616431b1fb5bd5379733fb1da0b78d03c59f4ec824c184
+  languageName: node
+  linkType: hard
+
+"@types/webpack-sources@npm:^0.1.5":
+  version: 0.1.12
+  resolution: "@types/webpack-sources@npm:0.1.12"
+  dependencies:
+    "@types/node": "*"
+    "@types/source-list-map": "*"
+    source-map: ^0.6.1
+  checksum: 75342659a9889478969f7bb7360b998aa084ba11ab523c172ded6a807dac43ab2a9e1212078ef8bbf0f33e4fadd2c8a91b75d38184d8030d96a32fe819c9bb57
+  languageName: node
+  linkType: hard
+
+"@types/yargs-parser@npm:*":
+  version: 21.0.3
+  resolution: "@types/yargs-parser@npm:21.0.3"
+  checksum: ef236c27f9432983e91432d974243e6c4cdae227cb673740320eff32d04d853eed59c92ca6f1142a335cfdc0e17cccafa62e95886a8154ca8891cc2dec4ee6fc
+  languageName: node
+  linkType: hard
+
+"@types/yargs@npm:^17.0.8":
+  version: 17.0.33
+  resolution: "@types/yargs@npm:17.0.33"
+  dependencies:
+    "@types/yargs-parser": "*"
+  checksum: ee013f257472ab643cb0584cf3e1ff9b0c44bca1c9ba662395300a7f1a6c55fa9d41bd40ddff42d99f5d95febb3907c9ff600fbcb92dadbec22c6a76de7e1236
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/eslint-plugin@npm:^6.19.1":
+  version: 6.21.0
+  resolution: "@typescript-eslint/eslint-plugin@npm:6.21.0"
+  dependencies:
+    "@eslint-community/regexpp": ^4.5.1
+    "@typescript-eslint/scope-manager": 6.21.0
+    "@typescript-eslint/type-utils": 6.21.0
+    "@typescript-eslint/utils": 6.21.0
+    "@typescript-eslint/visitor-keys": 6.21.0
+    debug: ^4.3.4
+    graphemer: ^1.4.0
+    ignore: ^5.2.4
+    natural-compare: ^1.4.0
+    semver: ^7.5.4
+    ts-api-utils: ^1.0.1
+  peerDependencies:
+    "@typescript-eslint/parser": ^6.0.0 || ^6.0.0-alpha
+    eslint: ^7.0.0 || ^8.0.0
+  peerDependenciesMeta:
+    typescript:
+      optional: true
+  checksum: 5ef2c502255e643e98051e87eb682c2a257e87afd8ec3b9f6274277615e1c2caf3131b352244cfb1987b8b2c415645eeacb9113fa841fc4c9b2ac46e8aed6efd
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/parser@npm:^6.19.1":
+  version: 6.21.0
+  resolution: "@typescript-eslint/parser@npm:6.21.0"
+  dependencies:
+    "@typescript-eslint/scope-manager": 6.21.0
+    "@typescript-eslint/types": 6.21.0
+    "@typescript-eslint/typescript-estree": 6.21.0
+    "@typescript-eslint/visitor-keys": 6.21.0
+    debug: ^4.3.4
+  peerDependencies:
+    eslint: ^7.0.0 || ^8.0.0
+  peerDependenciesMeta:
+    typescript:
+      optional: true
+  checksum: 162fe3a867eeeffda7328bce32dae45b52283c68c8cb23258fb9f44971f761991af61f71b8c9fe1aa389e93dfe6386f8509c1273d870736c507d76dd40647b68
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/scope-manager@npm:6.21.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/scope-manager@npm:6.21.0"
+  dependencies:
+    "@typescript-eslint/types": 6.21.0
+    "@typescript-eslint/visitor-keys": 6.21.0
+  checksum: 71028b757da9694528c4c3294a96cc80bc7d396e383a405eab3bc224cda7341b88e0fc292120b35d3f31f47beac69f7083196c70616434072fbcd3d3e62d3376
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/type-utils@npm:6.21.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/type-utils@npm:6.21.0"
+  dependencies:
+    "@typescript-eslint/typescript-estree": 6.21.0
+    "@typescript-eslint/utils": 6.21.0
+    debug: ^4.3.4
+    ts-api-utils: ^1.0.1
+  peerDependencies:
+    eslint: ^7.0.0 || ^8.0.0
+  peerDependenciesMeta:
+    typescript:
+      optional: true
+  checksum: 77025473f4d80acf1fafcce99c5c283e557686a61861febeba9c9913331f8a41e930bf5cd8b7a54db502a57b6eb8ea6d155cbd4f41349ed00e3d7aeb1f477ddc
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/types@npm:6.21.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/types@npm:6.21.0"
+  checksum: 9501b47d7403417af95fc1fb72b2038c5ac46feac0e1598a46bcb43e56a606c387e9dcd8a2a0abe174c91b509f2d2a8078b093786219eb9a01ab2fbf9ee7b684
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/typescript-estree@npm:6.21.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/typescript-estree@npm:6.21.0"
+  dependencies:
+    "@typescript-eslint/types": 6.21.0
+    "@typescript-eslint/visitor-keys": 6.21.0
+    debug: ^4.3.4
+    globby: ^11.1.0
+    is-glob: ^4.0.3
+    minimatch: 9.0.3
+    semver: ^7.5.4
+    ts-api-utils: ^1.0.1
+  peerDependenciesMeta:
+    typescript:
+      optional: true
+  checksum: dec02dc107c4a541e14fb0c96148f3764b92117c3b635db3a577b5a56fc48df7a556fa853fb82b07c0663b4bf2c484c9f245c28ba3e17e5cb0918ea4cab2ea21
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/utils@npm:6.21.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/utils@npm:6.21.0"
+  dependencies:
+    "@eslint-community/eslint-utils": ^4.4.0
+    "@types/json-schema": ^7.0.12
+    "@types/semver": ^7.5.0
+    "@typescript-eslint/scope-manager": 6.21.0
+    "@typescript-eslint/types": 6.21.0
+    "@typescript-eslint/typescript-estree": 6.21.0
+    semver: ^7.5.4
+  peerDependencies:
+    eslint: ^7.0.0 || ^8.0.0
+  checksum: b129b3a4aebec8468259f4589985cb59ea808afbfdb9c54f02fad11e17d185e2bf72bb332f7c36ec3c09b31f18fc41368678b076323e6e019d06f74ee93f7bf2
+  languageName: node
+  linkType: hard
+
+"@typescript-eslint/visitor-keys@npm:6.21.0":
+  version: 6.21.0
+  resolution: "@typescript-eslint/visitor-keys@npm:6.21.0"
+  dependencies:
+    "@typescript-eslint/types": 6.21.0
+    eslint-visitor-keys: ^3.4.1
+  checksum: 67c7e6003d5af042d8703d11538fca9d76899f0119130b373402819ae43f0bc90d18656aa7add25a24427ccf1a0efd0804157ba83b0d4e145f06107d7d1b7433
+  languageName: node
+  linkType: hard
+
+"@ungap/structured-clone@npm:^1.2.0":
+  version: 1.2.1
+  resolution: "@ungap/structured-clone@npm:1.2.1"
+  checksum: 1e3b9fef293118861f0b2159b3695fc7f3793c0707095888ebb3ac7183f78c390e68f04cd4b4cf9ac979ae0da454505e08b3aae887cdd639609a3fe529e19e59
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/ast@npm:1.14.1, @webassemblyjs/ast@npm:^1.14.1":
+  version: 1.14.1
+  resolution: "@webassemblyjs/ast@npm:1.14.1"
+  dependencies:
+    "@webassemblyjs/helper-numbers": 1.13.2
+    "@webassemblyjs/helper-wasm-bytecode": 1.13.2
+  checksum: f9154ad9ea14f6f2374ebe918c221fd69a4d4514126a1acc6fa4966e8d27ab28cb550a5e6880032cf620e19640578658a7e5a55bd2aad1e3db4e9d598b8f2099
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/floating-point-hex-parser@npm:1.13.2":
+  version: 1.13.2
+  resolution: "@webassemblyjs/floating-point-hex-parser@npm:1.13.2"
+  checksum: e866ec8433f4a70baa511df5e8f2ebcd6c24f4e2cc6274c7c5aabe2bcce3459ea4680e0f35d450e1f3602acf3913b6b8e4f15069c8cfd34ae8609fb9a7d01795
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/helper-api-error@npm:1.13.2":
+  version: 1.13.2
+  resolution: "@webassemblyjs/helper-api-error@npm:1.13.2"
+  checksum: 48b5df7fd3095bb252f59a139fe2cbd999a62ac9b488123e9a0da3906ad8a2f2da7b2eb21d328c01a90da987380928706395c2897d1f3ed9e2125b6d75a920d0
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/helper-buffer@npm:1.14.1":
+  version: 1.14.1
+  resolution: "@webassemblyjs/helper-buffer@npm:1.14.1"
+  checksum: b611e981dfd6a797c3d8fc3a772de29a6e55033737c2c09c31bb66c613bdbb2d25f915df1dee62a602c6acc057ca71128432fa8c3e22a893e1219dc454f14ede
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/helper-numbers@npm:1.13.2":
+  version: 1.13.2
+  resolution: "@webassemblyjs/helper-numbers@npm:1.13.2"
+  dependencies:
+    "@webassemblyjs/floating-point-hex-parser": 1.13.2
+    "@webassemblyjs/helper-api-error": 1.13.2
+    "@xtuc/long": 4.2.2
+  checksum: 49e2c9bf9b66997e480f6b44d80f895b3cde4de52ac135921d28e144565edca6903a519f627f4089b5509de1d7f9e5023f0e1a94ff78a36c9e2eb30e7c18ffd2
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/helper-wasm-bytecode@npm:1.13.2":
+  version: 1.13.2
+  resolution: "@webassemblyjs/helper-wasm-bytecode@npm:1.13.2"
+  checksum: 8e059e1c1f0294f4fc3df8e4eaff3c5ef6e2e1358f34ebc118eaf5070ed59e56ed7fc92b28be734ebde17c8d662d5d27e06ade686c282445135da083ae11c128
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/helper-wasm-section@npm:1.14.1":
+  version: 1.14.1
+  resolution: "@webassemblyjs/helper-wasm-section@npm:1.14.1"
+  dependencies:
+    "@webassemblyjs/ast": 1.14.1
+    "@webassemblyjs/helper-buffer": 1.14.1
+    "@webassemblyjs/helper-wasm-bytecode": 1.13.2
+    "@webassemblyjs/wasm-gen": 1.14.1
+  checksum: 0a08d454a63192cd66abf91b6f060ac4b466cef341262246e9dcc828dd4c8536195dea9b46a1244b1eac65b59b8b502164a771a190052a92ff0a0a2ded0f8f53
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/ieee754@npm:1.13.2":
+  version: 1.13.2
+  resolution: "@webassemblyjs/ieee754@npm:1.13.2"
+  dependencies:
+    "@xtuc/ieee754": ^1.2.0
+  checksum: d7e3520baa37a7309fa7db4d73d69fb869878853b1ebd4b168821bd03fcc4c0e1669c06231315b0039035d9a7a462e53de3ad982da4a426a4b0743b5888e8673
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/leb128@npm:1.13.2":
+  version: 1.13.2
+  resolution: "@webassemblyjs/leb128@npm:1.13.2"
+  dependencies:
+    "@xtuc/long": 4.2.2
+  checksum: 64083507f7cff477a6d71a9e325d95665cea78ec8df99ca7c050e1cfbe300fbcf0842ca3dcf3b4fa55028350135588a4f879398d3dd2b6a8de9913ce7faf5333
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/utf8@npm:1.13.2":
+  version: 1.13.2
+  resolution: "@webassemblyjs/utf8@npm:1.13.2"
+  checksum: 95ec6052f30eefa8d50c9b2a3394d08b17d53a4aa52821451d41d774c126fa8f39b988fbf5bff56da86852a87c16d676e576775a4071e5e5ccf020cc85a4b281
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/wasm-edit@npm:^1.14.1":
+  version: 1.14.1
+  resolution: "@webassemblyjs/wasm-edit@npm:1.14.1"
+  dependencies:
+    "@webassemblyjs/ast": 1.14.1
+    "@webassemblyjs/helper-buffer": 1.14.1
+    "@webassemblyjs/helper-wasm-bytecode": 1.13.2
+    "@webassemblyjs/helper-wasm-section": 1.14.1
+    "@webassemblyjs/wasm-gen": 1.14.1
+    "@webassemblyjs/wasm-opt": 1.14.1
+    "@webassemblyjs/wasm-parser": 1.14.1
+    "@webassemblyjs/wast-printer": 1.14.1
+  checksum: 9341c3146bb1b7863f03d6050c2a66990f20384ca137388047bbe1feffacb599e94fca7b7c18287d17e2449ffb4005fdc7f41f674a6975af9ad8522756f8ffff
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/wasm-gen@npm:1.14.1":
+  version: 1.14.1
+  resolution: "@webassemblyjs/wasm-gen@npm:1.14.1"
+  dependencies:
+    "@webassemblyjs/ast": 1.14.1
+    "@webassemblyjs/helper-wasm-bytecode": 1.13.2
+    "@webassemblyjs/ieee754": 1.13.2
+    "@webassemblyjs/leb128": 1.13.2
+    "@webassemblyjs/utf8": 1.13.2
+  checksum: 401b12bec7431c4fc29d9414bbe40d3c6dc5be04d25a116657c42329f5481f0129f3b5834c293f26f0e42681ceac9157bf078ce9bdb6a7f78037c650373f98b2
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/wasm-opt@npm:1.14.1":
+  version: 1.14.1
+  resolution: "@webassemblyjs/wasm-opt@npm:1.14.1"
+  dependencies:
+    "@webassemblyjs/ast": 1.14.1
+    "@webassemblyjs/helper-buffer": 1.14.1
+    "@webassemblyjs/wasm-gen": 1.14.1
+    "@webassemblyjs/wasm-parser": 1.14.1
+  checksum: 60c697a9e9129d8d23573856df0791ba33cea4a3bc2339044cae73128c0983802e5e50a42157b990eeafe1237eb8e7653db6de5f02b54a0ae7b81b02dcdf2ae9
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/wasm-parser@npm:1.14.1, @webassemblyjs/wasm-parser@npm:^1.14.1":
+  version: 1.14.1
+  resolution: "@webassemblyjs/wasm-parser@npm:1.14.1"
+  dependencies:
+    "@webassemblyjs/ast": 1.14.1
+    "@webassemblyjs/helper-api-error": 1.13.2
+    "@webassemblyjs/helper-wasm-bytecode": 1.13.2
+    "@webassemblyjs/ieee754": 1.13.2
+    "@webassemblyjs/leb128": 1.13.2
+    "@webassemblyjs/utf8": 1.13.2
+  checksum: 93f1fe2676da465b4e824419d9812a3d7218de4c3addd4e916c04bc86055fa134416c1b67e4b7cbde8d728c0dce2721d06cc0bfe7a7db7c093a0898009937405
+  languageName: node
+  linkType: hard
+
+"@webassemblyjs/wast-printer@npm:1.14.1":
+  version: 1.14.1
+  resolution: "@webassemblyjs/wast-printer@npm:1.14.1"
+  dependencies:
+    "@webassemblyjs/ast": 1.14.1
+    "@xtuc/long": 4.2.2
+  checksum: 517881a0554debe6945de719d100b2d8883a2d24ddf47552cdeda866341e2bb153cd824a864bc7e2a61190a4b66b18f9899907e0074e9e820d2912ac0789ea60
+  languageName: node
+  linkType: hard
+
+"@webpack-cli/configtest@npm:^2.1.1":
+  version: 2.1.1
+  resolution: "@webpack-cli/configtest@npm:2.1.1"
+  peerDependencies:
+    webpack: 5.x.x
+    webpack-cli: 5.x.x
+  checksum: 9f9f9145c2d05471fc83d426db1df85cf49f329836b0c4b9f46b6948bed4b013464c00622b136d2a0a26993ce2306976682592245b08ee717500b1db45009a72
+  languageName: node
+  linkType: hard
+
+"@webpack-cli/info@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "@webpack-cli/info@npm:2.0.2"
+  peerDependencies:
+    webpack: 5.x.x
+    webpack-cli: 5.x.x
+  checksum: 8f9a178afca5c82e113aed1efa552d64ee5ae4fdff63fe747c096a981ec74f18a5d07bd6e89bbe6715c3e57d96eea024a410e58977169489fe1df044c10dd94e
+  languageName: node
+  linkType: hard
+
+"@webpack-cli/serve@npm:^2.0.5":
+  version: 2.0.5
+  resolution: "@webpack-cli/serve@npm:2.0.5"
+  peerDependencies:
+    webpack: 5.x.x
+    webpack-cli: 5.x.x
+  peerDependenciesMeta:
+    webpack-dev-server:
+      optional: true
+  checksum: 75f0e54681796d567a71ac3e2781d2901a8d8cf1cdfc82f261034dddac59a8343e8c3bc5e32b4bb9d6766759ba49fb29a5cd86ef1701d79c506fe886bb63ac75
+  languageName: node
+  linkType: hard
+
+"@xtuc/ieee754@npm:^1.2.0":
+  version: 1.2.0
+  resolution: "@xtuc/ieee754@npm:1.2.0"
+  checksum: ac56d4ca6e17790f1b1677f978c0c6808b1900a5b138885d3da21732f62e30e8f0d9120fcf8f6edfff5100ca902b46f8dd7c1e3f903728634523981e80e2885a
+  languageName: node
+  linkType: hard
+
+"@xtuc/long@npm:4.2.2":
+  version: 4.2.2
+  resolution: "@xtuc/long@npm:4.2.2"
+  checksum: 8ed0d477ce3bc9c6fe2bf6a6a2cc316bb9c4127c5a7827bae947fa8ec34c7092395c5a283cc300c05b5fa01cbbfa1f938f410a7bf75db7c7846fea41949989ec
+  languageName: node
+  linkType: hard
+
+"abab@npm:^2.0.3, abab@npm:^2.0.6":
+  version: 2.0.6
+  resolution: "abab@npm:2.0.6"
+  checksum: 6ffc1af4ff315066c62600123990d87551ceb0aafa01e6539da77b0f5987ac7019466780bf480f1787576d4385e3690c81ccc37cfda12819bf510b8ab47e5a3e
+  languageName: node
+  linkType: hard
+
+"abbrev@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "abbrev@npm:2.0.0"
+  checksum: 0e994ad2aa6575f94670d8a2149afe94465de9cedaaaac364e7fb43a40c3691c980ff74899f682f4ca58fa96b4cbd7421a015d3a6defe43a442117d7821a2f36
+  languageName: node
+  linkType: hard
+
+"acorn-globals@npm:^7.0.0":
+  version: 7.0.1
+  resolution: "acorn-globals@npm:7.0.1"
+  dependencies:
+    acorn: ^8.1.0
+    acorn-walk: ^8.0.2
+  checksum: 2a2998a547af6d0db5f0cdb90acaa7c3cbca6709010e02121fb8b8617c0fbd8bab0b869579903fde358ac78454356a14fadcc1a672ecb97b04b1c2ccba955ce8
+  languageName: node
+  linkType: hard
+
+"acorn-jsx@npm:^5.3.2":
+  version: 5.3.2
+  resolution: "acorn-jsx@npm:5.3.2"
+  peerDependencies:
+    acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+  checksum: c3d3b2a89c9a056b205b69530a37b972b404ee46ec8e5b341666f9513d3163e2a4f214a71f4dfc7370f5a9c07472d2fd1c11c91c3f03d093e37637d95da98950
+  languageName: node
+  linkType: hard
+
+"acorn-walk@npm:^8.0.2":
+  version: 8.3.4
+  resolution: "acorn-walk@npm:8.3.4"
+  dependencies:
+    acorn: ^8.11.0
+  checksum: 4ff03f42323e7cf90f1683e08606b0f460e1e6ac263d2730e3df91c7665b6f64e696db6ea27ee4bed18c2599569be61f28a8399fa170c611161a348c402ca19c
+  languageName: node
+  linkType: hard
+
+"acorn@npm:^8.1.0, acorn@npm:^8.11.0, acorn@npm:^8.11.3, acorn@npm:^8.14.0, acorn@npm:^8.8.1, acorn@npm:^8.8.2, acorn@npm:^8.9.0":
+  version: 8.14.0
+  resolution: "acorn@npm:8.14.0"
+  bin:
+    acorn: bin/acorn
+  checksum: 8755074ba55fff94e84e81c72f1013c2d9c78e973c31231c8ae505a5f966859baf654bddd75046bffd73ce816b149298977fff5077a3033dedba0ae2aad152d4
+  languageName: node
+  linkType: hard
+
+"agent-base@npm:6":
+  version: 6.0.2
+  resolution: "agent-base@npm:6.0.2"
+  dependencies:
+    debug: 4
+  checksum: f52b6872cc96fd5f622071b71ef200e01c7c4c454ee68bc9accca90c98cfb39f2810e3e9aa330435835eedc8c23f4f8a15267f67c6e245d2b33757575bdac49d
+  languageName: node
+  linkType: hard
+
+"agent-base@npm:^7.1.0, agent-base@npm:^7.1.2":
+  version: 7.1.3
+  resolution: "agent-base@npm:7.1.3"
+  checksum: 87bb7ee54f5ecf0ccbfcba0b07473885c43ecd76cb29a8db17d6137a19d9f9cd443a2a7c5fd8a3f24d58ad8145f9eb49116344a66b107e1aeab82cf2383f4753
+  languageName: node
+  linkType: hard
+
+"ajv-formats@npm:^2.1.1":
+  version: 2.1.1
+  resolution: "ajv-formats@npm:2.1.1"
+  dependencies:
+    ajv: ^8.0.0
+  peerDependencies:
+    ajv: ^8.0.0
+  peerDependenciesMeta:
+    ajv:
+      optional: true
+  checksum: 4a287d937f1ebaad4683249a4c40c0fa3beed30d9ddc0adba04859026a622da0d317851316ea64b3680dc60f5c3c708105ddd5d5db8fe595d9d0207fd19f90b7
+  languageName: node
+  linkType: hard
+
+"ajv-keywords@npm:^3.5.2":
+  version: 3.5.2
+  resolution: "ajv-keywords@npm:3.5.2"
+  peerDependencies:
+    ajv: ^6.9.1
+  checksum: 7dc5e5931677a680589050f79dcbe1fefbb8fea38a955af03724229139175b433c63c68f7ae5f86cf8f65d55eb7c25f75a046723e2e58296707617ca690feae9
+  languageName: node
+  linkType: hard
+
+"ajv-keywords@npm:^5.1.0":
+  version: 5.1.0
+  resolution: "ajv-keywords@npm:5.1.0"
+  dependencies:
+    fast-deep-equal: ^3.1.3
+  peerDependencies:
+    ajv: ^8.8.2
+  checksum: c35193940b853119242c6757787f09ecf89a2c19bcd36d03ed1a615e710d19d450cb448bfda407b939aba54b002368c8bff30529cc50a0536a8e10bcce300421
+  languageName: node
+  linkType: hard
+
+"ajv@npm:^6.12.4, ajv@npm:^6.12.5":
+  version: 6.12.6
+  resolution: "ajv@npm:6.12.6"
+  dependencies:
+    fast-deep-equal: ^3.1.1
+    fast-json-stable-stringify: ^2.0.0
+    json-schema-traverse: ^0.4.1
+    uri-js: ^4.2.2
+  checksum: 874972efe5c4202ab0a68379481fbd3d1b5d0a7bd6d3cc21d40d3536ebff3352a2a1fabb632d4fd2cc7fe4cbdcd5ed6782084c9bbf7f32a1536d18f9da5007d4
+  languageName: node
+  linkType: hard
+
+"ajv@npm:^8.0.0, ajv@npm:^8.12.0, ajv@npm:^8.9.0":
+  version: 8.17.1
+  resolution: "ajv@npm:8.17.1"
+  dependencies:
+    fast-deep-equal: ^3.1.3
+    fast-uri: ^3.0.1
+    json-schema-traverse: ^1.0.0
+    require-from-string: ^2.0.2
+  checksum: 1797bf242cfffbaf3b870d13565bd1716b73f214bb7ada9a497063aada210200da36e3ed40237285f3255acc4feeae91b1fb183625331bad27da95973f7253d9
+  languageName: node
+  linkType: hard
+
+"ansi-escapes@npm:^4.2.1":
+  version: 4.3.2
+  resolution: "ansi-escapes@npm:4.3.2"
+  dependencies:
+    type-fest: ^0.21.3
+  checksum: 93111c42189c0a6bed9cdb4d7f2829548e943827ee8479c74d6e0b22ee127b2a21d3f8b5ca57723b8ef78ce011fbfc2784350eb2bde3ccfccf2f575fa8489815
+  languageName: node
+  linkType: hard
+
+"ansi-regex@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "ansi-regex@npm:5.0.1"
+  checksum: 2aa4bb54caf2d622f1afdad09441695af2a83aa3fe8b8afa581d205e57ed4261c183c4d3877cee25794443fde5876417d859c108078ab788d6af7e4fe52eb66b
+  languageName: node
+  linkType: hard
+
+"ansi-regex@npm:^6.0.1":
+  version: 6.1.0
+  resolution: "ansi-regex@npm:6.1.0"
+  checksum: 495834a53b0856c02acd40446f7130cb0f8284f4a39afdab20d5dc42b2e198b1196119fe887beed8f9055c4ff2055e3b2f6d4641d0be018cdfb64fedf6fc1aac
+  languageName: node
+  linkType: hard
+
+"ansi-styles@npm:^3.2.1":
+  version: 3.2.1
+  resolution: "ansi-styles@npm:3.2.1"
+  dependencies:
+    color-convert: ^1.9.0
+  checksum: d85ade01c10e5dd77b6c89f34ed7531da5830d2cb5882c645f330079975b716438cd7ebb81d0d6e6b4f9c577f19ae41ab55f07f19786b02f9dfd9e0377395665
+  languageName: node
+  linkType: hard
+
+"ansi-styles@npm:^4.0.0, ansi-styles@npm:^4.1.0":
+  version: 4.3.0
+  resolution: "ansi-styles@npm:4.3.0"
+  dependencies:
+    color-convert: ^2.0.1
+  checksum: 513b44c3b2105dd14cc42a19271e80f386466c4be574bccf60b627432f9198571ebf4ab1e4c3ba17347658f4ee1711c163d574248c0c1cdc2d5917a0ad582ec4
+  languageName: node
+  linkType: hard
+
+"ansi-styles@npm:^5.0.0":
+  version: 5.2.0
+  resolution: "ansi-styles@npm:5.2.0"
+  checksum: d7f4e97ce0623aea6bc0d90dcd28881ee04cba06c570b97fd3391bd7a268eedfd9d5e2dd4fdcbdd82b8105df5faf6f24aaedc08eaf3da898e702db5948f63469
+  languageName: node
+  linkType: hard
+
+"ansi-styles@npm:^6.1.0":
+  version: 6.2.1
+  resolution: "ansi-styles@npm:6.2.1"
+  checksum: ef940f2f0ced1a6347398da88a91da7930c33ecac3c77b72c5905f8b8fe402c52e6fde304ff5347f616e27a742da3f1dc76de98f6866c69251ad0b07a66776d9
+  languageName: node
+  linkType: hard
+
+"anymatch@npm:^3.0.3":
+  version: 3.1.3
+  resolution: "anymatch@npm:3.1.3"
+  dependencies:
+    normalize-path: ^3.0.0
+    picomatch: ^2.0.4
+  checksum: 3e044fd6d1d26545f235a9fe4d7a534e2029d8e59fa7fd9f2a6eb21230f6b5380ea1eaf55136e60cbf8e613544b3b766e7a6fa2102e2a3a117505466e3025dc2
+  languageName: node
+  linkType: hard
+
+"argparse@npm:^1.0.7":
+  version: 1.0.10
+  resolution: "argparse@npm:1.0.10"
+  dependencies:
+    sprintf-js: ~1.0.2
+  checksum: 7ca6e45583a28de7258e39e13d81e925cfa25d7d4aacbf806a382d3c02fcb13403a07fb8aeef949f10a7cfe4a62da0e2e807b348a5980554cc28ee573ef95945
+  languageName: node
+  linkType: hard
+
+"argparse@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "argparse@npm:2.0.1"
+  checksum: 83644b56493e89a254bae05702abf3a1101b4fa4d0ca31df1c9985275a5a5bd47b3c27b7fa0b71098d41114d8ca000e6ed90cad764b306f8a503665e4d517ced
+  languageName: node
+  linkType: hard
+
+"array-buffer-byte-length@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "array-buffer-byte-length@npm:1.0.1"
+  dependencies:
+    call-bind: ^1.0.5
+    is-array-buffer: ^3.0.4
+  checksum: 53524e08f40867f6a9f35318fafe467c32e45e9c682ba67b11943e167344d2febc0f6977a17e699b05699e805c3e8f073d876f8bbf1b559ed494ad2cd0fae09e
+  languageName: node
+  linkType: hard
+
+"array-union@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "array-union@npm:2.1.0"
+  checksum: 5bee12395cba82da674931df6d0fea23c4aa4660cb3b338ced9f828782a65caa232573e6bf3968f23e0c5eb301764a382cef2f128b170a9dc59de0e36c39f98d
+  languageName: node
+  linkType: hard
+
+"arraybuffer.prototype.slice@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "arraybuffer.prototype.slice@npm:1.0.4"
+  dependencies:
+    array-buffer-byte-length: ^1.0.1
+    call-bind: ^1.0.8
+    define-properties: ^1.2.1
+    es-abstract: ^1.23.5
+    es-errors: ^1.3.0
+    get-intrinsic: ^1.2.6
+    is-array-buffer: ^3.0.4
+  checksum: b1d1fd20be4e972a3779b1569226f6740170dca10f07aa4421d42cefeec61391e79c557cda8e771f5baefe47d878178cd4438f60916ce831813c08132bced765
+  languageName: node
+  linkType: hard
+
+"async@npm:^3.2.3":
+  version: 3.2.6
+  resolution: "async@npm:3.2.6"
+  checksum: ee6eb8cd8a0ab1b58bd2a3ed6c415e93e773573a91d31df9d5ef559baafa9dab37d3b096fa7993e84585cac3697b2af6ddb9086f45d3ac8cae821bb2aab65682
+  languageName: node
+  linkType: hard
+
+"asynckit@npm:^0.4.0":
+  version: 0.4.0
+  resolution: "asynckit@npm:0.4.0"
+  checksum: 7b78c451df768adba04e2d02e63e2d0bf3b07adcd6e42b4cf665cb7ce899bedd344c69a1dcbce355b5f972d597b25aaa1c1742b52cffd9caccb22f348114f6be
+  languageName: node
+  linkType: hard
+
+"available-typed-arrays@npm:^1.0.7":
+  version: 1.0.7
+  resolution: "available-typed-arrays@npm:1.0.7"
+  dependencies:
+    possible-typed-array-names: ^1.0.0
+  checksum: 1aa3ffbfe6578276996de660848b6e95669d9a95ad149e3dd0c0cda77db6ee1dbd9d1dd723b65b6d277b882dd0c4b91a654ae9d3cf9e1254b7e93e4908d78fd3
+  languageName: node
+  linkType: hard
+
+"babel-jest@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "babel-jest@npm:29.7.0"
+  dependencies:
+    "@jest/transform": ^29.7.0
+    "@types/babel__core": ^7.1.14
+    babel-plugin-istanbul: ^6.1.1
+    babel-preset-jest: ^29.6.3
+    chalk: ^4.0.0
+    graceful-fs: ^4.2.9
+    slash: ^3.0.0
+  peerDependencies:
+    "@babel/core": ^7.8.0
+  checksum: ee6f8e0495afee07cac5e4ee167be705c711a8cc8a737e05a587a131fdae2b3c8f9aa55dfd4d9c03009ac2d27f2de63d8ba96d3e8460da4d00e8af19ef9a83f7
+  languageName: node
+  linkType: hard
+
+"babel-plugin-istanbul@npm:^6.1.1":
+  version: 6.1.1
+  resolution: "babel-plugin-istanbul@npm:6.1.1"
+  dependencies:
+    "@babel/helper-plugin-utils": ^7.0.0
+    "@istanbuljs/load-nyc-config": ^1.0.0
+    "@istanbuljs/schema": ^0.1.2
+    istanbul-lib-instrument: ^5.0.4
+    test-exclude: ^6.0.0
+  checksum: cb4fd95738219f232f0aece1116628cccff16db891713c4ccb501cddbbf9272951a5df81f2f2658dfdf4b3e7b236a9d5cbcf04d5d8c07dd5077297339598061a
+  languageName: node
+  linkType: hard
+
+"babel-plugin-jest-hoist@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "babel-plugin-jest-hoist@npm:29.6.3"
+  dependencies:
+    "@babel/template": ^7.3.3
+    "@babel/types": ^7.3.3
+    "@types/babel__core": ^7.1.14
+    "@types/babel__traverse": ^7.0.6
+  checksum: 51250f22815a7318f17214a9d44650ba89551e6d4f47a2dc259128428324b52f5a73979d010cefd921fd5a720d8c1d55ad74ff601cd94c7bd44d5f6292fde2d1
+  languageName: node
+  linkType: hard
+
+"babel-plugin-polyfill-corejs2@npm:^0.4.10":
+  version: 0.4.12
+  resolution: "babel-plugin-polyfill-corejs2@npm:0.4.12"
+  dependencies:
+    "@babel/compat-data": ^7.22.6
+    "@babel/helper-define-polyfill-provider": ^0.6.3
+    semver: ^6.3.1
+  peerDependencies:
+    "@babel/core": ^7.4.0 || ^8.0.0-0 <8.0.0
+  checksum: 6e6e6a8b85fec80a310ded2f5c151385e4ac59118909dd6a952e1025e4a478eb79dda45a5a6322cc2e598fd696eb07d4e2fa52418b4101f3dc370bdf8c8939ba
+  languageName: node
+  linkType: hard
+
+"babel-plugin-polyfill-corejs3@npm:^0.10.6":
+  version: 0.10.6
+  resolution: "babel-plugin-polyfill-corejs3@npm:0.10.6"
+  dependencies:
+    "@babel/helper-define-polyfill-provider": ^0.6.2
+    core-js-compat: ^3.38.0
+  peerDependencies:
+    "@babel/core": ^7.4.0 || ^8.0.0-0 <8.0.0
+  checksum: f762f29f7acca576897c63149c850f0a72babd3fb9ea436a2e36f0c339161c4b912a77828541d8188ce8a91e50965c6687120cf36071eabb1b7aa92f279e2164
+  languageName: node
+  linkType: hard
+
+"babel-plugin-polyfill-regenerator@npm:^0.6.1":
+  version: 0.6.3
+  resolution: "babel-plugin-polyfill-regenerator@npm:0.6.3"
+  dependencies:
+    "@babel/helper-define-polyfill-provider": ^0.6.3
+  peerDependencies:
+    "@babel/core": ^7.4.0 || ^8.0.0-0 <8.0.0
+  checksum: d12696e6b3f280eb78fac551619ca4389262db62c7352cd54bf679d830df8b35596eef2de77cf00db6648eada1c99d49c4f40636dbc9c335a1e5420cfef96750
+  languageName: node
+  linkType: hard
+
+"babel-preset-current-node-syntax@npm:^1.0.0":
+  version: 1.1.0
+  resolution: "babel-preset-current-node-syntax@npm:1.1.0"
+  dependencies:
+    "@babel/plugin-syntax-async-generators": ^7.8.4
+    "@babel/plugin-syntax-bigint": ^7.8.3
+    "@babel/plugin-syntax-class-properties": ^7.12.13
+    "@babel/plugin-syntax-class-static-block": ^7.14.5
+    "@babel/plugin-syntax-import-attributes": ^7.24.7
+    "@babel/plugin-syntax-import-meta": ^7.10.4
+    "@babel/plugin-syntax-json-strings": ^7.8.3
+    "@babel/plugin-syntax-logical-assignment-operators": ^7.10.4
+    "@babel/plugin-syntax-nullish-coalescing-operator": ^7.8.3
+    "@babel/plugin-syntax-numeric-separator": ^7.10.4
+    "@babel/plugin-syntax-object-rest-spread": ^7.8.3
+    "@babel/plugin-syntax-optional-catch-binding": ^7.8.3
+    "@babel/plugin-syntax-optional-chaining": ^7.8.3
+    "@babel/plugin-syntax-private-property-in-object": ^7.14.5
+    "@babel/plugin-syntax-top-level-await": ^7.14.5
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: 9f93fac975eaba296c436feeca1031ca0539143c4066eaf5d1ba23525a31850f03b651a1049caea7287df837a409588c8252c15627ad3903f17864c8e25ed64b
+  languageName: node
+  linkType: hard
+
+"babel-preset-jest@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "babel-preset-jest@npm:29.6.3"
+  dependencies:
+    babel-plugin-jest-hoist: ^29.6.3
+    babel-preset-current-node-syntax: ^1.0.0
+  peerDependencies:
+    "@babel/core": ^7.0.0
+  checksum: aa4ff2a8a728d9d698ed521e3461a109a1e66202b13d3494e41eea30729a5e7cc03b3a2d56c594423a135429c37bf63a9fa8b0b9ce275298be3095a88c69f6fb
+  languageName: node
+  linkType: hard
+
+"backbone@npm:1.4.0":
+  version: 1.4.0
+  resolution: "backbone@npm:1.4.0"
+  dependencies:
+    underscore: ">=1.8.3"
+  checksum: 09abdf184c485a4cd2c68218298cf772fbefeaa166ef8eb795cdb0159b4ad1d2f6823dde089352eaf0be929e5bbef67c57555722f4d1886f969d954f77814870
+  languageName: node
+  linkType: hard
+
+"balanced-match@npm:^1.0.0":
+  version: 1.0.2
+  resolution: "balanced-match@npm:1.0.2"
+  checksum: 9706c088a283058a8a99e0bf91b0a2f75497f185980d9ffa8b304de1d9e58ebda7c72c07ebf01dadedaac5b2907b2c6f566f660d62bd336c3468e960403b9d65
+  languageName: node
+  linkType: hard
+
+"base64-js@npm:^1.2.1":
+  version: 1.5.1
+  resolution: "base64-js@npm:1.5.1"
+  checksum: 669632eb3745404c2f822a18fc3a0122d2f9a7a13f7fb8b5823ee19d1d2ff9ee5b52c53367176ea4ad093c332fd5ab4bd0ebae5a8e27917a4105a4cfc86b1005
+  languageName: node
+  linkType: hard
+
+"big.js@npm:^5.2.2":
+  version: 5.2.2
+  resolution: "big.js@npm:5.2.2"
+  checksum: b89b6e8419b097a8fb4ed2399a1931a68c612bce3cfd5ca8c214b2d017531191070f990598de2fc6f3f993d91c0f08aa82697717f6b3b8732c9731866d233c9e
+  languageName: node
+  linkType: hard
+
+"brace-expansion@npm:^1.1.7":
+  version: 1.1.11
+  resolution: "brace-expansion@npm:1.1.11"
+  dependencies:
+    balanced-match: ^1.0.0
+    concat-map: 0.0.1
+  checksum: faf34a7bb0c3fcf4b59c7808bc5d2a96a40988addf2e7e09dfbb67a2251800e0d14cd2bfc1aa79174f2f5095c54ff27f46fb1289fe2d77dac755b5eb3434cc07
+  languageName: node
+  linkType: hard
+
+"brace-expansion@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "brace-expansion@npm:2.0.1"
+  dependencies:
+    balanced-match: ^1.0.0
+  checksum: a61e7cd2e8a8505e9f0036b3b6108ba5e926b4b55089eeb5550cd04a471fe216c96d4fe7e4c7f995c728c554ae20ddfc4244cad10aef255e72b62930afd233d1
+  languageName: node
+  linkType: hard
+
+"braces@npm:^3.0.3":
+  version: 3.0.3
+  resolution: "braces@npm:3.0.3"
+  dependencies:
+    fill-range: ^7.1.1
+  checksum: b95aa0b3bd909f6cd1720ffcf031aeaf46154dd88b4da01f9a1d3f7ea866a79eba76a6d01cbc3c422b2ee5cdc39a4f02491058d5df0d7bf6e6a162a832df1f69
+  languageName: node
+  linkType: hard
+
+"browserslist@npm:^4.24.0, browserslist@npm:^4.24.2":
+  version: 4.24.3
+  resolution: "browserslist@npm:4.24.3"
+  dependencies:
+    caniuse-lite: ^1.0.30001688
+    electron-to-chromium: ^1.5.73
+    node-releases: ^2.0.19
+    update-browserslist-db: ^1.1.1
+  bin:
+    browserslist: cli.js
+  checksum: 016efc9953350e3a7212edcfdd72210cb33b339c1a974a77c0715eb67d23d7e5cd0a073ce1c801ab09235d8c213425ca51b92d41bbb829b833872b45f885fe7c
+  languageName: node
+  linkType: hard
+
+"bs-logger@npm:^0.2.6":
+  version: 0.2.6
+  resolution: "bs-logger@npm:0.2.6"
+  dependencies:
+    fast-json-stable-stringify: 2.x
+  checksum: d34bdaf68c64bd099ab97c3ea608c9ae7d3f5faa1178b3f3f345acd94e852e608b2d4f9103fb2e503f5e69780e98293df41691b84be909b41cf5045374d54606
+  languageName: node
+  linkType: hard
+
+"bser@npm:2.1.1":
+  version: 2.1.1
+  resolution: "bser@npm:2.1.1"
+  dependencies:
+    node-int64: ^0.4.0
+  checksum: 9ba4dc58ce86300c862bffc3ae91f00b2a03b01ee07f3564beeeaf82aa243b8b03ba53f123b0b842c190d4399b94697970c8e7cf7b1ea44b61aa28c3526a4449
+  languageName: node
+  linkType: hard
+
+"buffer-from@npm:^1.0.0":
+  version: 1.1.2
+  resolution: "buffer-from@npm:1.1.2"
+  checksum: 0448524a562b37d4d7ed9efd91685a5b77a50672c556ea254ac9a6d30e3403a517d8981f10e565db24e8339413b43c97ca2951f10e399c6125a0d8911f5679bb
+  languageName: node
+  linkType: hard
+
+"cacache@npm:^19.0.1":
+  version: 19.0.1
+  resolution: "cacache@npm:19.0.1"
+  dependencies:
+    "@npmcli/fs": ^4.0.0
+    fs-minipass: ^3.0.0
+    glob: ^10.2.2
+    lru-cache: ^10.0.1
+    minipass: ^7.0.3
+    minipass-collect: ^2.0.1
+    minipass-flush: ^1.0.5
+    minipass-pipeline: ^1.2.4
+    p-map: ^7.0.2
+    ssri: ^12.0.0
+    tar: ^7.4.3
+    unique-filename: ^4.0.0
+  checksum: e95684717de6881b4cdaa949fa7574e3171946421cd8291769dd3d2417dbf7abf4aa557d1f968cca83dcbc95bed2a281072b09abfc977c942413146ef7ed4525
+  languageName: node
+  linkType: hard
+
+"call-bind-apply-helpers@npm:^1.0.0, call-bind-apply-helpers@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "call-bind-apply-helpers@npm:1.0.1"
+  dependencies:
+    es-errors: ^1.3.0
+    function-bind: ^1.1.2
+  checksum: 3c55343261bb387c58a4762d15ad9d42053659a62681ec5eb50690c6b52a4a666302a01d557133ce6533e8bd04530ee3b209f23dd06c9577a1925556f8fcccdf
+  languageName: node
+  linkType: hard
+
+"call-bind@npm:^1.0.5, call-bind@npm:^1.0.6, call-bind@npm:^1.0.7, call-bind@npm:^1.0.8":
+  version: 1.0.8
+  resolution: "call-bind@npm:1.0.8"
+  dependencies:
+    call-bind-apply-helpers: ^1.0.0
+    es-define-property: ^1.0.0
+    get-intrinsic: ^1.2.4
+    set-function-length: ^1.2.2
+  checksum: aa2899bce917a5392fd73bd32e71799c37c0b7ab454e0ed13af7f6727549091182aade8bbb7b55f304a5bc436d543241c14090fb8a3137e9875e23f444f4f5a9
+  languageName: node
+  linkType: hard
+
+"call-bound@npm:^1.0.2, call-bound@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "call-bound@npm:1.0.3"
+  dependencies:
+    call-bind-apply-helpers: ^1.0.1
+    get-intrinsic: ^1.2.6
+  checksum: a93bbe0f2d0a2d6c144a4349ccd0593d5d0d5d9309b69101710644af8964286420062f2cc3114dca120b9bc8cc07507952d4b1b3ea7672e0d7f6f1675efedb32
+  languageName: node
+  linkType: hard
+
+"callsites@npm:^3.0.0":
+  version: 3.1.0
+  resolution: "callsites@npm:3.1.0"
+  checksum: 072d17b6abb459c2ba96598918b55868af677154bec7e73d222ef95a8fdb9bbf7dae96a8421085cdad8cd190d86653b5b6dc55a4484f2e5b2e27d5e0c3fc15b3
+  languageName: node
+  linkType: hard
+
+"camelcase@npm:^5.3.1":
+  version: 5.3.1
+  resolution: "camelcase@npm:5.3.1"
+  checksum: e6effce26b9404e3c0f301498184f243811c30dfe6d0b9051863bd8e4034d09c8c2923794f280d6827e5aa055f6c434115ff97864a16a963366fb35fd673024b
+  languageName: node
+  linkType: hard
+
+"camelcase@npm:^6.2.0":
+  version: 6.3.0
+  resolution: "camelcase@npm:6.3.0"
+  checksum: 8c96818a9076434998511251dcb2761a94817ea17dbdc37f47ac080bd088fc62c7369429a19e2178b993497132c8cbcf5cc1f44ba963e76782ba469c0474938d
+  languageName: node
+  linkType: hard
+
+"caniuse-lite@npm:^1.0.30001688":
+  version: 1.0.30001689
+  resolution: "caniuse-lite@npm:1.0.30001689"
+  checksum: 8d4152076517ac1dfd6d6733ecc8055f3cd3a8b679af8f5858e731312f03967f6a2184553636696e44cee39abdd9ccccc914716235791b0c25f68ef8dea4e24a
+  languageName: node
+  linkType: hard
+
+"chalk@npm:^2.3.0, chalk@npm:^2.4.1":
+  version: 2.4.2
+  resolution: "chalk@npm:2.4.2"
+  dependencies:
+    ansi-styles: ^3.2.1
+    escape-string-regexp: ^1.0.5
+    supports-color: ^5.3.0
+  checksum: ec3661d38fe77f681200f878edbd9448821924e0f93a9cefc0e26a33b145f1027a2084bf19967160d11e1f03bfe4eaffcabf5493b89098b2782c3fe0b03d80c2
+  languageName: node
+  linkType: hard
+
+"chalk@npm:^4.0.0, chalk@npm:^4.0.2, chalk@npm:^4.1.0":
+  version: 4.1.2
+  resolution: "chalk@npm:4.1.2"
+  dependencies:
+    ansi-styles: ^4.1.0
+    supports-color: ^7.1.0
+  checksum: fe75c9d5c76a7a98d45495b91b2172fa3b7a09e0cc9370e5c8feb1c567b85c4288e2b3fded7cfdd7359ac28d6b3844feb8b82b8686842e93d23c827c417e83fc
+  languageName: node
+  linkType: hard
+
+"char-regex@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "char-regex@npm:1.0.2"
+  checksum: b563e4b6039b15213114626621e7a3d12f31008bdce20f9c741d69987f62aeaace7ec30f6018890ad77b2e9b4d95324c9f5acfca58a9441e3b1dcdd1e2525d17
+  languageName: node
+  linkType: hard
+
+"chownr@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "chownr@npm:3.0.0"
+  checksum: fd73a4bab48b79e66903fe1cafbdc208956f41ea4f856df883d0c7277b7ab29fd33ee65f93b2ec9192fc0169238f2f8307b7735d27c155821d886b84aa97aa8d
+  languageName: node
+  linkType: hard
+
+"chrome-trace-event@npm:^1.0.2":
+  version: 1.0.4
+  resolution: "chrome-trace-event@npm:1.0.4"
+  checksum: fcbbd9dd0cd5b48444319007cc0c15870fd8612cc0df320908aa9d5e8a244084d48571eb28bf3c58c19327d2c5838f354c2d89fac3956d8e992273437401ac19
+  languageName: node
+  linkType: hard
+
+"ci-info@npm:^3.2.0":
+  version: 3.9.0
+  resolution: "ci-info@npm:3.9.0"
+  checksum: 6b19dc9b2966d1f8c2041a838217299718f15d6c4b63ae36e4674edd2bee48f780e94761286a56aa59eb305a85fbea4ddffb7630ec063e7ec7e7e5ad42549a87
+  languageName: node
+  linkType: hard
+
+"cjs-module-lexer@npm:^1.0.0":
+  version: 1.4.1
+  resolution: "cjs-module-lexer@npm:1.4.1"
+  checksum: 2556807a99aec1f9daac60741af96cd613a707f343174ae7967da46402c91dced411bf830d209f2e93be4cecea46fc75cecf1f17c799d7d8a9e1dd6204bfcd22
+  languageName: node
+  linkType: hard
+
+"cliui@npm:^8.0.1":
+  version: 8.0.1
+  resolution: "cliui@npm:8.0.1"
+  dependencies:
+    string-width: ^4.2.0
+    strip-ansi: ^6.0.1
+    wrap-ansi: ^7.0.0
+  checksum: 79648b3b0045f2e285b76fb2e24e207c6db44323581e421c3acbd0e86454cba1b37aea976ab50195a49e7384b871e6dfb2247ad7dec53c02454ac6497394cb56
+  languageName: node
+  linkType: hard
+
+"clone-deep@npm:^4.0.1":
+  version: 4.0.1
+  resolution: "clone-deep@npm:4.0.1"
+  dependencies:
+    is-plain-object: ^2.0.4
+    kind-of: ^6.0.2
+    shallow-clone: ^3.0.0
+  checksum: 770f912fe4e6f21873c8e8fbb1e99134db3b93da32df271d00589ea4a29dbe83a9808a322c93f3bcaf8584b8b4fa6fc269fc8032efbaa6728e0c9886c74467d2
+  languageName: node
+  linkType: hard
+
+"co@npm:^4.6.0":
+  version: 4.6.0
+  resolution: "co@npm:4.6.0"
+  checksum: 5210d9223010eb95b29df06a91116f2cf7c8e0748a9013ed853b53f362ea0e822f1e5bb054fb3cefc645239a4cf966af1f6133a3b43f40d591f3b68ed6cf0510
+  languageName: node
+  linkType: hard
+
+"collect-v8-coverage@npm:^1.0.0":
+  version: 1.0.2
+  resolution: "collect-v8-coverage@npm:1.0.2"
+  checksum: c10f41c39ab84629d16f9f6137bc8a63d332244383fc368caf2d2052b5e04c20cd1fd70f66fcf4e2422b84c8226598b776d39d5f2d2a51867cc1ed5d1982b4da
+  languageName: node
+  linkType: hard
+
+"color-convert@npm:^1.9.0":
+  version: 1.9.3
+  resolution: "color-convert@npm:1.9.3"
+  dependencies:
+    color-name: 1.1.3
+  checksum: fd7a64a17cde98fb923b1dd05c5f2e6f7aefda1b60d67e8d449f9328b4e53b228a428fd38bfeaeb2db2ff6b6503a776a996150b80cdf224062af08a5c8a3a203
+  languageName: node
+  linkType: hard
+
+"color-convert@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "color-convert@npm:2.0.1"
+  dependencies:
+    color-name: ~1.1.4
+  checksum: 79e6bdb9fd479a205c71d89574fccfb22bd9053bd98c6c4d870d65c132e5e904e6034978e55b43d69fcaa7433af2016ee203ce76eeba9cfa554b373e7f7db336
+  languageName: node
+  linkType: hard
+
+"color-name@npm:1.1.3":
+  version: 1.1.3
+  resolution: "color-name@npm:1.1.3"
+  checksum: 09c5d3e33d2105850153b14466501f2bfb30324a2f76568a408763a3b7433b0e50e5b4ab1947868e65cb101bb7cb75029553f2c333b6d4b8138a73fcc133d69d
+  languageName: node
+  linkType: hard
+
+"color-name@npm:~1.1.4":
+  version: 1.1.4
+  resolution: "color-name@npm:1.1.4"
+  checksum: b0445859521eb4021cd0fb0cc1a75cecf67fceecae89b63f62b201cca8d345baf8b952c966862a9d9a2632987d4f6581f0ec8d957dfacece86f0a7919316f610
+  languageName: node
+  linkType: hard
+
+"colorette@npm:^2.0.14":
+  version: 2.0.20
+  resolution: "colorette@npm:2.0.20"
+  checksum: 0c016fea2b91b733eb9f4bcdb580018f52c0bc0979443dad930e5037a968237ac53d9beb98e218d2e9235834f8eebce7f8e080422d6194e957454255bde71d3d
+  languageName: node
+  linkType: hard
+
+"combined-stream@npm:^1.0.8":
+  version: 1.0.8
+  resolution: "combined-stream@npm:1.0.8"
+  dependencies:
+    delayed-stream: ~1.0.0
+  checksum: 49fa4aeb4916567e33ea81d088f6584749fc90c7abec76fd516bf1c5aa5c79f3584b5ba3de6b86d26ddd64bae5329c4c7479343250cfe71c75bb366eae53bb7c
+  languageName: node
+  linkType: hard
+
+"commander@npm:^10.0.1":
+  version: 10.0.1
+  resolution: "commander@npm:10.0.1"
+  checksum: 436901d64a818295803c1996cd856621a74f30b9f9e28a588e726b2b1670665bccd7c1a77007ebf328729f0139838a88a19265858a0fa7a8728c4656796db948
+  languageName: node
+  linkType: hard
+
+"commander@npm:^2.20.0":
+  version: 2.20.3
+  resolution: "commander@npm:2.20.3"
+  checksum: ab8c07884e42c3a8dbc5dd9592c606176c7eb5c1ca5ff274bcf907039b2c41de3626f684ea75ccf4d361ba004bbaff1f577d5384c155f3871e456bdf27becf9e
+  languageName: node
+  linkType: hard
+
+"commander@npm:^9.4.1":
+  version: 9.5.0
+  resolution: "commander@npm:9.5.0"
+  checksum: c7a3e27aa59e913b54a1bafd366b88650bc41d6651f0cbe258d4ff09d43d6a7394232a4dadd0bf518b3e696fdf595db1028a0d82c785b88bd61f8a440cecfade
+  languageName: node
+  linkType: hard
+
+"compute-gcd@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "compute-gcd@npm:1.2.1"
+  dependencies:
+    validate.io-array: ^1.0.3
+    validate.io-function: ^1.0.2
+    validate.io-integer-array: ^1.0.0
+  checksum: 51cf33b75f7c8db5142fcb99a9d84a40260993fed8e02a7ab443834186c3ab99b3fd20b30ad9075a6a9d959d69df6da74dd3be8a59c78d9f2fe780ebda8242e1
+  languageName: node
+  linkType: hard
+
+"compute-lcm@npm:^1.1.2":
+  version: 1.1.2
+  resolution: "compute-lcm@npm:1.1.2"
+  dependencies:
+    compute-gcd: ^1.2.1
+    validate.io-array: ^1.0.3
+    validate.io-function: ^1.0.2
+    validate.io-integer-array: ^1.0.0
+  checksum: d499ab57dcb48e8d0fd233b99844a06d1cc56115602c920c586e998ebba60293731f5b6976e8a1e83ae6cbfe86716f62d9432e8d94913fed8bd8352f447dc917
+  languageName: node
+  linkType: hard
+
+"concat-map@npm:0.0.1":
+  version: 0.0.1
+  resolution: "concat-map@npm:0.0.1"
+  checksum: 902a9f5d8967a3e2faf138d5cb784b9979bad2e6db5357c5b21c568df4ebe62bcb15108af1b2253744844eb964fc023fbd9afbbbb6ddd0bcc204c6fb5b7bf3af
+  languageName: node
+  linkType: hard
+
+"convert-source-map@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "convert-source-map@npm:2.0.0"
+  checksum: 63ae9933be5a2b8d4509daca5124e20c14d023c820258e484e32dc324d34c2754e71297c94a05784064ad27615037ef677e3f0c00469fb55f409d2bb21261035
+  languageName: node
+  linkType: hard
+
+"core-js-compat@npm:^3.38.0, core-js-compat@npm:^3.38.1":
+  version: 3.39.0
+  resolution: "core-js-compat@npm:3.39.0"
+  dependencies:
+    browserslist: ^4.24.2
+  checksum: 2d7d087c3271d711d03a55203d4756f6288317a1ce35cdc8bafaf1833ef21fd67a92a50cff8dcf7df1325ac63720906ab3cf514c85b238c95f65fca1040f6ad6
+  languageName: node
+  linkType: hard
+
+"create-jest@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "create-jest@npm:29.7.0"
+  dependencies:
+    "@jest/types": ^29.6.3
+    chalk: ^4.0.0
+    exit: ^0.1.2
+    graceful-fs: ^4.2.9
+    jest-config: ^29.7.0
+    jest-util: ^29.7.0
+    prompts: ^2.0.1
+  bin:
+    create-jest: bin/create-jest.js
+  checksum: 1427d49458adcd88547ef6fa39041e1fe9033a661293aa8d2c3aa1b4967cb5bf4f0c00436c7a61816558f28ba2ba81a94d5c962e8022ea9a883978fc8e1f2945
+  languageName: node
+  linkType: hard
+
+"cross-spawn@npm:^6.0.5":
+  version: 6.0.6
+  resolution: "cross-spawn@npm:6.0.6"
+  dependencies:
+    nice-try: ^1.0.4
+    path-key: ^2.0.1
+    semver: ^5.5.0
+    shebang-command: ^1.2.0
+    which: ^1.2.9
+  checksum: a6e2e5b04a0e0f806c1df45f92cd079b65f95fbe5a7650ee1ab60318c33a6c156a8a2f8b6898f57764f7363ec599a0625e9855dfa78d52d2d73dbd32eb11c25e
+  languageName: node
+  linkType: hard
+
+"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.3":
+  version: 7.0.6
+  resolution: "cross-spawn@npm:7.0.6"
+  dependencies:
+    path-key: ^3.1.0
+    shebang-command: ^2.0.0
+    which: ^2.0.1
+  checksum: 8d306efacaf6f3f60e0224c287664093fa9185680b2d195852ba9a863f85d02dcc737094c6e512175f8ee0161f9b87c73c6826034c2422e39de7d6569cf4503b
+  languageName: node
+  linkType: hard
+
+"css-loader@npm:^6.7.1, css-loader@npm:^6.9.1":
+  version: 6.11.0
+  resolution: "css-loader@npm:6.11.0"
+  dependencies:
+    icss-utils: ^5.1.0
+    postcss: ^8.4.33
+    postcss-modules-extract-imports: ^3.1.0
+    postcss-modules-local-by-default: ^4.0.5
+    postcss-modules-scope: ^3.2.0
+    postcss-modules-values: ^4.0.0
+    postcss-value-parser: ^4.2.0
+    semver: ^7.5.4
+  peerDependencies:
+    "@rspack/core": 0.x || 1.x
+    webpack: ^5.0.0
+  peerDependenciesMeta:
+    "@rspack/core":
+      optional: true
+    webpack:
+      optional: true
+  checksum: 5c8d35975a7121334905394e88e28f05df72f037dbed2fb8fec4be5f0b313ae73a13894ba791867d4a4190c35896da84a7fd0c54fb426db55d85ba5e714edbe3
+  languageName: node
+  linkType: hard
+
+"cssesc@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "cssesc@npm:3.0.0"
+  bin:
+    cssesc: bin/cssesc
+  checksum: f8c4ababffbc5e2ddf2fa9957dda1ee4af6048e22aeda1869d0d00843223c1b13ad3f5d88b51caa46c994225eacb636b764eb807a8883e2fb6f99b4f4e8c48b2
+  languageName: node
+  linkType: hard
+
+"cssom@npm:^0.5.0":
+  version: 0.5.0
+  resolution: "cssom@npm:0.5.0"
+  checksum: 823471aa30091c59e0a305927c30e7768939b6af70405808f8d2ce1ca778cddcb24722717392438329d1691f9a87cb0183b64b8d779b56a961546d54854fde01
+  languageName: node
+  linkType: hard
+
+"cssom@npm:~0.3.6":
+  version: 0.3.8
+  resolution: "cssom@npm:0.3.8"
+  checksum: 24beb3087c76c0d52dd458be9ee1fbc80ac771478a9baef35dd258cdeb527c68eb43204dd439692bb2b1ae5272fa5f2946d10946edab0d04f1078f85e06bc7f6
+  languageName: node
+  linkType: hard
+
+"cssstyle@npm:^2.3.0":
+  version: 2.3.0
+  resolution: "cssstyle@npm:2.3.0"
+  dependencies:
+    cssom: ~0.3.6
+  checksum: 5f05e6fd2e3df0b44695c2f08b9ef38b011862b274e320665176467c0725e44a53e341bc4959a41176e83b66064ab786262e7380fd1cabeae6efee0d255bb4e3
+  languageName: node
+  linkType: hard
+
+"data-urls@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "data-urls@npm:2.0.0"
+  dependencies:
+    abab: ^2.0.3
+    whatwg-mimetype: ^2.3.0
+    whatwg-url: ^8.0.0
+  checksum: 97caf828aac25e25e04ba6869db0f99c75e6859bb5b424ada28d3e7841941ebf08ddff3c1b1bb4585986bd507a5d54c2a716853ea6cb98af877400e637393e71
+  languageName: node
+  linkType: hard
+
+"data-urls@npm:^3.0.2":
+  version: 3.0.2
+  resolution: "data-urls@npm:3.0.2"
+  dependencies:
+    abab: ^2.0.6
+    whatwg-mimetype: ^3.0.0
+    whatwg-url: ^11.0.0
+  checksum: 033fc3dd0fba6d24bc9a024ddcf9923691dd24f90a3d26f6545d6a2f71ec6956f93462f2cdf2183cc46f10dc01ed3bcb36731a8208456eb1a08147e571fe2a76
+  languageName: node
+  linkType: hard
+
+"data-view-buffer@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "data-view-buffer@npm:1.0.1"
+  dependencies:
+    call-bind: ^1.0.6
+    es-errors: ^1.3.0
+    is-data-view: ^1.0.1
+  checksum: ce24348f3c6231223b216da92e7e6a57a12b4af81a23f27eff8feabdf06acfb16c00639c8b705ca4d167f761cfc756e27e5f065d0a1f840c10b907fdaf8b988c
+  languageName: node
+  linkType: hard
+
+"data-view-byte-length@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "data-view-byte-length@npm:1.0.1"
+  dependencies:
+    call-bind: ^1.0.7
+    es-errors: ^1.3.0
+    is-data-view: ^1.0.1
+  checksum: dbb3200edcb7c1ef0d68979834f81d64fd8cab2f7691b3a4c6b97e67f22182f3ec2c8602efd7b76997b55af6ff8bce485829c1feda4fa2165a6b71fb7baa4269
+  languageName: node
+  linkType: hard
+
+"data-view-byte-offset@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "data-view-byte-offset@npm:1.0.0"
+  dependencies:
+    call-bind: ^1.0.6
+    es-errors: ^1.3.0
+    is-data-view: ^1.0.1
+  checksum: 7f0bf8720b7414ca719eedf1846aeec392f2054d7af707c5dc9a753cc77eb8625f067fa901e0b5127e831f9da9056138d894b9c2be79c27a21f6db5824f009c2
+  languageName: node
+  linkType: hard
+
+"debug@npm:4, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.4":
+  version: 4.4.0
+  resolution: "debug@npm:4.4.0"
+  dependencies:
+    ms: ^2.1.3
+  peerDependenciesMeta:
+    supports-color:
+      optional: true
+  checksum: fb42df878dd0e22816fc56e1fdca9da73caa85212fbe40c868b1295a6878f9101ae684f4eeef516c13acfc700f5ea07f1136954f43d4cd2d477a811144136479
+  languageName: node
+  linkType: hard
+
+"decimal.js@npm:^10.4.2":
+  version: 10.4.3
+  resolution: "decimal.js@npm:10.4.3"
+  checksum: 796404dcfa9d1dbfdc48870229d57f788b48c21c603c3f6554a1c17c10195fc1024de338b0cf9e1efe0c7c167eeb18f04548979bcc5fdfabebb7cc0ae3287bae
+  languageName: node
+  linkType: hard
+
+"dedent@npm:^1.0.0":
+  version: 1.5.3
+  resolution: "dedent@npm:1.5.3"
+  peerDependencies:
+    babel-plugin-macros: ^3.1.0
+  peerDependenciesMeta:
+    babel-plugin-macros:
+      optional: true
+  checksum: 045b595557b2a8ea2eb9b0b4623d764e9a87326486fe2b61191b4342ed93dc01245644d8a09f3108a50c0ee7965f1eedd92e4a3a503ed89ea8e810566ea27f9a
+  languageName: node
+  linkType: hard
+
+"deep-is@npm:^0.1.3":
+  version: 0.1.4
+  resolution: "deep-is@npm:0.1.4"
+  checksum: edb65dd0d7d1b9c40b2f50219aef30e116cedd6fc79290e740972c132c09106d2e80aa0bc8826673dd5a00222d4179c84b36a790eef63a4c4bca75a37ef90804
+  languageName: node
+  linkType: hard
+
+"deepmerge@npm:^4.2.2":
+  version: 4.3.1
+  resolution: "deepmerge@npm:4.3.1"
+  checksum: 2024c6a980a1b7128084170c4cf56b0fd58a63f2da1660dcfe977415f27b17dbe5888668b59d0b063753f3220719d5e400b7f113609489c90160bb9a5518d052
+  languageName: node
+  linkType: hard
+
+"define-data-property@npm:^1.0.1, define-data-property@npm:^1.1.4":
+  version: 1.1.4
+  resolution: "define-data-property@npm:1.1.4"
+  dependencies:
+    es-define-property: ^1.0.0
+    es-errors: ^1.3.0
+    gopd: ^1.0.1
+  checksum: 8068ee6cab694d409ac25936eb861eea704b7763f7f342adbdfe337fc27c78d7ae0eff2364b2917b58c508d723c7a074326d068eef2e45c4edcd85cf94d0313b
+  languageName: node
+  linkType: hard
+
+"define-properties@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "define-properties@npm:1.2.1"
+  dependencies:
+    define-data-property: ^1.0.1
+    has-property-descriptors: ^1.0.0
+    object-keys: ^1.1.1
+  checksum: b4ccd00597dd46cb2d4a379398f5b19fca84a16f3374e2249201992f36b30f6835949a9429669ee6b41b6e837205a163eadd745e472069e70dfc10f03e5fcc12
+  languageName: node
+  linkType: hard
+
+"delayed-stream@npm:~1.0.0":
+  version: 1.0.0
+  resolution: "delayed-stream@npm:1.0.0"
+  checksum: 46fe6e83e2cb1d85ba50bd52803c68be9bd953282fa7096f51fc29edd5d67ff84ff753c51966061e5ba7cb5e47ef6d36a91924eddb7f3f3483b1c560f77a0020
+  languageName: node
+  linkType: hard
+
+"detect-newline@npm:^3.0.0":
+  version: 3.1.0
+  resolution: "detect-newline@npm:3.1.0"
+  checksum: ae6cd429c41ad01b164c59ea36f264a2c479598e61cba7c99da24175a7ab80ddf066420f2bec9a1c57a6bead411b4655ff15ad7d281c000a89791f48cbe939e7
+  languageName: node
+  linkType: hard
+
+"diff-sequences@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "diff-sequences@npm:29.6.3"
+  checksum: f4914158e1f2276343d98ff5b31fc004e7304f5470bf0f1adb2ac6955d85a531a6458d33e87667f98f6ae52ebd3891bb47d420bb48a5bd8b7a27ee25b20e33aa
+  languageName: node
+  linkType: hard
+
+"dir-glob@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "dir-glob@npm:3.0.1"
+  dependencies:
+    path-type: ^4.0.0
+  checksum: fa05e18324510d7283f55862f3161c6759a3f2f8dbce491a2fc14c8324c498286c54282c1f0e933cb930da8419b30679389499b919122952a4f8592362ef4615
+  languageName: node
+  linkType: hard
+
+"doctrine@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "doctrine@npm:3.0.0"
+  dependencies:
+    esutils: ^2.0.2
+  checksum: fd7673ca77fe26cd5cba38d816bc72d641f500f1f9b25b83e8ce28827fe2da7ad583a8da26ab6af85f834138cf8dae9f69b0cd6ab925f52ddab1754db44d99ce
+  languageName: node
+  linkType: hard
+
+"dom-serializer@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "dom-serializer@npm:2.0.0"
+  dependencies:
+    domelementtype: ^2.3.0
+    domhandler: ^5.0.2
+    entities: ^4.2.0
+  checksum: cd1810544fd8cdfbd51fa2c0c1128ec3a13ba92f14e61b7650b5de421b88205fd2e3f0cc6ace82f13334114addb90ed1c2f23074a51770a8e9c1273acbc7f3e6
+  languageName: node
+  linkType: hard
+
+"domelementtype@npm:^2.3.0":
+  version: 2.3.0
+  resolution: "domelementtype@npm:2.3.0"
+  checksum: ee837a318ff702622f383409d1f5b25dd1024b692ef64d3096ff702e26339f8e345820f29a68bcdcea8cfee3531776b3382651232fbeae95612d6f0a75efb4f6
+  languageName: node
+  linkType: hard
+
+"domexception@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "domexception@npm:4.0.0"
+  dependencies:
+    webidl-conversions: ^7.0.0
+  checksum: ddbc1268edf33a8ba02ccc596735ede80375ee0cf124b30d2f05df5b464ba78ef4f49889b6391df4a04954e63d42d5631c7fcf8b1c4f12bc531252977a5f13d5
+  languageName: node
+  linkType: hard
+
+"domhandler@npm:^5.0.2, domhandler@npm:^5.0.3":
+  version: 5.0.3
+  resolution: "domhandler@npm:5.0.3"
+  dependencies:
+    domelementtype: ^2.3.0
+  checksum: 0f58f4a6af63e6f3a4320aa446d28b5790a009018707bce2859dcb1d21144c7876482b5188395a188dfa974238c019e0a1e610d2fc269a12b2c192ea2b0b131c
+  languageName: node
+  linkType: hard
+
+"domutils@npm:^3.0.1":
+  version: 3.1.0
+  resolution: "domutils@npm:3.1.0"
+  dependencies:
+    dom-serializer: ^2.0.0
+    domelementtype: ^2.3.0
+    domhandler: ^5.0.3
+  checksum: e5757456ddd173caa411cfc02c2bb64133c65546d2c4081381a3bafc8a57411a41eed70494551aa58030be9e58574fcc489828bebd673863d39924fb4878f416
+  languageName: node
+  linkType: hard
+
+"dunder-proto@npm:^1.0.0, dunder-proto@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "dunder-proto@npm:1.0.1"
+  dependencies:
+    call-bind-apply-helpers: ^1.0.1
+    es-errors: ^1.3.0
+    gopd: ^1.2.0
+  checksum: 149207e36f07bd4941921b0ca929e3a28f1da7bd6b6ff8ff7f4e2f2e460675af4576eeba359c635723dc189b64cdd4787e0255897d5b135ccc5d15cb8685fc90
+  languageName: node
+  linkType: hard
+
+"duplicate-package-checker-webpack-plugin@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "duplicate-package-checker-webpack-plugin@npm:3.0.0"
+  dependencies:
+    chalk: ^2.3.0
+    find-root: ^1.0.0
+    lodash: ^4.17.4
+    semver: ^5.4.1
+  checksum: d77be45cb72d79a429c64d8f8f7603fea681d182fb795459a3d4afa608faad9a923378a7e80c6855f465263e1983140b6fc3682bd0213228b8cd7906ab4b934d
+  languageName: node
+  linkType: hard
+
+"eastasianwidth@npm:^0.2.0":
+  version: 0.2.0
+  resolution: "eastasianwidth@npm:0.2.0"
+  checksum: 7d00d7cd8e49b9afa762a813faac332dee781932d6f2c848dc348939c4253f1d4564341b7af1d041853bc3f32c2ef141b58e0a4d9862c17a7f08f68df1e0f1ed
+  languageName: node
+  linkType: hard
+
+"ejs@npm:^3.1.10":
+  version: 3.1.10
+  resolution: "ejs@npm:3.1.10"
+  dependencies:
+    jake: ^10.8.5
+  bin:
+    ejs: bin/cli.js
+  checksum: ce90637e9c7538663ae023b8a7a380b2ef7cc4096de70be85abf5a3b9641912dde65353211d05e24d56b1f242d71185c6d00e02cb8860701d571786d92c71f05
+  languageName: node
+  linkType: hard
+
+"electron-to-chromium@npm:^1.5.73":
+  version: 1.5.74
+  resolution: "electron-to-chromium@npm:1.5.74"
+  checksum: e93db5fdfafe927dcefe2ffef5b8670ae0c340eb8a4fe176918ec8efa53c37aff0ba4c3649c234950af2809d16a186ffead64dd921c9021d629658bf6d17c21f
+  languageName: node
+  linkType: hard
+
+"emittery@npm:^0.13.1":
+  version: 0.13.1
+  resolution: "emittery@npm:0.13.1"
+  checksum: 2b089ab6306f38feaabf4f6f02792f9ec85fc054fda79f44f6790e61bbf6bc4e1616afb9b232e0c5ec5289a8a452f79bfa6d905a6fd64e94b49981f0934001c6
+  languageName: node
+  linkType: hard
+
+"emoji-regex@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "emoji-regex@npm:8.0.0"
+  checksum: d4c5c39d5a9868b5fa152f00cada8a936868fd3367f33f71be515ecee4c803132d11b31a6222b2571b1e5f7e13890156a94880345594d0ce7e3c9895f560f192
+  languageName: node
+  linkType: hard
+
+"emoji-regex@npm:^9.2.2":
+  version: 9.2.2
+  resolution: "emoji-regex@npm:9.2.2"
+  checksum: 8487182da74aabd810ac6d6f1994111dfc0e331b01271ae01ec1eb0ad7b5ecc2bbbbd2f053c05cb55a1ac30449527d819bbfbf0e3de1023db308cbcb47f86601
+  languageName: node
+  linkType: hard
+
+"emojis-list@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "emojis-list@npm:3.0.0"
+  checksum: ddaaa02542e1e9436c03970eeed445f4ed29a5337dfba0fe0c38dfdd2af5da2429c2a0821304e8a8d1cadf27fdd5b22ff793571fa803ae16852a6975c65e8e70
+  languageName: node
+  linkType: hard
+
+"encoding@npm:^0.1.13":
+  version: 0.1.13
+  resolution: "encoding@npm:0.1.13"
+  dependencies:
+    iconv-lite: ^0.6.2
+  checksum: bb98632f8ffa823996e508ce6a58ffcf5856330fde839ae42c9e1f436cc3b5cc651d4aeae72222916545428e54fd0f6aa8862fd8d25bdbcc4589f1e3f3715e7f
+  languageName: node
+  linkType: hard
+
+"enhanced-resolve@npm:^5.0.0, enhanced-resolve@npm:^5.17.1":
+  version: 5.17.1
+  resolution: "enhanced-resolve@npm:5.17.1"
+  dependencies:
+    graceful-fs: ^4.2.4
+    tapable: ^2.2.0
+  checksum: 4bc38cf1cea96456f97503db7280394177d1bc46f8f87c267297d04f795ac5efa81e48115a2f5b6273c781027b5b6bfc5f62b54df629e4d25fa7001a86624f59
+  languageName: node
+  linkType: hard
+
+"entities@npm:^4.2.0, entities@npm:^4.4.0, entities@npm:^4.5.0":
+  version: 4.5.0
+  resolution: "entities@npm:4.5.0"
+  checksum: 853f8ebd5b425d350bffa97dd6958143179a5938352ccae092c62d1267c4e392a039be1bae7d51b6e4ffad25f51f9617531fedf5237f15df302ccfb452cbf2d7
+  languageName: node
+  linkType: hard
+
+"env-paths@npm:^2.2.0":
+  version: 2.2.1
+  resolution: "env-paths@npm:2.2.1"
+  checksum: 65b5df55a8bab92229ab2b40dad3b387fad24613263d103a97f91c9fe43ceb21965cd3392b1ccb5d77088021e525c4e0481adb309625d0cb94ade1d1fb8dc17e
+  languageName: node
+  linkType: hard
+
+"envinfo@npm:^7.7.3":
+  version: 7.14.0
+  resolution: "envinfo@npm:7.14.0"
+  bin:
+    envinfo: dist/cli.js
+  checksum: 137c1dd9a4d5781c4a6cdc6b695454ba3c4ba1829f73927198aa4122f11b35b59d7b2cb7e1ceea1364925a30278897548511d22f860c14253a33797d0bebd551
+  languageName: node
+  linkType: hard
+
+"err-code@npm:^2.0.2":
+  version: 2.0.3
+  resolution: "err-code@npm:2.0.3"
+  checksum: 8b7b1be20d2de12d2255c0bc2ca638b7af5171142693299416e6a9339bd7d88fc8d7707d913d78e0993176005405a236b066b45666b27b797252c771156ace54
+  languageName: node
+  linkType: hard
+
+"error-ex@npm:^1.3.1":
+  version: 1.3.2
+  resolution: "error-ex@npm:1.3.2"
+  dependencies:
+    is-arrayish: ^0.2.1
+  checksum: c1c2b8b65f9c91b0f9d75f0debaa7ec5b35c266c2cac5de412c1a6de86d4cbae04ae44e510378cb14d032d0645a36925d0186f8bb7367bcc629db256b743a001
+  languageName: node
+  linkType: hard
+
+"es-abstract@npm:^1.23.2, es-abstract@npm:^1.23.5, es-abstract@npm:^1.23.6":
+  version: 1.23.6
+  resolution: "es-abstract@npm:1.23.6"
+  dependencies:
+    array-buffer-byte-length: ^1.0.1
+    arraybuffer.prototype.slice: ^1.0.4
+    available-typed-arrays: ^1.0.7
+    call-bind: ^1.0.8
+    call-bound: ^1.0.3
+    data-view-buffer: ^1.0.1
+    data-view-byte-length: ^1.0.1
+    data-view-byte-offset: ^1.0.0
+    es-define-property: ^1.0.1
+    es-errors: ^1.3.0
+    es-object-atoms: ^1.0.0
+    es-set-tostringtag: ^2.0.3
+    es-to-primitive: ^1.3.0
+    function.prototype.name: ^1.1.7
+    get-intrinsic: ^1.2.6
+    get-symbol-description: ^1.0.2
+    globalthis: ^1.0.4
+    gopd: ^1.2.0
+    has-property-descriptors: ^1.0.2
+    has-proto: ^1.2.0
+    has-symbols: ^1.1.0
+    hasown: ^2.0.2
+    internal-slot: ^1.1.0
+    is-array-buffer: ^3.0.4
+    is-callable: ^1.2.7
+    is-data-view: ^1.0.2
+    is-negative-zero: ^2.0.3
+    is-regex: ^1.2.1
+    is-shared-array-buffer: ^1.0.3
+    is-string: ^1.1.1
+    is-typed-array: ^1.1.13
+    is-weakref: ^1.1.0
+    math-intrinsics: ^1.0.0
+    object-inspect: ^1.13.3
+    object-keys: ^1.1.1
+    object.assign: ^4.1.5
+    regexp.prototype.flags: ^1.5.3
+    safe-array-concat: ^1.1.3
+    safe-regex-test: ^1.1.0
+    string.prototype.trim: ^1.2.10
+    string.prototype.trimend: ^1.0.9
+    string.prototype.trimstart: ^1.0.8
+    typed-array-buffer: ^1.0.2
+    typed-array-byte-length: ^1.0.1
+    typed-array-byte-offset: ^1.0.3
+    typed-array-length: ^1.0.7
+    unbox-primitive: ^1.0.2
+    which-typed-array: ^1.1.16
+  checksum: bc1b5a78ca243a9abd00e30aa84d644957878980e8bad961c9362a58e7790b56f54e146fc1871b15eed406fcd495cf2296a8ffb261370878f36316b62a67bbb4
+  languageName: node
+  linkType: hard
+
+"es-define-property@npm:^1.0.0, es-define-property@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "es-define-property@npm:1.0.1"
+  checksum: 0512f4e5d564021c9e3a644437b0155af2679d10d80f21adaf868e64d30efdfbd321631956f20f42d655fedb2e3a027da479fad3fa6048f768eb453a80a5f80a
+  languageName: node
+  linkType: hard
+
+"es-errors@npm:^1.3.0":
+  version: 1.3.0
+  resolution: "es-errors@npm:1.3.0"
+  checksum: ec1414527a0ccacd7f15f4a3bc66e215f04f595ba23ca75cdae0927af099b5ec865f9f4d33e9d7e86f512f252876ac77d4281a7871531a50678132429b1271b5
+  languageName: node
+  linkType: hard
+
+"es-module-lexer@npm:^1.2.1":
+  version: 1.5.4
+  resolution: "es-module-lexer@npm:1.5.4"
+  checksum: a0cf04fb92d052647ac7d818d1913b98d3d3d0f5b9d88f0eafb993436e4c3e2c958599db68839d57f2dfa281fdf0f60e18d448eb78fc292c33c0f25635b6854f
+  languageName: node
+  linkType: hard
+
+"es-object-atoms@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "es-object-atoms@npm:1.0.0"
+  dependencies:
+    es-errors: ^1.3.0
+  checksum: 26f0ff78ab93b63394e8403c353842b2272836968de4eafe97656adfb8a7c84b9099bf0fe96ed58f4a4cddc860f6e34c77f91649a58a5daa4a9c40b902744e3c
+  languageName: node
+  linkType: hard
+
+"es-set-tostringtag@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "es-set-tostringtag@npm:2.0.3"
+  dependencies:
+    get-intrinsic: ^1.2.4
+    has-tostringtag: ^1.0.2
+    hasown: ^2.0.1
+  checksum: 7227fa48a41c0ce83e0377b11130d324ac797390688135b8da5c28994c0165be8b252e15cd1de41e1325e5a5412511586960213e88f9ab4a5e7d028895db5129
+  languageName: node
+  linkType: hard
+
+"es-to-primitive@npm:^1.3.0":
+  version: 1.3.0
+  resolution: "es-to-primitive@npm:1.3.0"
+  dependencies:
+    is-callable: ^1.2.7
+    is-date-object: ^1.0.5
+    is-symbol: ^1.0.4
+  checksum: 966965880356486cd4d1fe9a523deda2084c81b3702d951212c098f5f2ee93605d1b7c1840062efb48a07d892641c7ed1bc194db563645c0dd2b919cb6d65b93
+  languageName: node
+  linkType: hard
+
+"escalade@npm:^3.1.1, escalade@npm:^3.2.0":
+  version: 3.2.0
+  resolution: "escalade@npm:3.2.0"
+  checksum: 47b029c83de01b0d17ad99ed766347b974b0d628e848de404018f3abee728e987da0d2d370ad4574aa3d5b5bfc368754fd085d69a30f8e75903486ec4b5b709e
+  languageName: node
+  linkType: hard
+
+"escape-string-regexp@npm:^1.0.5":
+  version: 1.0.5
+  resolution: "escape-string-regexp@npm:1.0.5"
+  checksum: 6092fda75c63b110c706b6a9bfde8a612ad595b628f0bd2147eea1d3406723020810e591effc7db1da91d80a71a737a313567c5abb3813e8d9c71f4aa595b410
+  languageName: node
+  linkType: hard
+
+"escape-string-regexp@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "escape-string-regexp@npm:2.0.0"
+  checksum: 9f8a2d5743677c16e85c810e3024d54f0c8dea6424fad3c79ef6666e81dd0846f7437f5e729dfcdac8981bc9e5294c39b4580814d114076b8d36318f46ae4395
+  languageName: node
+  linkType: hard
+
+"escape-string-regexp@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "escape-string-regexp@npm:4.0.0"
+  checksum: 98b48897d93060f2322108bf29db0feba7dd774be96cd069458d1453347b25ce8682ecc39859d4bca2203cc0ab19c237bcc71755eff49a0f8d90beadeeba5cc5
+  languageName: node
+  linkType: hard
+
+"escodegen@npm:^2.0.0":
+  version: 2.1.0
+  resolution: "escodegen@npm:2.1.0"
+  dependencies:
+    esprima: ^4.0.1
+    estraverse: ^5.2.0
+    esutils: ^2.0.2
+    source-map: ~0.6.1
+  dependenciesMeta:
+    source-map:
+      optional: true
+  bin:
+    escodegen: bin/escodegen.js
+    esgenerate: bin/esgenerate.js
+  checksum: 096696407e161305cd05aebb95134ad176708bc5cb13d0dcc89a5fcbb959b8ed757e7f2591a5f8036f8f4952d4a724de0df14cd419e29212729fa6df5ce16bf6
+  languageName: node
+  linkType: hard
+
+"eslint-config-prettier@npm:^9.1.0":
+  version: 9.1.0
+  resolution: "eslint-config-prettier@npm:9.1.0"
+  peerDependencies:
+    eslint: ">=7.0.0"
+  bin:
+    eslint-config-prettier: bin/cli.js
+  checksum: 9229b768c879f500ee54ca05925f31b0c0bafff3d9f5521f98ff05127356de78c81deb9365c86a5ec4efa990cb72b74df8612ae15965b14136044c73e1f6a907
+  languageName: node
+  linkType: hard
+
+"eslint-plugin-prettier@npm:^5.1.3":
+  version: 5.2.1
+  resolution: "eslint-plugin-prettier@npm:5.2.1"
+  dependencies:
+    prettier-linter-helpers: ^1.0.0
+    synckit: ^0.9.1
+  peerDependencies:
+    "@types/eslint": ">=8.0.0"
+    eslint: ">=8.0.0"
+    eslint-config-prettier: "*"
+    prettier: ">=3.0.0"
+  peerDependenciesMeta:
+    "@types/eslint":
+      optional: true
+    eslint-config-prettier:
+      optional: true
+  checksum: 812f4d1596dcd3a55963212dfbd818a4b38f880741aac75f6869aa740dc5d934060674d3b85d10ff9fec424defa61967dbdef26b8a893a92c9b51880264ed0d9
+  languageName: node
+  linkType: hard
+
+"eslint-scope@npm:5.1.1":
+  version: 5.1.1
+  resolution: "eslint-scope@npm:5.1.1"
+  dependencies:
+    esrecurse: ^4.3.0
+    estraverse: ^4.1.1
+  checksum: 47e4b6a3f0cc29c7feedee6c67b225a2da7e155802c6ea13bbef4ac6b9e10c66cd2dcb987867ef176292bf4e64eccc680a49e35e9e9c669f4a02bac17e86abdb
+  languageName: node
+  linkType: hard
+
+"eslint-scope@npm:^7.2.2":
+  version: 7.2.2
+  resolution: "eslint-scope@npm:7.2.2"
+  dependencies:
+    esrecurse: ^4.3.0
+    estraverse: ^5.2.0
+  checksum: ec97dbf5fb04b94e8f4c5a91a7f0a6dd3c55e46bfc7bbcd0e3138c3a76977570e02ed89a1810c778dcd72072ff0e9621ba1379b4babe53921d71e2e4486fda3e
+  languageName: node
+  linkType: hard
+
+"eslint-visitor-keys@npm:^3.4.1, eslint-visitor-keys@npm:^3.4.3":
+  version: 3.4.3
+  resolution: "eslint-visitor-keys@npm:3.4.3"
+  checksum: 36e9ef87fca698b6fd7ca5ca35d7b2b6eeaaf106572e2f7fd31c12d3bfdaccdb587bba6d3621067e5aece31c8c3a348b93922ab8f7b2cbc6aaab5e1d89040c60
+  languageName: node
+  linkType: hard
+
+"eslint@npm:^8.56.0":
+  version: 8.57.1
+  resolution: "eslint@npm:8.57.1"
+  dependencies:
+    "@eslint-community/eslint-utils": ^4.2.0
+    "@eslint-community/regexpp": ^4.6.1
+    "@eslint/eslintrc": ^2.1.4
+    "@eslint/js": 8.57.1
+    "@humanwhocodes/config-array": ^0.13.0
+    "@humanwhocodes/module-importer": ^1.0.1
+    "@nodelib/fs.walk": ^1.2.8
+    "@ungap/structured-clone": ^1.2.0
+    ajv: ^6.12.4
+    chalk: ^4.0.0
+    cross-spawn: ^7.0.2
+    debug: ^4.3.2
+    doctrine: ^3.0.0
+    escape-string-regexp: ^4.0.0
+    eslint-scope: ^7.2.2
+    eslint-visitor-keys: ^3.4.3
+    espree: ^9.6.1
+    esquery: ^1.4.2
+    esutils: ^2.0.2
+    fast-deep-equal: ^3.1.3
+    file-entry-cache: ^6.0.1
+    find-up: ^5.0.0
+    glob-parent: ^6.0.2
+    globals: ^13.19.0
+    graphemer: ^1.4.0
+    ignore: ^5.2.0
+    imurmurhash: ^0.1.4
+    is-glob: ^4.0.0
+    is-path-inside: ^3.0.3
+    js-yaml: ^4.1.0
+    json-stable-stringify-without-jsonify: ^1.0.1
+    levn: ^0.4.1
+    lodash.merge: ^4.6.2
+    minimatch: ^3.1.2
+    natural-compare: ^1.4.0
+    optionator: ^0.9.3
+    strip-ansi: ^6.0.1
+    text-table: ^0.2.0
+  bin:
+    eslint: bin/eslint.js
+  checksum: e2489bb7f86dd2011967759a09164e65744ef7688c310bc990612fc26953f34cc391872807486b15c06833bdff737726a23e9b4cdba5de144c311377dc41d91b
+  languageName: node
+  linkType: hard
+
+"espree@npm:^9.6.0, espree@npm:^9.6.1":
+  version: 9.6.1
+  resolution: "espree@npm:9.6.1"
+  dependencies:
+    acorn: ^8.9.0
+    acorn-jsx: ^5.3.2
+    eslint-visitor-keys: ^3.4.1
+  checksum: eb8c149c7a2a77b3f33a5af80c10875c3abd65450f60b8af6db1bfcfa8f101e21c1e56a561c6dc13b848e18148d43469e7cd208506238554fb5395a9ea5a1ab9
+  languageName: node
+  linkType: hard
+
+"esprima@npm:^4.0.0, esprima@npm:^4.0.1":
+  version: 4.0.1
+  resolution: "esprima@npm:4.0.1"
+  bin:
+    esparse: ./bin/esparse.js
+    esvalidate: ./bin/esvalidate.js
+  checksum: b45bc805a613dbea2835278c306b91aff6173c8d034223fa81498c77dcbce3b2931bf6006db816f62eacd9fd4ea975dfd85a5b7f3c6402cfd050d4ca3c13a628
+  languageName: node
+  linkType: hard
+
+"esquery@npm:^1.4.2":
+  version: 1.6.0
+  resolution: "esquery@npm:1.6.0"
+  dependencies:
+    estraverse: ^5.1.0
+  checksum: 08ec4fe446d9ab27186da274d979558557fbdbbd10968fa9758552482720c54152a5640e08b9009e5a30706b66aba510692054d4129d32d0e12e05bbc0b96fb2
+  languageName: node
+  linkType: hard
+
+"esrecurse@npm:^4.3.0":
+  version: 4.3.0
+  resolution: "esrecurse@npm:4.3.0"
+  dependencies:
+    estraverse: ^5.2.0
+  checksum: ebc17b1a33c51cef46fdc28b958994b1dc43cd2e86237515cbc3b4e5d2be6a811b2315d0a1a4d9d340b6d2308b15322f5c8291059521cc5f4802f65e7ec32837
+  languageName: node
+  linkType: hard
+
+"estraverse@npm:^4.1.1":
+  version: 4.3.0
+  resolution: "estraverse@npm:4.3.0"
+  checksum: a6299491f9940bb246124a8d44b7b7a413a8336f5436f9837aaa9330209bd9ee8af7e91a654a3545aee9c54b3308e78ee360cef1d777d37cfef77d2fa33b5827
+  languageName: node
+  linkType: hard
+
+"estraverse@npm:^5.1.0, estraverse@npm:^5.2.0":
+  version: 5.3.0
+  resolution: "estraverse@npm:5.3.0"
+  checksum: 072780882dc8416ad144f8fe199628d2b3e7bbc9989d9ed43795d2c90309a2047e6bc5979d7e2322a341163d22cfad9e21f4110597fe487519697389497e4e2b
+  languageName: node
+  linkType: hard
+
+"esutils@npm:^2.0.2":
+  version: 2.0.3
+  resolution: "esutils@npm:2.0.3"
+  checksum: 22b5b08f74737379a840b8ed2036a5fb35826c709ab000683b092d9054e5c2a82c27818f12604bfc2a9a76b90b6834ef081edbc1c7ae30d1627012e067c6ec87
+  languageName: node
+  linkType: hard
+
+"events@npm:^3.2.0":
+  version: 3.3.0
+  resolution: "events@npm:3.3.0"
+  checksum: f6f487ad2198aa41d878fa31452f1a3c00958f46e9019286ff4787c84aac329332ab45c9cdc8c445928fc6d7ded294b9e005a7fce9426488518017831b272780
+  languageName: node
+  linkType: hard
+
+"execa@npm:^5.0.0":
+  version: 5.1.1
+  resolution: "execa@npm:5.1.1"
+  dependencies:
+    cross-spawn: ^7.0.3
+    get-stream: ^6.0.0
+    human-signals: ^2.1.0
+    is-stream: ^2.0.0
+    merge-stream: ^2.0.0
+    npm-run-path: ^4.0.1
+    onetime: ^5.1.2
+    signal-exit: ^3.0.3
+    strip-final-newline: ^2.0.0
+  checksum: fba9022c8c8c15ed862847e94c252b3d946036d7547af310e344a527e59021fd8b6bb0723883ea87044dc4f0201f949046993124a42ccb0855cae5bf8c786343
+  languageName: node
+  linkType: hard
+
+"exit@npm:^0.1.2":
+  version: 0.1.2
+  resolution: "exit@npm:0.1.2"
+  checksum: abc407f07a875c3961e4781dfcb743b58d6c93de9ab263f4f8c9d23bb6da5f9b7764fc773f86b43dd88030444d5ab8abcb611cb680fba8ca075362b77114bba3
+  languageName: node
+  linkType: hard
+
+"expect@npm:^29.0.0, expect@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "expect@npm:29.7.0"
+  dependencies:
+    "@jest/expect-utils": ^29.7.0
+    jest-get-type: ^29.6.3
+    jest-matcher-utils: ^29.7.0
+    jest-message-util: ^29.7.0
+    jest-util: ^29.7.0
+  checksum: 9257f10288e149b81254a0fda8ffe8d54a7061cd61d7515779998b012579d2b8c22354b0eb901daf0145f347403da582f75f359f4810c007182ad3fb318b5c0c
+  languageName: node
+  linkType: hard
+
+"exponential-backoff@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "exponential-backoff@npm:3.1.1"
+  checksum: 3d21519a4f8207c99f7457287291316306255a328770d320b401114ec8481986e4e467e854cb9914dd965e0a1ca810a23ccb559c642c88f4c7f55c55778a9b48
+  languageName: node
+  linkType: hard
+
+"fast-deep-equal@npm:^3.1.1, fast-deep-equal@npm:^3.1.3":
+  version: 3.1.3
+  resolution: "fast-deep-equal@npm:3.1.3"
+  checksum: e21a9d8d84f53493b6aa15efc9cfd53dd5b714a1f23f67fb5dc8f574af80df889b3bce25dc081887c6d25457cce704e636395333abad896ccdec03abaf1f3f9d
+  languageName: node
+  linkType: hard
+
+"fast-diff@npm:^1.1.2":
+  version: 1.3.0
+  resolution: "fast-diff@npm:1.3.0"
+  checksum: d22d371b994fdc8cce9ff510d7b8dc4da70ac327bcba20df607dd5b9cae9f908f4d1028f5fe467650f058d1e7270235ae0b8230809a262b4df587a3b3aa216c3
+  languageName: node
+  linkType: hard
+
+"fast-glob@npm:^3.2.9":
+  version: 3.3.2
+  resolution: "fast-glob@npm:3.3.2"
+  dependencies:
+    "@nodelib/fs.stat": ^2.0.2
+    "@nodelib/fs.walk": ^1.2.3
+    glob-parent: ^5.1.2
+    merge2: ^1.3.0
+    micromatch: ^4.0.4
+  checksum: 900e4979f4dbc3313840078419245621259f349950411ca2fa445a2f9a1a6d98c3b5e7e0660c5ccd563aa61abe133a21765c6c0dec8e57da1ba71d8000b05ec1
+  languageName: node
+  linkType: hard
+
+"fast-json-stable-stringify@npm:2.x, fast-json-stable-stringify@npm:^2.0.0, fast-json-stable-stringify@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "fast-json-stable-stringify@npm:2.1.0"
+  checksum: b191531e36c607977e5b1c47811158733c34ccb3bfde92c44798929e9b4154884378536d26ad90dfecd32e1ffc09c545d23535ad91b3161a27ddbb8ebe0cbecb
+  languageName: node
+  linkType: hard
+
+"fast-levenshtein@npm:^2.0.6":
+  version: 2.0.6
+  resolution: "fast-levenshtein@npm:2.0.6"
+  checksum: 92cfec0a8dfafd9c7a15fba8f2cc29cd0b62b85f056d99ce448bbcd9f708e18ab2764bda4dd5158364f4145a7c72788538994f0d1787b956ef0d1062b0f7c24c
+  languageName: node
+  linkType: hard
+
+"fast-uri@npm:^3.0.1":
+  version: 3.0.3
+  resolution: "fast-uri@npm:3.0.3"
+  checksum: c52e6c86465f5c240e84a4485fb001088cc743d261a4b54b0050ce4758b1648bdbe53da1328ef9620149dca1435e3de64184f226d7c0a3656cb5837b3491e149
+  languageName: node
+  linkType: hard
+
+"fastest-levenshtein@npm:^1.0.12":
+  version: 1.0.16
+  resolution: "fastest-levenshtein@npm:1.0.16"
+  checksum: a78d44285c9e2ae2c25f3ef0f8a73f332c1247b7ea7fb4a191e6bb51aa6ee1ef0dfb3ed113616dcdc7023e18e35a8db41f61c8d88988e877cf510df8edafbc71
+  languageName: node
+  linkType: hard
+
+"fastq@npm:^1.6.0":
+  version: 1.17.1
+  resolution: "fastq@npm:1.17.1"
+  dependencies:
+    reusify: ^1.0.4
+  checksum: a8c5b26788d5a1763f88bae56a8ddeee579f935a831c5fe7a8268cea5b0a91fbfe705f612209e02d639b881d7b48e461a50da4a10cfaa40da5ca7cc9da098d88
+  languageName: node
+  linkType: hard
+
+"fb-watchman@npm:^2.0.0":
+  version: 2.0.2
+  resolution: "fb-watchman@npm:2.0.2"
+  dependencies:
+    bser: 2.1.1
+  checksum: b15a124cef28916fe07b400eb87cbc73ca082c142abf7ca8e8de6af43eca79ca7bd13eb4d4d48240b3bd3136eaac40d16e42d6edf87a8e5d1dd8070626860c78
+  languageName: node
+  linkType: hard
+
+"file-entry-cache@npm:^6.0.1":
+  version: 6.0.1
+  resolution: "file-entry-cache@npm:6.0.1"
+  dependencies:
+    flat-cache: ^3.0.4
+  checksum: f49701feaa6314c8127c3c2f6173cfefff17612f5ed2daaafc6da13b5c91fd43e3b2a58fd0d63f9f94478a501b167615931e7200e31485e320f74a33885a9c74
+  languageName: node
+  linkType: hard
+
+"filelist@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "filelist@npm:1.0.4"
+  dependencies:
+    minimatch: ^5.0.1
+  checksum: a303573b0821e17f2d5e9783688ab6fbfce5d52aaac842790ae85e704a6f5e4e3538660a63183d6453834dedf1e0f19a9dadcebfa3e926c72397694ea11f5160
+  languageName: node
+  linkType: hard
+
+"fill-range@npm:^7.1.1":
+  version: 7.1.1
+  resolution: "fill-range@npm:7.1.1"
+  dependencies:
+    to-regex-range: ^5.0.1
+  checksum: b4abfbca3839a3d55e4ae5ec62e131e2e356bf4859ce8480c64c4876100f4df292a63e5bb1618e1d7460282ca2b305653064f01654474aa35c68000980f17798
+  languageName: node
+  linkType: hard
+
+"find-root@npm:^1.0.0":
+  version: 1.1.0
+  resolution: "find-root@npm:1.1.0"
+  checksum: b2a59fe4b6c932eef36c45a048ae8f93c85640212ebe8363164814990ee20f154197505965f3f4f102efc33bfb1cbc26fd17c4a2fc739ebc51b886b137cbefaf
+  languageName: node
+  linkType: hard
+
+"find-up@npm:^4.0.0, find-up@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "find-up@npm:4.1.0"
+  dependencies:
+    locate-path: ^5.0.0
+    path-exists: ^4.0.0
+  checksum: 4c172680e8f8c1f78839486e14a43ef82e9decd0e74145f40707cc42e7420506d5ec92d9a11c22bd2c48fb0c384ea05dd30e10dd152fefeec6f2f75282a8b844
+  languageName: node
+  linkType: hard
+
+"find-up@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "find-up@npm:5.0.0"
+  dependencies:
+    locate-path: ^6.0.0
+    path-exists: ^4.0.0
+  checksum: 07955e357348f34660bde7920783204ff5a26ac2cafcaa28bace494027158a97b9f56faaf2d89a6106211a8174db650dd9f503f9c0d526b1202d5554a00b9095
+  languageName: node
+  linkType: hard
+
+"flat-cache@npm:^3.0.4":
+  version: 3.2.0
+  resolution: "flat-cache@npm:3.2.0"
+  dependencies:
+    flatted: ^3.2.9
+    keyv: ^4.5.3
+    rimraf: ^3.0.2
+  checksum: e7e0f59801e288b54bee5cb9681e9ee21ee28ef309f886b312c9d08415b79fc0f24ac842f84356ce80f47d6a53de62197ce0e6e148dc42d5db005992e2a756ec
+  languageName: node
+  linkType: hard
+
+"flat@npm:^5.0.2":
+  version: 5.0.2
+  resolution: "flat@npm:5.0.2"
+  bin:
+    flat: cli.js
+  checksum: 12a1536ac746db74881316a181499a78ef953632ddd28050b7a3a43c62ef5462e3357c8c29d76072bb635f147f7a9a1f0c02efef6b4be28f8db62ceb3d5c7f5d
+  languageName: node
+  linkType: hard
+
+"flatted@npm:^3.2.9":
+  version: 3.3.2
+  resolution: "flatted@npm:3.3.2"
+  checksum: ac3c159742e01d0e860a861164bcfd35bb567ccbebb8a0dd041e61cf3c64a435b917dd1e7ed1c380c2ebca85735fb16644485ec33665bc6aafc3b316aa1eed44
+  languageName: node
+  linkType: hard
+
+"for-each@npm:^0.3.3":
+  version: 0.3.3
+  resolution: "for-each@npm:0.3.3"
+  dependencies:
+    is-callable: ^1.1.3
+  checksum: 6c48ff2bc63362319c65e2edca4a8e1e3483a2fabc72fbe7feaf8c73db94fc7861bd53bc02c8a66a0c1dd709da6b04eec42e0abdd6b40ce47305ae92a25e5d28
+  languageName: node
+  linkType: hard
+
+"foreground-child@npm:^3.1.0":
+  version: 3.3.0
+  resolution: "foreground-child@npm:3.3.0"
+  dependencies:
+    cross-spawn: ^7.0.0
+    signal-exit: ^4.0.1
+  checksum: 1989698488f725b05b26bc9afc8a08f08ec41807cd7b92ad85d96004ddf8243fd3e79486b8348c64a3011ae5cc2c9f0936af989e1f28339805d8bc178a75b451
+  languageName: node
+  linkType: hard
+
+"form-data@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "form-data@npm:4.0.1"
+  dependencies:
+    asynckit: ^0.4.0
+    combined-stream: ^1.0.8
+    mime-types: ^2.1.12
+  checksum: ccee458cd5baf234d6b57f349fe9cc5f9a2ea8fd1af5ecda501a18fd1572a6dd3bf08a49f00568afd995b6a65af34cb8dec083cf9d582c4e621836499498dd84
+  languageName: node
+  linkType: hard
+
+"fs-extra@npm:^10.1.0":
+  version: 10.1.0
+  resolution: "fs-extra@npm:10.1.0"
+  dependencies:
+    graceful-fs: ^4.2.0
+    jsonfile: ^6.0.1
+    universalify: ^2.0.0
+  checksum: dc94ab37096f813cc3ca12f0f1b5ad6744dfed9ed21e953d72530d103cea193c2f81584a39e9dee1bea36de5ee66805678c0dddc048e8af1427ac19c00fffc50
+  languageName: node
+  linkType: hard
+
+"fs-extra@npm:^11.2.0":
+  version: 11.2.0
+  resolution: "fs-extra@npm:11.2.0"
+  dependencies:
+    graceful-fs: ^4.2.0
+    jsonfile: ^6.0.1
+    universalify: ^2.0.0
+  checksum: b12e42fa40ba47104202f57b8480dd098aa931c2724565e5e70779ab87605665594e76ee5fb00545f772ab9ace167fe06d2ab009c416dc8c842c5ae6df7aa7e8
+  languageName: node
+  linkType: hard
+
+"fs-minipass@npm:^3.0.0":
+  version: 3.0.3
+  resolution: "fs-minipass@npm:3.0.3"
+  dependencies:
+    minipass: ^7.0.3
+  checksum: 8722a41109130851d979222d3ec88aabaceeaaf8f57b2a8f744ef8bd2d1ce95453b04a61daa0078822bc5cd21e008814f06fe6586f56fef511e71b8d2394d802
+  languageName: node
+  linkType: hard
+
+"fs.realpath@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "fs.realpath@npm:1.0.0"
+  checksum: 99ddea01a7e75aa276c250a04eedeffe5662bce66c65c07164ad6264f9de18fb21be9433ead460e54cff20e31721c811f4fb5d70591799df5f85dce6d6746fd0
+  languageName: node
+  linkType: hard
+
+"fsevents@npm:^2.3.2":
+  version: 2.3.3
+  resolution: "fsevents@npm:2.3.3"
+  dependencies:
+    node-gyp: latest
+  checksum: 11e6ea6fea15e42461fc55b4b0e4a0a3c654faa567f1877dbd353f39156f69def97a69936d1746619d656c4b93de2238bf731f6085a03a50cabf287c9d024317
+  conditions: os=darwin
+  languageName: node
+  linkType: hard
+
+"fsevents@patch:fsevents@^2.3.2#~builtin<compat/fsevents>":
+  version: 2.3.3
+  resolution: "fsevents@patch:fsevents@npm%3A2.3.3#~builtin<compat/fsevents>::version=2.3.3&hash=df0bf1"
+  dependencies:
+    node-gyp: latest
+  conditions: os=darwin
+  languageName: node
+  linkType: hard
+
+"function-bind@npm:^1.1.2":
+  version: 1.1.2
+  resolution: "function-bind@npm:1.1.2"
+  checksum: 2b0ff4ce708d99715ad14a6d1f894e2a83242e4a52ccfcefaee5e40050562e5f6dafc1adbb4ce2d4ab47279a45dc736ab91ea5042d843c3c092820dfe032efb1
+  languageName: node
+  linkType: hard
+
+"function.prototype.name@npm:^1.1.6, function.prototype.name@npm:^1.1.7":
+  version: 1.1.7
+  resolution: "function.prototype.name@npm:1.1.7"
+  dependencies:
+    call-bind: ^1.0.8
+    define-properties: ^1.2.1
+    functions-have-names: ^1.2.3
+    hasown: ^2.0.2
+    is-callable: ^1.2.7
+  checksum: 271000814fd44b45ee5dbd595fe9aa45c20f276d04e2d3191476331e44d39c3d83d758bd7482e4dc7dacb67a2f196f5183834ab7a3546aa6d98f1de9020c676a
+  languageName: node
+  linkType: hard
+
+"functions-have-names@npm:^1.2.3":
+  version: 1.2.3
+  resolution: "functions-have-names@npm:1.2.3"
+  checksum: c3f1f5ba20f4e962efb71344ce0a40722163e85bee2101ce25f88214e78182d2d2476aa85ef37950c579eb6cf6ee811c17b3101bb84004bb75655f3e33f3fdb5
+  languageName: node
+  linkType: hard
+
+"gensync@npm:^1.0.0-beta.2":
+  version: 1.0.0-beta.2
+  resolution: "gensync@npm:1.0.0-beta.2"
+  checksum: a7437e58c6be12aa6c90f7730eac7fa9833dc78872b4ad2963d2031b00a3367a93f98aec75f9aaac7220848e4026d67a8655e870b24f20a543d103c0d65952ec
+  languageName: node
+  linkType: hard
+
+"get-caller-file@npm:^2.0.5":
+  version: 2.0.5
+  resolution: "get-caller-file@npm:2.0.5"
+  checksum: b9769a836d2a98c3ee734a88ba712e62703f1df31b94b784762c433c27a386dd6029ff55c2a920c392e33657d80191edbf18c61487e198844844516f843496b9
+  languageName: node
+  linkType: hard
+
+"get-intrinsic@npm:^1.2.4, get-intrinsic@npm:^1.2.5, get-intrinsic@npm:^1.2.6":
+  version: 1.2.6
+  resolution: "get-intrinsic@npm:1.2.6"
+  dependencies:
+    call-bind-apply-helpers: ^1.0.1
+    dunder-proto: ^1.0.0
+    es-define-property: ^1.0.1
+    es-errors: ^1.3.0
+    es-object-atoms: ^1.0.0
+    function-bind: ^1.1.2
+    gopd: ^1.2.0
+    has-symbols: ^1.1.0
+    hasown: ^2.0.2
+    math-intrinsics: ^1.0.0
+  checksum: a7592a0b7f023a2e83c0121fa9449ca83780e370a5feeebe8452119474d148016e43b455049134ae7a683b9b11b93d3f65eac199a0ad452ab740d5f0c299de47
+  languageName: node
+  linkType: hard
+
+"get-package-type@npm:^0.1.0":
+  version: 0.1.0
+  resolution: "get-package-type@npm:0.1.0"
+  checksum: bba0811116d11e56d702682ddef7c73ba3481f114590e705fc549f4d868972263896af313c57a25c076e3c0d567e11d919a64ba1b30c879be985fc9d44f96148
+  languageName: node
+  linkType: hard
+
+"get-stream@npm:^6.0.0":
+  version: 6.0.1
+  resolution: "get-stream@npm:6.0.1"
+  checksum: e04ecece32c92eebf5b8c940f51468cd53554dcbb0ea725b2748be583c9523d00128137966afce410b9b051eb2ef16d657cd2b120ca8edafcf5a65e81af63cad
+  languageName: node
+  linkType: hard
+
+"get-symbol-description@npm:^1.0.2":
+  version: 1.1.0
+  resolution: "get-symbol-description@npm:1.1.0"
+  dependencies:
+    call-bound: ^1.0.3
+    es-errors: ^1.3.0
+    get-intrinsic: ^1.2.6
+  checksum: 655ed04db48ee65ef2ddbe096540d4405e79ba0a7f54225775fef43a7e2afcb93a77d141c5f05fdef0afce2eb93bcbfb3597142189d562ac167ff183582683cd
+  languageName: node
+  linkType: hard
+
+"glob-parent@npm:^5.1.2":
+  version: 5.1.2
+  resolution: "glob-parent@npm:5.1.2"
+  dependencies:
+    is-glob: ^4.0.1
+  checksum: f4f2bfe2425296e8a47e36864e4f42be38a996db40420fe434565e4480e3322f18eb37589617a98640c5dc8fdec1a387007ee18dbb1f3f5553409c34d17f425e
+  languageName: node
+  linkType: hard
+
+"glob-parent@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "glob-parent@npm:6.0.2"
+  dependencies:
+    is-glob: ^4.0.3
+  checksum: c13ee97978bef4f55106b71e66428eb1512e71a7466ba49025fc2aec59a5bfb0954d5abd58fc5ee6c9b076eef4e1f6d3375c2e964b88466ca390da4419a786a8
+  languageName: node
+  linkType: hard
+
+"glob-to-regexp@npm:^0.4.1":
+  version: 0.4.1
+  resolution: "glob-to-regexp@npm:0.4.1"
+  checksum: e795f4e8f06d2a15e86f76e4d92751cf8bbfcf0157cea5c2f0f35678a8195a750b34096b1256e436f0cebc1883b5ff0888c47348443e69546a5a87f9e1eb1167
+  languageName: node
+  linkType: hard
+
+"glob@npm:^10.2.2, glob@npm:^10.3.10, glob@npm:^10.3.7":
+  version: 10.4.5
+  resolution: "glob@npm:10.4.5"
+  dependencies:
+    foreground-child: ^3.1.0
+    jackspeak: ^3.1.2
+    minimatch: ^9.0.4
+    minipass: ^7.1.2
+    package-json-from-dist: ^1.0.0
+    path-scurry: ^1.11.1
+  bin:
+    glob: dist/esm/bin.mjs
+  checksum: 0bc725de5e4862f9f387fd0f2b274baf16850dcd2714502ccf471ee401803997983e2c05590cb65f9675a3c6f2a58e7a53f9e365704108c6ad3cbf1d60934c4a
+  languageName: node
+  linkType: hard
+
+"glob@npm:^7.1.3, glob@npm:^7.1.4":
+  version: 7.2.3
+  resolution: "glob@npm:7.2.3"
+  dependencies:
+    fs.realpath: ^1.0.0
+    inflight: ^1.0.4
+    inherits: 2
+    minimatch: ^3.1.1
+    once: ^1.3.0
+    path-is-absolute: ^1.0.0
+  checksum: 29452e97b38fa704dabb1d1045350fb2467cf0277e155aa9ff7077e90ad81d1ea9d53d3ee63bd37c05b09a065e90f16aec4a65f5b8de401d1dac40bc5605d133
+  languageName: node
+  linkType: hard
+
+"glob@npm:~7.1.6":
+  version: 7.1.7
+  resolution: "glob@npm:7.1.7"
+  dependencies:
+    fs.realpath: ^1.0.0
+    inflight: ^1.0.4
+    inherits: 2
+    minimatch: ^3.0.4
+    once: ^1.3.0
+    path-is-absolute: ^1.0.0
+  checksum: b61f48973bbdcf5159997b0874a2165db572b368b931135832599875919c237fc05c12984e38fe828e69aa8a921eb0e8a4997266211c517c9cfaae8a93988bb8
+  languageName: node
+  linkType: hard
+
+"globals@npm:^11.1.0":
+  version: 11.12.0
+  resolution: "globals@npm:11.12.0"
+  checksum: 67051a45eca3db904aee189dfc7cd53c20c7d881679c93f6146ddd4c9f4ab2268e68a919df740d39c71f4445d2b38ee360fc234428baea1dbdfe68bbcb46979e
+  languageName: node
+  linkType: hard
+
+"globals@npm:^13.19.0":
+  version: 13.24.0
+  resolution: "globals@npm:13.24.0"
+  dependencies:
+    type-fest: ^0.20.2
+  checksum: 56066ef058f6867c04ff203b8a44c15b038346a62efbc3060052a1016be9f56f4cf0b2cd45b74b22b81e521a889fc7786c73691b0549c2f3a6e825b3d394f43c
+  languageName: node
+  linkType: hard
+
+"globalthis@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "globalthis@npm:1.0.4"
+  dependencies:
+    define-properties: ^1.2.1
+    gopd: ^1.0.1
+  checksum: 39ad667ad9f01476474633a1834a70842041f70a55571e8dcef5fb957980a92da5022db5430fca8aecc5d47704ae30618c0bc877a579c70710c904e9ef06108a
+  languageName: node
+  linkType: hard
+
+"globby@npm:^11.1.0":
+  version: 11.1.0
+  resolution: "globby@npm:11.1.0"
+  dependencies:
+    array-union: ^2.1.0
+    dir-glob: ^3.0.1
+    fast-glob: ^3.2.9
+    ignore: ^5.2.0
+    merge2: ^1.4.1
+    slash: ^3.0.0
+  checksum: b4be8885e0cfa018fc783792942d53926c35c50b3aefd3fdcfb9d22c627639dc26bd2327a40a0b74b074100ce95bb7187bfeae2f236856aa3de183af7a02aea6
+  languageName: node
+  linkType: hard
+
+"gopd@npm:^1.0.1, gopd@npm:^1.2.0":
+  version: 1.2.0
+  resolution: "gopd@npm:1.2.0"
+  checksum: cc6d8e655e360955bdccaca51a12a474268f95bb793fc3e1f2bdadb075f28bfd1fd988dab872daf77a61d78cbaf13744bc8727a17cfb1d150d76047d805375f3
+  languageName: node
+  linkType: hard
+
+"graceful-fs@npm:^4.1.2, graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.11, graceful-fs@npm:^4.2.4, graceful-fs@npm:^4.2.6, graceful-fs@npm:^4.2.9":
+  version: 4.2.11
+  resolution: "graceful-fs@npm:4.2.11"
+  checksum: ac85f94da92d8eb6b7f5a8b20ce65e43d66761c55ce85ac96df6865308390da45a8d3f0296dd3a663de65d30ba497bd46c696cc1e248c72b13d6d567138a4fc7
+  languageName: node
+  linkType: hard
+
+"graphemer@npm:^1.4.0":
+  version: 1.4.0
+  resolution: "graphemer@npm:1.4.0"
+  checksum: bab8f0be9b568857c7bec9fda95a89f87b783546d02951c40c33f84d05bb7da3fd10f863a9beb901463669b6583173a8c8cc6d6b306ea2b9b9d5d3d943c3a673
+  languageName: node
+  linkType: hard
+
+"harmony-reflect@npm:^1.4.6":
+  version: 1.6.2
+  resolution: "harmony-reflect@npm:1.6.2"
+  checksum: 2e5bae414cd2bfae5476147f9935dc69ee9b9a413206994dcb94c5b3208d4555da3d4313aff6fd14bd9991c1e3ef69cdda5c8fac1eb1d7afc064925839339b8c
+  languageName: node
+  linkType: hard
+
+"has-bigints@npm:^1.0.2":
+  version: 1.1.0
+  resolution: "has-bigints@npm:1.1.0"
+  checksum: 79730518ae02c77e4af6a1d1a0b6a2c3e1509785532771f9baf0241e83e36329542c3d7a0e723df8cbc85f74eff4f177828a2265a01ba576adbdc2d40d86538b
+  languageName: node
+  linkType: hard
+
+"has-flag@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "has-flag@npm:3.0.0"
+  checksum: 4a15638b454bf086c8148979aae044dd6e39d63904cd452d970374fa6a87623423da485dfb814e7be882e05c096a7ccf1ebd48e7e7501d0208d8384ff4dea73b
+  languageName: node
+  linkType: hard
+
+"has-flag@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "has-flag@npm:4.0.0"
+  checksum: 261a1357037ead75e338156b1f9452c016a37dcd3283a972a30d9e4a87441ba372c8b81f818cd0fbcd9c0354b4ae7e18b9e1afa1971164aef6d18c2b6095a8ad
+  languageName: node
+  linkType: hard
+
+"has-property-descriptors@npm:^1.0.0, has-property-descriptors@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "has-property-descriptors@npm:1.0.2"
+  dependencies:
+    es-define-property: ^1.0.0
+  checksum: fcbb246ea2838058be39887935231c6d5788babed499d0e9d0cc5737494c48aba4fe17ba1449e0d0fbbb1e36175442faa37f9c427ae357d6ccb1d895fbcd3de3
+  languageName: node
+  linkType: hard
+
+"has-proto@npm:^1.0.3, has-proto@npm:^1.2.0":
+  version: 1.2.0
+  resolution: "has-proto@npm:1.2.0"
+  dependencies:
+    dunder-proto: ^1.0.0
+  checksum: f55010cb94caa56308041d77967c72a02ffd71386b23f9afa8447e58bc92d49d15c19bf75173713468e92fe3fb1680b03b115da39c21c32c74886d1d50d3e7ff
+  languageName: node
+  linkType: hard
+
+"has-symbols@npm:^1.0.3, has-symbols@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "has-symbols@npm:1.1.0"
+  checksum: b2316c7302a0e8ba3aaba215f834e96c22c86f192e7310bdf689dd0e6999510c89b00fbc5742571507cebf25764d68c988b3a0da217369a73596191ac0ce694b
+  languageName: node
+  linkType: hard
+
+"has-tostringtag@npm:^1.0.0, has-tostringtag@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "has-tostringtag@npm:1.0.2"
+  dependencies:
+    has-symbols: ^1.0.3
+  checksum: 999d60bb753ad714356b2c6c87b7fb74f32463b8426e159397da4bde5bca7e598ab1073f4d8d4deafac297f2eb311484cd177af242776bf05f0d11565680468d
+  languageName: node
+  linkType: hard
+
+"hasown@npm:^2.0.1, hasown@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "hasown@npm:2.0.2"
+  dependencies:
+    function-bind: ^1.1.2
+  checksum: e8516f776a15149ca6c6ed2ae3110c417a00b62260e222590e54aa367cbcd6ed99122020b37b7fbdf05748df57b265e70095d7bf35a47660587619b15ffb93db
+  languageName: node
+  linkType: hard
+
+"hosted-git-info@npm:^2.1.4":
+  version: 2.8.9
+  resolution: "hosted-git-info@npm:2.8.9"
+  checksum: c955394bdab888a1e9bb10eb33029e0f7ce5a2ac7b3f158099dc8c486c99e73809dca609f5694b223920ca2174db33d32b12f9a2a47141dc59607c29da5a62dd
+  languageName: node
+  linkType: hard
+
+"html-encoding-sniffer@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "html-encoding-sniffer@npm:3.0.0"
+  dependencies:
+    whatwg-encoding: ^2.0.0
+  checksum: 8d806aa00487e279e5ccb573366a951a9f68f65c90298eac9c3a2b440a7ffe46615aff2995a2f61c6746c639234e6179a97e18ca5ccbbf93d3725ef2099a4502
+  languageName: node
+  linkType: hard
+
+"html-escaper@npm:^2.0.0":
+  version: 2.0.2
+  resolution: "html-escaper@npm:2.0.2"
+  checksum: d2df2da3ad40ca9ee3a39c5cc6475ef67c8f83c234475f24d8e9ce0dc80a2c82df8e1d6fa78ddd1e9022a586ea1bd247a615e80a5cd9273d90111ddda7d9e974
+  languageName: node
+  linkType: hard
+
+"htmlparser2@npm:^8.0.0":
+  version: 8.0.2
+  resolution: "htmlparser2@npm:8.0.2"
+  dependencies:
+    domelementtype: ^2.3.0
+    domhandler: ^5.0.3
+    domutils: ^3.0.1
+    entities: ^4.4.0
+  checksum: 29167a0f9282f181da8a6d0311b76820c8a59bc9e3c87009e21968264c2987d2723d6fde5a964d4b7b6cba663fca96ffb373c06d8223a85f52a6089ced942700
+  languageName: node
+  linkType: hard
+
+"http-cache-semantics@npm:^4.1.1":
+  version: 4.1.1
+  resolution: "http-cache-semantics@npm:4.1.1"
+  checksum: 83ac0bc60b17a3a36f9953e7be55e5c8f41acc61b22583060e8dedc9dd5e3607c823a88d0926f9150e571f90946835c7fe150732801010845c72cd8bbff1a236
+  languageName: node
+  linkType: hard
+
+"http-proxy-agent@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "http-proxy-agent@npm:5.0.0"
+  dependencies:
+    "@tootallnate/once": 2
+    agent-base: 6
+    debug: 4
+  checksum: e2ee1ff1656a131953839b2a19cd1f3a52d97c25ba87bd2559af6ae87114abf60971e498021f9b73f9fd78aea8876d1fb0d4656aac8a03c6caa9fc175f22b786
+  languageName: node
+  linkType: hard
+
+"http-proxy-agent@npm:^7.0.0":
+  version: 7.0.2
+  resolution: "http-proxy-agent@npm:7.0.2"
+  dependencies:
+    agent-base: ^7.1.0
+    debug: ^4.3.4
+  checksum: 670858c8f8f3146db5889e1fa117630910101db601fff7d5a8aa637da0abedf68c899f03d3451cac2f83bcc4c3d2dabf339b3aa00ff8080571cceb02c3ce02f3
+  languageName: node
+  linkType: hard
+
+"https-proxy-agent@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "https-proxy-agent@npm:5.0.1"
+  dependencies:
+    agent-base: 6
+    debug: 4
+  checksum: 571fccdf38184f05943e12d37d6ce38197becdd69e58d03f43637f7fa1269cf303a7d228aa27e5b27bbd3af8f09fd938e1c91dcfefff2df7ba77c20ed8dfc765
+  languageName: node
+  linkType: hard
+
+"https-proxy-agent@npm:^7.0.1":
+  version: 7.0.6
+  resolution: "https-proxy-agent@npm:7.0.6"
+  dependencies:
+    agent-base: ^7.1.2
+    debug: 4
+  checksum: b882377a120aa0544846172e5db021fa8afbf83fea2a897d397bd2ddd8095ab268c24bc462f40a15f2a8c600bf4aa05ce52927f70038d4014e68aefecfa94e8d
+  languageName: node
+  linkType: hard
+
+"human-signals@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "human-signals@npm:2.1.0"
+  checksum: b87fd89fce72391625271454e70f67fe405277415b48bcc0117ca73d31fa23a4241787afdc8d67f5a116cf37258c052f59ea82daffa72364d61351423848e3b8
+  languageName: node
+  linkType: hard
+
+"iconv-lite@npm:0.6.3, iconv-lite@npm:^0.6.2, iconv-lite@npm:^0.6.3":
+  version: 0.6.3
+  resolution: "iconv-lite@npm:0.6.3"
+  dependencies:
+    safer-buffer: ">= 2.1.2 < 3.0.0"
+  checksum: 3f60d47a5c8fc3313317edfd29a00a692cc87a19cac0159e2ce711d0ebc9019064108323b5e493625e25594f11c6236647d8e256fbe7a58f4a3b33b89e6d30bf
+  languageName: node
+  linkType: hard
+
+"icss-utils@npm:^5.0.0, icss-utils@npm:^5.1.0":
+  version: 5.1.0
+  resolution: "icss-utils@npm:5.1.0"
+  peerDependencies:
+    postcss: ^8.1.0
+  checksum: 5c324d283552b1269cfc13a503aaaa172a280f914e5b81544f3803bc6f06a3b585fb79f66f7c771a2c052db7982c18bf92d001e3b47282e3abbbb4c4cc488d68
+  languageName: node
+  linkType: hard
+
+"identity-obj-proxy@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "identity-obj-proxy@npm:3.0.0"
+  dependencies:
+    harmony-reflect: ^1.4.6
+  checksum: 97559f8ea2aeaa1a880d279d8c49550dce01148321e00a2102cda5ddf9ce622fa1d7f3efc7bed63458af78889de888fdaebaf31c816312298bb3fdd0ef8aaf2c
+  languageName: node
+  linkType: hard
+
+"ignore@npm:^5.2.0, ignore@npm:^5.2.4":
+  version: 5.3.2
+  resolution: "ignore@npm:5.3.2"
+  checksum: 2acfd32a573260ea522ea0bfeff880af426d68f6831f973129e2ba7363f422923cf53aab62f8369cbf4667c7b25b6f8a3761b34ecdb284ea18e87a5262a865be
+  languageName: node
+  linkType: hard
+
+"import-fresh@npm:^3.2.1":
+  version: 3.3.0
+  resolution: "import-fresh@npm:3.3.0"
+  dependencies:
+    parent-module: ^1.0.0
+    resolve-from: ^4.0.0
+  checksum: 2cacfad06e652b1edc50be650f7ec3be08c5e5a6f6d12d035c440a42a8cc028e60a5b99ca08a77ab4d6b1346da7d971915828f33cdab730d3d42f08242d09baa
+  languageName: node
+  linkType: hard
+
+"import-local@npm:^3.0.2":
+  version: 3.2.0
+  resolution: "import-local@npm:3.2.0"
+  dependencies:
+    pkg-dir: ^4.2.0
+    resolve-cwd: ^3.0.0
+  bin:
+    import-local-fixture: fixtures/cli.js
+  checksum: 0b0b0b412b2521739fbb85eeed834a3c34de9bc67e670b3d0b86248fc460d990a7b116ad056c084b87a693ef73d1f17268d6a5be626bb43c998a8b1c8a230004
+  languageName: node
+  linkType: hard
+
+"imurmurhash@npm:^0.1.4":
+  version: 0.1.4
+  resolution: "imurmurhash@npm:0.1.4"
+  checksum: 7cae75c8cd9a50f57dadd77482359f659eaebac0319dd9368bcd1714f55e65badd6929ca58569da2b6494ef13fdd5598cd700b1eba23f8b79c5f19d195a3ecf7
+  languageName: node
+  linkType: hard
+
+"inflight@npm:^1.0.4":
+  version: 1.0.6
+  resolution: "inflight@npm:1.0.6"
+  dependencies:
+    once: ^1.3.0
+    wrappy: 1
+  checksum: f4f76aa072ce19fae87ce1ef7d221e709afb59d445e05d47fba710e85470923a75de35bfae47da6de1b18afc3ce83d70facf44cfb0aff89f0a3f45c0a0244dfd
+  languageName: node
+  linkType: hard
+
+"inherits@npm:2":
+  version: 2.0.4
+  resolution: "inherits@npm:2.0.4"
+  checksum: 4a48a733847879d6cf6691860a6b1e3f0f4754176e4d71494c41f3475553768b10f84b5ce1d40fbd0e34e6bfbb864ee35858ad4dd2cf31e02fc4a154b724d7f1
+  languageName: node
+  linkType: hard
+
+"internal-slot@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "internal-slot@npm:1.1.0"
+  dependencies:
+    es-errors: ^1.3.0
+    hasown: ^2.0.2
+    side-channel: ^1.1.0
+  checksum: 8e0991c2d048cc08dab0a91f573c99f6a4215075887517ea4fa32203ce8aea60fa03f95b177977fa27eb502e5168366d0f3e02c762b799691411d49900611861
+  languageName: node
+  linkType: hard
+
+"interpret@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "interpret@npm:3.1.1"
+  checksum: 35cebcf48c7351130437596d9ab8c8fe131ce4038da4561e6d665f25640e0034702a031cf7e3a5cea60ac7ac548bf17465e0571ede126f3d3a6933152171ac82
+  languageName: node
+  linkType: hard
+
+"ip-address@npm:^9.0.5":
+  version: 9.0.5
+  resolution: "ip-address@npm:9.0.5"
+  dependencies:
+    jsbn: 1.1.0
+    sprintf-js: ^1.1.3
+  checksum: aa15f12cfd0ef5e38349744e3654bae649a34c3b10c77a674a167e99925d1549486c5b14730eebce9fea26f6db9d5e42097b00aa4f9f612e68c79121c71652dc
+  languageName: node
+  linkType: hard
+
+"is-array-buffer@npm:^3.0.4":
+  version: 3.0.5
+  resolution: "is-array-buffer@npm:3.0.5"
+  dependencies:
+    call-bind: ^1.0.8
+    call-bound: ^1.0.3
+    get-intrinsic: ^1.2.6
+  checksum: f137a2a6e77af682cdbffef1e633c140cf596f72321baf8bba0f4ef22685eb4339dde23dfe9e9ca430b5f961dee4d46577dcf12b792b68518c8449b134fb9156
+  languageName: node
+  linkType: hard
+
+"is-arrayish@npm:^0.2.1":
+  version: 0.2.1
+  resolution: "is-arrayish@npm:0.2.1"
+  checksum: eef4417e3c10e60e2c810b6084942b3ead455af16c4509959a27e490e7aee87cfb3f38e01bbde92220b528a0ee1a18d52b787e1458ee86174d8c7f0e58cd488f
+  languageName: node
+  linkType: hard
+
+"is-async-function@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "is-async-function@npm:2.0.0"
+  dependencies:
+    has-tostringtag: ^1.0.0
+  checksum: e3471d95e6c014bf37cad8a93f2f4b6aac962178e0a5041e8903147166964fdc1c5c1d2ef87e86d77322c370ca18f2ea004fa7420581fa747bcaf7c223069dbd
+  languageName: node
+  linkType: hard
+
+"is-bigint@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "is-bigint@npm:1.1.0"
+  dependencies:
+    has-bigints: ^1.0.2
+  checksum: ee1544f0e664f253306786ed1dce494b8cf242ef415d6375d8545b4d8816b0f054bd9f948a8988ae2c6325d1c28260dd02978236b2f7b8fb70dfc4838a6c9fa7
+  languageName: node
+  linkType: hard
+
+"is-boolean-object@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "is-boolean-object@npm:1.2.1"
+  dependencies:
+    call-bound: ^1.0.2
+    has-tostringtag: ^1.0.2
+  checksum: 2672609f0f2536172873810a38ec006a415e43ddc6a240f7638a1659cb20dfa91cc75c8a1bed36247bb046aa8f0eab945f20d1203bc69606418bd129c745f861
+  languageName: node
+  linkType: hard
+
+"is-callable@npm:^1.1.3, is-callable@npm:^1.2.7":
+  version: 1.2.7
+  resolution: "is-callable@npm:1.2.7"
+  checksum: 61fd57d03b0d984e2ed3720fb1c7a897827ea174bd44402878e059542ea8c4aeedee0ea0985998aa5cc2736b2fa6e271c08587addb5b3959ac52cf665173d1ac
+  languageName: node
+  linkType: hard
+
+"is-core-module@npm:^2.16.0":
+  version: 2.16.0
+  resolution: "is-core-module@npm:2.16.0"
+  dependencies:
+    hasown: ^2.0.2
+  checksum: 98aa14eaee864c2e86fff4e08813e0da3ca7ac38dd0a43b9f10aeec48bfbc4827e2677349adb626f66921caef7fa9e2745c80b8b7cafe8ac24d46dc8124cc216
+  languageName: node
+  linkType: hard
+
+"is-data-view@npm:^1.0.1, is-data-view@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "is-data-view@npm:1.0.2"
+  dependencies:
+    call-bound: ^1.0.2
+    get-intrinsic: ^1.2.6
+    is-typed-array: ^1.1.13
+  checksum: 31600dd19932eae7fd304567e465709ffbfa17fa236427c9c864148e1b54eb2146357fcf3aed9b686dee13c217e1bb5a649cb3b9c479e1004c0648e9febde1b2
+  languageName: node
+  linkType: hard
+
+"is-date-object@npm:^1.0.5, is-date-object@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "is-date-object@npm:1.1.0"
+  dependencies:
+    call-bound: ^1.0.2
+    has-tostringtag: ^1.0.2
+  checksum: d6c36ab9d20971d65f3fc64cef940d57a4900a2ac85fb488a46d164c2072a33da1cb51eefcc039e3e5c208acbce343d3480b84ab5ff0983f617512da2742562a
+  languageName: node
+  linkType: hard
+
+"is-extglob@npm:^2.1.1":
+  version: 2.1.1
+  resolution: "is-extglob@npm:2.1.1"
+  checksum: df033653d06d0eb567461e58a7a8c9f940bd8c22274b94bf7671ab36df5719791aae15eef6d83bbb5e23283967f2f984b8914559d4449efda578c775c4be6f85
+  languageName: node
+  linkType: hard
+
+"is-finalizationregistry@npm:^1.1.0":
+  version: 1.1.1
+  resolution: "is-finalizationregistry@npm:1.1.1"
+  dependencies:
+    call-bound: ^1.0.3
+  checksum: 38c646c506e64ead41a36c182d91639833311970b6b6c6268634f109eef0a1a9d2f1f2e499ef4cb43c744a13443c4cdd2f0812d5afdcee5e9b65b72b28c48557
+  languageName: node
+  linkType: hard
+
+"is-fullwidth-code-point@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "is-fullwidth-code-point@npm:3.0.0"
+  checksum: 44a30c29457c7fb8f00297bce733f0a64cd22eca270f83e58c105e0d015e45c019491a4ab2faef91ab51d4738c670daff901c799f6a700e27f7314029e99e348
+  languageName: node
+  linkType: hard
+
+"is-generator-fn@npm:^2.0.0":
+  version: 2.1.0
+  resolution: "is-generator-fn@npm:2.1.0"
+  checksum: a6ad5492cf9d1746f73b6744e0c43c0020510b59d56ddcb78a91cbc173f09b5e6beff53d75c9c5a29feb618bfef2bf458e025ecf3a57ad2268e2fb2569f56215
+  languageName: node
+  linkType: hard
+
+"is-generator-function@npm:^1.0.10":
+  version: 1.0.10
+  resolution: "is-generator-function@npm:1.0.10"
+  dependencies:
+    has-tostringtag: ^1.0.0
+  checksum: d54644e7dbaccef15ceb1e5d91d680eb5068c9ee9f9eb0a9e04173eb5542c9b51b5ab52c5537f5703e48d5fddfd376817c1ca07a84a407b7115b769d4bdde72b
+  languageName: node
+  linkType: hard
+
+"is-glob@npm:^4.0.0, is-glob@npm:^4.0.1, is-glob@npm:^4.0.3":
+  version: 4.0.3
+  resolution: "is-glob@npm:4.0.3"
+  dependencies:
+    is-extglob: ^2.1.1
+  checksum: d381c1319fcb69d341cc6e6c7cd588e17cd94722d9a32dbd60660b993c4fb7d0f19438674e68dfec686d09b7c73139c9166b47597f846af387450224a8101ab4
+  languageName: node
+  linkType: hard
+
+"is-map@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "is-map@npm:2.0.3"
+  checksum: e6ce5f6380f32b141b3153e6ba9074892bbbbd655e92e7ba5ff195239777e767a976dcd4e22f864accaf30e53ebf961ab1995424aef91af68788f0591b7396cc
+  languageName: node
+  linkType: hard
+
+"is-negative-zero@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "is-negative-zero@npm:2.0.3"
+  checksum: c1e6b23d2070c0539d7b36022d5a94407132411d01aba39ec549af824231f3804b1aea90b5e4e58e807a65d23ceb538ed6e355ce76b267bdd86edb757ffcbdcd
+  languageName: node
+  linkType: hard
+
+"is-number-object@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-number-object@npm:1.1.1"
+  dependencies:
+    call-bound: ^1.0.3
+    has-tostringtag: ^1.0.2
+  checksum: 6517f0a0e8c4b197a21afb45cd3053dc711e79d45d8878aa3565de38d0102b130ca8732485122c7b336e98c27dacd5236854e3e6526e0eb30cae64956535662f
+  languageName: node
+  linkType: hard
+
+"is-number@npm:^7.0.0":
+  version: 7.0.0
+  resolution: "is-number@npm:7.0.0"
+  checksum: 456ac6f8e0f3111ed34668a624e45315201dff921e5ac181f8ec24923b99e9f32ca1a194912dc79d539c97d33dba17dc635202ff0b2cf98326f608323276d27a
+  languageName: node
+  linkType: hard
+
+"is-path-inside@npm:^3.0.3":
+  version: 3.0.3
+  resolution: "is-path-inside@npm:3.0.3"
+  checksum: abd50f06186a052b349c15e55b182326f1936c89a78bf6c8f2b707412517c097ce04bc49a0ca221787bc44e1049f51f09a2ffb63d22899051988d3a618ba13e9
+  languageName: node
+  linkType: hard
+
+"is-plain-object@npm:^2.0.4":
+  version: 2.0.4
+  resolution: "is-plain-object@npm:2.0.4"
+  dependencies:
+    isobject: ^3.0.1
+  checksum: 2a401140cfd86cabe25214956ae2cfee6fbd8186809555cd0e84574f88de7b17abacb2e477a6a658fa54c6083ecbda1e6ae404c7720244cd198903848fca70ca
+  languageName: node
+  linkType: hard
+
+"is-plain-object@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "is-plain-object@npm:5.0.0"
+  checksum: e32d27061eef62c0847d303125440a38660517e586f2f3db7c9d179ae5b6674ab0f469d519b2e25c147a1a3bc87156d0d5f4d8821e0ce4a9ee7fe1fcf11ce45c
+  languageName: node
+  linkType: hard
+
+"is-potential-custom-element-name@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "is-potential-custom-element-name@npm:1.0.1"
+  checksum: ced7bbbb6433a5b684af581872afe0e1767e2d1146b2207ca0068a648fb5cab9d898495d1ac0583524faaf24ca98176a7d9876363097c2d14fee6dd324f3a1ab
+  languageName: node
+  linkType: hard
+
+"is-regex@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "is-regex@npm:1.2.1"
+  dependencies:
+    call-bound: ^1.0.2
+    gopd: ^1.2.0
+    has-tostringtag: ^1.0.2
+    hasown: ^2.0.2
+  checksum: 99ee0b6d30ef1bb61fa4b22fae7056c6c9b3c693803c0c284ff7a8570f83075a7d38cda53b06b7996d441215c27895ea5d1af62124562e13d91b3dbec41a5e13
+  languageName: node
+  linkType: hard
+
+"is-set@npm:^2.0.3":
+  version: 2.0.3
+  resolution: "is-set@npm:2.0.3"
+  checksum: 36e3f8c44bdbe9496c9689762cc4110f6a6a12b767c5d74c0398176aa2678d4467e3bf07595556f2dba897751bde1422480212b97d973c7b08a343100b0c0dfe
+  languageName: node
+  linkType: hard
+
+"is-shared-array-buffer@npm:^1.0.3":
+  version: 1.0.4
+  resolution: "is-shared-array-buffer@npm:1.0.4"
+  dependencies:
+    call-bound: ^1.0.3
+  checksum: 1611fedc175796eebb88f4dfc393dd969a4a8e6c69cadaff424ee9d4464f9f026399a5f84a90f7c62d6d7ee04e3626a912149726de102b0bd6c1ee6a9868fa5a
+  languageName: node
+  linkType: hard
+
+"is-stream@npm:^2.0.0":
+  version: 2.0.1
+  resolution: "is-stream@npm:2.0.1"
+  checksum: b8e05ccdf96ac330ea83c12450304d4a591f9958c11fd17bed240af8d5ffe08aedafa4c0f4cfccd4d28dc9d4d129daca1023633d5c11601a6cbc77521f6fae66
+  languageName: node
+  linkType: hard
+
+"is-string@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-string@npm:1.1.1"
+  dependencies:
+    call-bound: ^1.0.3
+    has-tostringtag: ^1.0.2
+  checksum: 2eeaaff605250f5e836ea3500d33d1a5d3aa98d008641d9d42fb941e929ffd25972326c2ef912987e54c95b6f10416281aaf1b35cdf81992cfb7524c5de8e193
+  languageName: node
+  linkType: hard
+
+"is-symbol@npm:^1.0.4, is-symbol@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "is-symbol@npm:1.1.1"
+  dependencies:
+    call-bound: ^1.0.2
+    has-symbols: ^1.1.0
+    safe-regex-test: ^1.1.0
+  checksum: bfafacf037af6f3c9d68820b74be4ae8a736a658a3344072df9642a090016e281797ba8edbeb1c83425879aae55d1cb1f30b38bf132d703692b2570367358032
+  languageName: node
+  linkType: hard
+
+"is-typed-array@npm:^1.1.13, is-typed-array@npm:^1.1.14":
+  version: 1.1.15
+  resolution: "is-typed-array@npm:1.1.15"
+  dependencies:
+    which-typed-array: ^1.1.16
+  checksum: ea7cfc46c282f805d19a9ab2084fd4542fed99219ee9dbfbc26284728bd713a51eac66daa74eca00ae0a43b61322920ba334793607dc39907465913e921e0892
+  languageName: node
+  linkType: hard
+
+"is-weakmap@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "is-weakmap@npm:2.0.2"
+  checksum: f36aef758b46990e0d3c37269619c0a08c5b29428c0bb11ecba7f75203442d6c7801239c2f31314bc79199217ef08263787f3837d9e22610ad1da62970d6616d
+  languageName: node
+  linkType: hard
+
+"is-weakref@npm:^1.0.2, is-weakref@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "is-weakref@npm:1.1.0"
+  dependencies:
+    call-bound: ^1.0.2
+  checksum: 2a2f3a1746ee1baecf9ac6483d903cd3f8ef3cca88e2baa42f2e85ea064bd246d218eed5f6d479fc1c76dae2231e71133b6b86160e821d176932be9fae3da4da
+  languageName: node
+  linkType: hard
+
+"is-weakset@npm:^2.0.3":
+  version: 2.0.4
+  resolution: "is-weakset@npm:2.0.4"
+  dependencies:
+    call-bound: ^1.0.3
+    get-intrinsic: ^1.2.6
+  checksum: 5c6c8415a06065d78bdd5e3a771483aa1cd928df19138aa73c4c51333226f203f22117b4325df55cc8b3085a6716870a320c2d757efee92d7a7091a039082041
+  languageName: node
+  linkType: hard
+
+"isarray@npm:^2.0.5":
+  version: 2.0.5
+  resolution: "isarray@npm:2.0.5"
+  checksum: bd5bbe4104438c4196ba58a54650116007fa0262eccef13a4c55b2e09a5b36b59f1e75b9fcc49883dd9d4953892e6fc007eef9e9155648ceea036e184b0f930a
+  languageName: node
+  linkType: hard
+
+"isexe@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "isexe@npm:2.0.0"
+  checksum: 26bf6c5480dda5161c820c5b5c751ae1e766c587b1f951ea3fcfc973bafb7831ae5b54a31a69bd670220e42e99ec154475025a468eae58ea262f813fdc8d1c62
+  languageName: node
+  linkType: hard
+
+"isexe@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "isexe@npm:3.1.1"
+  checksum: 7fe1931ee4e88eb5aa524cd3ceb8c882537bc3a81b02e438b240e47012eef49c86904d0f0e593ea7c3a9996d18d0f1f3be8d3eaa92333977b0c3a9d353d5563e
+  languageName: node
+  linkType: hard
+
+"isobject@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "isobject@npm:3.0.1"
+  checksum: db85c4c970ce30693676487cca0e61da2ca34e8d4967c2e1309143ff910c207133a969f9e4ddb2dc6aba670aabce4e0e307146c310350b298e74a31f7d464703
+  languageName: node
+  linkType: hard
+
+"isomorphic.js@npm:^0.2.4":
+  version: 0.2.5
+  resolution: "isomorphic.js@npm:0.2.5"
+  checksum: d8d1b083f05f3c337a06628b982ac3ce6db953bbef14a9de8ad49131250c3592f864b73c12030fdc9ef138ce97b76ef55c7d96a849561ac215b1b4b9d301c8e9
+  languageName: node
+  linkType: hard
+
+"istanbul-lib-coverage@npm:^3.0.0, istanbul-lib-coverage@npm:^3.2.0":
+  version: 3.2.2
+  resolution: "istanbul-lib-coverage@npm:3.2.2"
+  checksum: 2367407a8d13982d8f7a859a35e7f8dd5d8f75aae4bb5484ede3a9ea1b426dc245aff28b976a2af48ee759fdd9be374ce2bd2669b644f31e76c5f46a2e29a831
+  languageName: node
+  linkType: hard
+
+"istanbul-lib-instrument@npm:^5.0.4":
+  version: 5.2.1
+  resolution: "istanbul-lib-instrument@npm:5.2.1"
+  dependencies:
+    "@babel/core": ^7.12.3
+    "@babel/parser": ^7.14.7
+    "@istanbuljs/schema": ^0.1.2
+    istanbul-lib-coverage: ^3.2.0
+    semver: ^6.3.0
+  checksum: bf16f1803ba5e51b28bbd49ed955a736488381e09375d830e42ddeb403855b2006f850711d95ad726f2ba3f1ae8e7366de7e51d2b9ac67dc4d80191ef7ddf272
+  languageName: node
+  linkType: hard
+
+"istanbul-lib-instrument@npm:^6.0.0":
+  version: 6.0.3
+  resolution: "istanbul-lib-instrument@npm:6.0.3"
+  dependencies:
+    "@babel/core": ^7.23.9
+    "@babel/parser": ^7.23.9
+    "@istanbuljs/schema": ^0.1.3
+    istanbul-lib-coverage: ^3.2.0
+    semver: ^7.5.4
+  checksum: 74104c60c65c4fa0e97cc76f039226c356123893929f067bfad5f86fe839e08f5d680354a68fead3bc9c1e2f3fa6f3f53cded70778e821d911e851d349f3545a
+  languageName: node
+  linkType: hard
+
+"istanbul-lib-report@npm:^3.0.0":
+  version: 3.0.1
+  resolution: "istanbul-lib-report@npm:3.0.1"
+  dependencies:
+    istanbul-lib-coverage: ^3.0.0
+    make-dir: ^4.0.0
+    supports-color: ^7.1.0
+  checksum: fd17a1b879e7faf9bb1dc8f80b2a16e9f5b7b8498fe6ed580a618c34df0bfe53d2abd35bf8a0a00e628fb7405462576427c7df20bbe4148d19c14b431c974b21
+  languageName: node
+  linkType: hard
+
+"istanbul-lib-source-maps@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "istanbul-lib-source-maps@npm:4.0.1"
+  dependencies:
+    debug: ^4.1.1
+    istanbul-lib-coverage: ^3.0.0
+    source-map: ^0.6.1
+  checksum: 21ad3df45db4b81852b662b8d4161f6446cd250c1ddc70ef96a585e2e85c26ed7cd9c2a396a71533cfb981d1a645508bc9618cae431e55d01a0628e7dec62ef2
+  languageName: node
+  linkType: hard
+
+"istanbul-reports@npm:^3.1.3":
+  version: 3.1.7
+  resolution: "istanbul-reports@npm:3.1.7"
+  dependencies:
+    html-escaper: ^2.0.0
+    istanbul-lib-report: ^3.0.0
+  checksum: 2072db6e07bfbb4d0eb30e2700250636182398c1af811aea5032acb219d2080f7586923c09fa194029efd6b92361afb3dcbe1ebcc3ee6651d13340f7c6c4ed95
+  languageName: node
+  linkType: hard
+
+"jackspeak@npm:^3.1.2":
+  version: 3.4.3
+  resolution: "jackspeak@npm:3.4.3"
+  dependencies:
+    "@isaacs/cliui": ^8.0.2
+    "@pkgjs/parseargs": ^0.11.0
+  dependenciesMeta:
+    "@pkgjs/parseargs":
+      optional: true
+  checksum: be31027fc72e7cc726206b9f560395604b82e0fddb46c4cbf9f97d049bcef607491a5afc0699612eaa4213ca5be8fd3e1e7cd187b3040988b65c9489838a7c00
+  languageName: node
+  linkType: hard
+
+"jake@npm:^10.8.5":
+  version: 10.9.2
+  resolution: "jake@npm:10.9.2"
+  dependencies:
+    async: ^3.2.3
+    chalk: ^4.0.2
+    filelist: ^1.0.4
+    minimatch: ^3.1.2
+  bin:
+    jake: bin/cli.js
+  checksum: f2dc4a086b4f58446d02cb9be913c39710d9ea570218d7681bb861f7eeaecab7b458256c946aeaa7e548c5e0686cc293e6435501e4047174a3b6a504dcbfcaae
+  languageName: node
+  linkType: hard
+
+"jest-changed-files@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-changed-files@npm:29.7.0"
+  dependencies:
+    execa: ^5.0.0
+    jest-util: ^29.7.0
+    p-limit: ^3.1.0
+  checksum: 963e203893c396c5dfc75e00a49426688efea7361b0f0e040035809cecd2d46b3c01c02be2d9e8d38b1138357d2de7719ea5b5be21f66c10f2e9685a5a73bb99
+  languageName: node
+  linkType: hard
+
+"jest-circus@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-circus@npm:29.7.0"
+  dependencies:
+    "@jest/environment": ^29.7.0
+    "@jest/expect": ^29.7.0
+    "@jest/test-result": ^29.7.0
+    "@jest/types": ^29.6.3
+    "@types/node": "*"
+    chalk: ^4.0.0
+    co: ^4.6.0
+    dedent: ^1.0.0
+    is-generator-fn: ^2.0.0
+    jest-each: ^29.7.0
+    jest-matcher-utils: ^29.7.0
+    jest-message-util: ^29.7.0
+    jest-runtime: ^29.7.0
+    jest-snapshot: ^29.7.0
+    jest-util: ^29.7.0
+    p-limit: ^3.1.0
+    pretty-format: ^29.7.0
+    pure-rand: ^6.0.0
+    slash: ^3.0.0
+    stack-utils: ^2.0.3
+  checksum: 349437148924a5a109c9b8aad6d393a9591b4dac1918fc97d81b7fc515bc905af9918495055071404af1fab4e48e4b04ac3593477b1d5dcf48c4e71b527c70a7
+  languageName: node
+  linkType: hard
+
+"jest-cli@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-cli@npm:29.7.0"
+  dependencies:
+    "@jest/core": ^29.7.0
+    "@jest/test-result": ^29.7.0
+    "@jest/types": ^29.6.3
+    chalk: ^4.0.0
+    create-jest: ^29.7.0
+    exit: ^0.1.2
+    import-local: ^3.0.2
+    jest-config: ^29.7.0
+    jest-util: ^29.7.0
+    jest-validate: ^29.7.0
+    yargs: ^17.3.1
+  peerDependencies:
+    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+  peerDependenciesMeta:
+    node-notifier:
+      optional: true
+  bin:
+    jest: bin/jest.js
+  checksum: 664901277a3f5007ea4870632ed6e7889db9da35b2434e7cb488443e6bf5513889b344b7fddf15112135495b9875892b156faeb2d7391ddb9e2a849dcb7b6c36
+  languageName: node
+  linkType: hard
+
+"jest-config@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-config@npm:29.7.0"
+  dependencies:
+    "@babel/core": ^7.11.6
+    "@jest/test-sequencer": ^29.7.0
+    "@jest/types": ^29.6.3
+    babel-jest: ^29.7.0
+    chalk: ^4.0.0
+    ci-info: ^3.2.0
+    deepmerge: ^4.2.2
+    glob: ^7.1.3
+    graceful-fs: ^4.2.9
+    jest-circus: ^29.7.0
+    jest-environment-node: ^29.7.0
+    jest-get-type: ^29.6.3
+    jest-regex-util: ^29.6.3
+    jest-resolve: ^29.7.0
+    jest-runner: ^29.7.0
+    jest-util: ^29.7.0
+    jest-validate: ^29.7.0
+    micromatch: ^4.0.4
+    parse-json: ^5.2.0
+    pretty-format: ^29.7.0
+    slash: ^3.0.0
+    strip-json-comments: ^3.1.1
+  peerDependencies:
+    "@types/node": "*"
+    ts-node: ">=9.0.0"
+  peerDependenciesMeta:
+    "@types/node":
+      optional: true
+    ts-node:
+      optional: true
+  checksum: 4cabf8f894c180cac80b7df1038912a3fc88f96f2622de33832f4b3314f83e22b08fb751da570c0ab2b7988f21604bdabade95e3c0c041068ac578c085cf7dff
+  languageName: node
+  linkType: hard
+
+"jest-diff@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-diff@npm:29.7.0"
+  dependencies:
+    chalk: ^4.0.0
+    diff-sequences: ^29.6.3
+    jest-get-type: ^29.6.3
+    pretty-format: ^29.7.0
+  checksum: 08e24a9dd43bfba1ef07a6374e5af138f53137b79ec3d5cc71a2303515335898888fa5409959172e1e05de966c9e714368d15e8994b0af7441f0721ee8e1bb77
+  languageName: node
+  linkType: hard
+
+"jest-docblock@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-docblock@npm:29.7.0"
+  dependencies:
+    detect-newline: ^3.0.0
+  checksum: 66390c3e9451f8d96c5da62f577a1dad701180cfa9b071c5025acab2f94d7a3efc2515cfa1654ebe707213241541ce9c5530232cdc8017c91ed64eea1bd3b192
+  languageName: node
+  linkType: hard
+
+"jest-each@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-each@npm:29.7.0"
+  dependencies:
+    "@jest/types": ^29.6.3
+    chalk: ^4.0.0
+    jest-get-type: ^29.6.3
+    jest-util: ^29.7.0
+    pretty-format: ^29.7.0
+  checksum: e88f99f0184000fc8813f2a0aa79e29deeb63700a3b9b7928b8a418d7d93cd24933608591dbbdea732b473eb2021c72991b5cc51a17966842841c6e28e6f691c
+  languageName: node
+  linkType: hard
+
+"jest-environment-jsdom@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-environment-jsdom@npm:29.7.0"
+  dependencies:
+    "@jest/environment": ^29.7.0
+    "@jest/fake-timers": ^29.7.0
+    "@jest/types": ^29.6.3
+    "@types/jsdom": ^20.0.0
+    "@types/node": "*"
+    jest-mock: ^29.7.0
+    jest-util: ^29.7.0
+    jsdom: ^20.0.0
+  peerDependencies:
+    canvas: ^2.5.0
+  peerDependenciesMeta:
+    canvas:
+      optional: true
+  checksum: 559aac134c196fccc1dfc794d8fc87377e9f78e894bb13012b0831d88dec0abd7ece99abec69da564b8073803be4f04a9eb4f4d1bb80e29eec0cb252c254deb8
+  languageName: node
+  linkType: hard
+
+"jest-environment-node@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-environment-node@npm:29.7.0"
+  dependencies:
+    "@jest/environment": ^29.7.0
+    "@jest/fake-timers": ^29.7.0
+    "@jest/types": ^29.6.3
+    "@types/node": "*"
+    jest-mock: ^29.7.0
+    jest-util: ^29.7.0
+  checksum: 501a9966292cbe0ca3f40057a37587cb6def25e1e0c5e39ac6c650fe78d3c70a2428304341d084ac0cced5041483acef41c477abac47e9a290d5545fd2f15646
+  languageName: node
+  linkType: hard
+
+"jest-get-type@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "jest-get-type@npm:29.6.3"
+  checksum: 88ac9102d4679d768accae29f1e75f592b760b44277df288ad76ce5bf038c3f5ce3719dea8aa0f035dac30e9eb034b848ce716b9183ad7cc222d029f03e92205
+  languageName: node
+  linkType: hard
+
+"jest-haste-map@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-haste-map@npm:29.7.0"
+  dependencies:
+    "@jest/types": ^29.6.3
+    "@types/graceful-fs": ^4.1.3
+    "@types/node": "*"
+    anymatch: ^3.0.3
+    fb-watchman: ^2.0.0
+    fsevents: ^2.3.2
+    graceful-fs: ^4.2.9
+    jest-regex-util: ^29.6.3
+    jest-util: ^29.7.0
+    jest-worker: ^29.7.0
+    micromatch: ^4.0.4
+    walker: ^1.0.8
+  dependenciesMeta:
+    fsevents:
+      optional: true
+  checksum: c2c8f2d3e792a963940fbdfa563ce14ef9e14d4d86da645b96d3cd346b8d35c5ce0b992ee08593939b5f718cf0a1f5a90011a056548a1dbf58397d4356786f01
+  languageName: node
+  linkType: hard
+
+"jest-leak-detector@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-leak-detector@npm:29.7.0"
+  dependencies:
+    jest-get-type: ^29.6.3
+    pretty-format: ^29.7.0
+  checksum: e3950e3ddd71e1d0c22924c51a300a1c2db6cf69ec1e51f95ccf424bcc070f78664813bef7aed4b16b96dfbdeea53fe358f8aeaaea84346ae15c3735758f1605
+  languageName: node
+  linkType: hard
+
+"jest-matcher-utils@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-matcher-utils@npm:29.7.0"
+  dependencies:
+    chalk: ^4.0.0
+    jest-diff: ^29.7.0
+    jest-get-type: ^29.6.3
+    pretty-format: ^29.7.0
+  checksum: d7259e5f995d915e8a37a8fd494cb7d6af24cd2a287b200f831717ba0d015190375f9f5dc35393b8ba2aae9b2ebd60984635269c7f8cff7d85b077543b7744cd
+  languageName: node
+  linkType: hard
+
+"jest-message-util@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-message-util@npm:29.7.0"
+  dependencies:
+    "@babel/code-frame": ^7.12.13
+    "@jest/types": ^29.6.3
+    "@types/stack-utils": ^2.0.0
+    chalk: ^4.0.0
+    graceful-fs: ^4.2.9
+    micromatch: ^4.0.4
+    pretty-format: ^29.7.0
+    slash: ^3.0.0
+    stack-utils: ^2.0.3
+  checksum: a9d025b1c6726a2ff17d54cc694de088b0489456c69106be6b615db7a51b7beb66788bea7a59991a019d924fbf20f67d085a445aedb9a4d6760363f4d7d09930
+  languageName: node
+  linkType: hard
+
+"jest-mock@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-mock@npm:29.7.0"
+  dependencies:
+    "@jest/types": ^29.6.3
+    "@types/node": "*"
+    jest-util: ^29.7.0
+  checksum: 81ba9b68689a60be1482212878973700347cb72833c5e5af09895882b9eb5c4e02843a1bbdf23f94c52d42708bab53a30c45a3482952c9eec173d1eaac5b86c5
+  languageName: node
+  linkType: hard
+
+"jest-pnp-resolver@npm:^1.2.2":
+  version: 1.2.3
+  resolution: "jest-pnp-resolver@npm:1.2.3"
+  peerDependencies:
+    jest-resolve: "*"
+  peerDependenciesMeta:
+    jest-resolve:
+      optional: true
+  checksum: db1a8ab2cb97ca19c01b1cfa9a9c8c69a143fde833c14df1fab0766f411b1148ff0df878adea09007ac6a2085ec116ba9a996a6ad104b1e58c20adbf88eed9b2
+  languageName: node
+  linkType: hard
+
+"jest-regex-util@npm:^29.6.3":
+  version: 29.6.3
+  resolution: "jest-regex-util@npm:29.6.3"
+  checksum: 0518beeb9bf1228261695e54f0feaad3606df26a19764bc19541e0fc6e2a3737191904607fb72f3f2ce85d9c16b28df79b7b1ec9443aa08c3ef0e9efda6f8f2a
+  languageName: node
+  linkType: hard
+
+"jest-resolve-dependencies@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-resolve-dependencies@npm:29.7.0"
+  dependencies:
+    jest-regex-util: ^29.6.3
+    jest-snapshot: ^29.7.0
+  checksum: aeb75d8150aaae60ca2bb345a0d198f23496494677cd6aefa26fc005faf354061f073982175daaf32b4b9d86b26ca928586344516e3e6969aa614cb13b883984
+  languageName: node
+  linkType: hard
+
+"jest-resolve@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-resolve@npm:29.7.0"
+  dependencies:
+    chalk: ^4.0.0
+    graceful-fs: ^4.2.9
+    jest-haste-map: ^29.7.0
+    jest-pnp-resolver: ^1.2.2
+    jest-util: ^29.7.0
+    jest-validate: ^29.7.0
+    resolve: ^1.20.0
+    resolve.exports: ^2.0.0
+    slash: ^3.0.0
+  checksum: 0ca218e10731aa17920526ec39deaec59ab9b966237905ffc4545444481112cd422f01581230eceb7e82d86f44a543d520a71391ec66e1b4ef1a578bd5c73487
+  languageName: node
+  linkType: hard
+
+"jest-runner@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-runner@npm:29.7.0"
+  dependencies:
+    "@jest/console": ^29.7.0
+    "@jest/environment": ^29.7.0
+    "@jest/test-result": ^29.7.0
+    "@jest/transform": ^29.7.0
+    "@jest/types": ^29.6.3
+    "@types/node": "*"
+    chalk: ^4.0.0
+    emittery: ^0.13.1
+    graceful-fs: ^4.2.9
+    jest-docblock: ^29.7.0
+    jest-environment-node: ^29.7.0
+    jest-haste-map: ^29.7.0
+    jest-leak-detector: ^29.7.0
+    jest-message-util: ^29.7.0
+    jest-resolve: ^29.7.0
+    jest-runtime: ^29.7.0
+    jest-util: ^29.7.0
+    jest-watcher: ^29.7.0
+    jest-worker: ^29.7.0
+    p-limit: ^3.1.0
+    source-map-support: 0.5.13
+  checksum: f0405778ea64812bf9b5c50b598850d94ccf95d7ba21f090c64827b41decd680ee19fcbb494007cdd7f5d0d8906bfc9eceddd8fa583e753e736ecd462d4682fb
+  languageName: node
+  linkType: hard
+
+"jest-runtime@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-runtime@npm:29.7.0"
+  dependencies:
+    "@jest/environment": ^29.7.0
+    "@jest/fake-timers": ^29.7.0
+    "@jest/globals": ^29.7.0
+    "@jest/source-map": ^29.6.3
+    "@jest/test-result": ^29.7.0
+    "@jest/transform": ^29.7.0
+    "@jest/types": ^29.6.3
+    "@types/node": "*"
+    chalk: ^4.0.0
+    cjs-module-lexer: ^1.0.0
+    collect-v8-coverage: ^1.0.0
+    glob: ^7.1.3
+    graceful-fs: ^4.2.9
+    jest-haste-map: ^29.7.0
+    jest-message-util: ^29.7.0
+    jest-mock: ^29.7.0
+    jest-regex-util: ^29.6.3
+    jest-resolve: ^29.7.0
+    jest-snapshot: ^29.7.0
+    jest-util: ^29.7.0
+    slash: ^3.0.0
+    strip-bom: ^4.0.0
+  checksum: d19f113d013e80691e07047f68e1e3448ef024ff2c6b586ce4f90cd7d4c62a2cd1d460110491019719f3c59bfebe16f0e201ed005ef9f80e2cf798c374eed54e
+  languageName: node
+  linkType: hard
+
+"jest-snapshot@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-snapshot@npm:29.7.0"
+  dependencies:
+    "@babel/core": ^7.11.6
+    "@babel/generator": ^7.7.2
+    "@babel/plugin-syntax-jsx": ^7.7.2
+    "@babel/plugin-syntax-typescript": ^7.7.2
+    "@babel/types": ^7.3.3
+    "@jest/expect-utils": ^29.7.0
+    "@jest/transform": ^29.7.0
+    "@jest/types": ^29.6.3
+    babel-preset-current-node-syntax: ^1.0.0
+    chalk: ^4.0.0
+    expect: ^29.7.0
+    graceful-fs: ^4.2.9
+    jest-diff: ^29.7.0
+    jest-get-type: ^29.6.3
+    jest-matcher-utils: ^29.7.0
+    jest-message-util: ^29.7.0
+    jest-util: ^29.7.0
+    natural-compare: ^1.4.0
+    pretty-format: ^29.7.0
+    semver: ^7.5.3
+  checksum: 86821c3ad0b6899521ce75ee1ae7b01b17e6dfeff9166f2cf17f012e0c5d8c798f30f9e4f8f7f5bed01ea7b55a6bc159f5eda778311162cbfa48785447c237ad
+  languageName: node
+  linkType: hard
+
+"jest-util@npm:^29.0.0, jest-util@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-util@npm:29.7.0"
+  dependencies:
+    "@jest/types": ^29.6.3
+    "@types/node": "*"
+    chalk: ^4.0.0
+    ci-info: ^3.2.0
+    graceful-fs: ^4.2.9
+    picomatch: ^2.2.3
+  checksum: 042ab4980f4ccd4d50226e01e5c7376a8556b472442ca6091a8f102488c0f22e6e8b89ea874111d2328a2080083bf3225c86f3788c52af0bd0345a00eb57a3ca
+  languageName: node
+  linkType: hard
+
+"jest-validate@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-validate@npm:29.7.0"
+  dependencies:
+    "@jest/types": ^29.6.3
+    camelcase: ^6.2.0
+    chalk: ^4.0.0
+    jest-get-type: ^29.6.3
+    leven: ^3.1.0
+    pretty-format: ^29.7.0
+  checksum: 191fcdc980f8a0de4dbdd879fa276435d00eb157a48683af7b3b1b98b0f7d9de7ffe12689b617779097ff1ed77601b9f7126b0871bba4f776e222c40f62e9dae
+  languageName: node
+  linkType: hard
+
+"jest-watcher@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-watcher@npm:29.7.0"
+  dependencies:
+    "@jest/test-result": ^29.7.0
+    "@jest/types": ^29.6.3
+    "@types/node": "*"
+    ansi-escapes: ^4.2.1
+    chalk: ^4.0.0
+    emittery: ^0.13.1
+    jest-util: ^29.7.0
+    string-length: ^4.0.1
+  checksum: 67e6e7fe695416deff96b93a14a561a6db69389a0667e9489f24485bb85e5b54e12f3b2ba511ec0b777eca1e727235b073e3ebcdd473d68888650489f88df92f
+  languageName: node
+  linkType: hard
+
+"jest-worker@npm:^27.4.5":
+  version: 27.5.1
+  resolution: "jest-worker@npm:27.5.1"
+  dependencies:
+    "@types/node": "*"
+    merge-stream: ^2.0.0
+    supports-color: ^8.0.0
+  checksum: 98cd68b696781caed61c983a3ee30bf880b5bd021c01d98f47b143d4362b85d0737f8523761e2713d45e18b4f9a2b98af1eaee77afade4111bb65c77d6f7c980
+  languageName: node
+  linkType: hard
+
+"jest-worker@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest-worker@npm:29.7.0"
+  dependencies:
+    "@types/node": "*"
+    jest-util: ^29.7.0
+    merge-stream: ^2.0.0
+    supports-color: ^8.0.0
+  checksum: 30fff60af49675273644d408b650fc2eb4b5dcafc5a0a455f238322a8f9d8a98d847baca9d51ff197b6747f54c7901daa2287799230b856a0f48287d131f8c13
+  languageName: node
+  linkType: hard
+
+"jest@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "jest@npm:29.7.0"
+  dependencies:
+    "@jest/core": ^29.7.0
+    "@jest/types": ^29.6.3
+    import-local: ^3.0.2
+    jest-cli: ^29.7.0
+  peerDependencies:
+    node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+  peerDependenciesMeta:
+    node-notifier:
+      optional: true
+  bin:
+    jest: bin/jest.js
+  checksum: 17ca8d67504a7dbb1998cf3c3077ec9031ba3eb512da8d71cb91bcabb2b8995c4e4b292b740cb9bf1cbff5ce3e110b3f7c777b0cefb6f41ab05445f248d0ee0b
+  languageName: node
+  linkType: hard
+
+"jquery@npm:^3.1.1":
+  version: 3.7.1
+  resolution: "jquery@npm:3.7.1"
+  checksum: 4370b8139d6ae82867eb6f7f21d1edccf1d1bdf41c0840920ea80d366c2cd5dbe1ceebb110ee9772aa839b04400faa1572c5c560b507c688ed7b61cea26c0e27
+  languageName: node
+  linkType: hard
+
+"js-tokens@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "js-tokens@npm:4.0.0"
+  checksum: 8a95213a5a77deb6cbe94d86340e8d9ace2b93bc367790b260101d2f36a2eaf4e4e22d9fa9cf459b38af3a32fb4190e638024cf82ec95ef708680e405ea7cc78
+  languageName: node
+  linkType: hard
+
+"js-yaml@npm:^3.13.1":
+  version: 3.14.1
+  resolution: "js-yaml@npm:3.14.1"
+  dependencies:
+    argparse: ^1.0.7
+    esprima: ^4.0.0
+  bin:
+    js-yaml: bin/js-yaml.js
+  checksum: bef146085f472d44dee30ec34e5cf36bf89164f5d585435a3d3da89e52622dff0b188a580e4ad091c3341889e14cb88cac6e4deb16dc5b1e9623bb0601fc255c
+  languageName: node
+  linkType: hard
+
+"js-yaml@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "js-yaml@npm:4.1.0"
+  dependencies:
+    argparse: ^2.0.1
+  bin:
+    js-yaml: bin/js-yaml.js
+  checksum: c7830dfd456c3ef2c6e355cc5a92e6700ceafa1d14bba54497b34a99f0376cecbb3e9ac14d3e5849b426d5a5140709a66237a8c991c675431271c4ce5504151a
+  languageName: node
+  linkType: hard
+
+"jsbn@npm:1.1.0":
+  version: 1.1.0
+  resolution: "jsbn@npm:1.1.0"
+  checksum: 944f924f2bd67ad533b3850eee47603eed0f6ae425fd1ee8c760f477e8c34a05f144c1bd4f5a5dd1963141dc79a2c55f89ccc5ab77d039e7077f3ad196b64965
+  languageName: node
+  linkType: hard
+
+"jsdom@npm:^20.0.0":
+  version: 20.0.3
+  resolution: "jsdom@npm:20.0.3"
+  dependencies:
+    abab: ^2.0.6
+    acorn: ^8.8.1
+    acorn-globals: ^7.0.0
+    cssom: ^0.5.0
+    cssstyle: ^2.3.0
+    data-urls: ^3.0.2
+    decimal.js: ^10.4.2
+    domexception: ^4.0.0
+    escodegen: ^2.0.0
+    form-data: ^4.0.0
+    html-encoding-sniffer: ^3.0.0
+    http-proxy-agent: ^5.0.0
+    https-proxy-agent: ^5.0.1
+    is-potential-custom-element-name: ^1.0.1
+    nwsapi: ^2.2.2
+    parse5: ^7.1.1
+    saxes: ^6.0.0
+    symbol-tree: ^3.2.4
+    tough-cookie: ^4.1.2
+    w3c-xmlserializer: ^4.0.0
+    webidl-conversions: ^7.0.0
+    whatwg-encoding: ^2.0.0
+    whatwg-mimetype: ^3.0.0
+    whatwg-url: ^11.0.0
+    ws: ^8.11.0
+    xml-name-validator: ^4.0.0
+  peerDependencies:
+    canvas: ^2.5.0
+  peerDependenciesMeta:
+    canvas:
+      optional: true
+  checksum: 6e2ae21db397133a061b270c26d2dbc0b9051733ea3b896a7ece78d79f475ff0974f766a413c1198a79c793159119169f2335ddb23150348fbfdcfa6f3105536
+  languageName: node
+  linkType: hard
+
+"jsesc@npm:^3.0.2":
+  version: 3.1.0
+  resolution: "jsesc@npm:3.1.0"
+  bin:
+    jsesc: bin/jsesc
+  checksum: 19c94095ea026725540c0d29da33ab03144f6bcf2d4159e4833d534976e99e0c09c38cefa9a575279a51fc36b31166f8d6d05c9fe2645d5f15851d690b41f17f
+  languageName: node
+  linkType: hard
+
+"jsesc@npm:~3.0.2":
+  version: 3.0.2
+  resolution: "jsesc@npm:3.0.2"
+  bin:
+    jsesc: bin/jsesc
+  checksum: a36d3ca40574a974d9c2063bf68c2b6141c20da8f2a36bd3279fc802563f35f0527a6c828801295bdfb2803952cf2cf387786c2c90ed564f88d5782475abfe3c
+  languageName: node
+  linkType: hard
+
+"json-buffer@npm:3.0.1":
+  version: 3.0.1
+  resolution: "json-buffer@npm:3.0.1"
+  checksum: 9026b03edc2847eefa2e37646c579300a1f3a4586cfb62bf857832b60c852042d0d6ae55d1afb8926163fa54c2b01d83ae24705f34990348bdac6273a29d4581
+  languageName: node
+  linkType: hard
+
+"json-parse-better-errors@npm:^1.0.1":
+  version: 1.0.2
+  resolution: "json-parse-better-errors@npm:1.0.2"
+  checksum: ff2b5ba2a70e88fd97a3cb28c1840144c5ce8fae9cbeeddba15afa333a5c407cf0e42300cd0a2885dbb055227fe68d405070faad941beeffbfde9cf3b2c78c5d
+  languageName: node
+  linkType: hard
+
+"json-parse-even-better-errors@npm:^2.3.0, json-parse-even-better-errors@npm:^2.3.1":
+  version: 2.3.1
+  resolution: "json-parse-even-better-errors@npm:2.3.1"
+  checksum: 798ed4cf3354a2d9ccd78e86d2169515a0097a5c133337807cdf7f1fc32e1391d207ccfc276518cc1d7d8d4db93288b8a50ba4293d212ad1336e52a8ec0a941f
+  languageName: node
+  linkType: hard
+
+"json-schema-compare@npm:^0.2.2":
+  version: 0.2.2
+  resolution: "json-schema-compare@npm:0.2.2"
+  dependencies:
+    lodash: ^4.17.4
+  checksum: dd6f2173857c8e3b77d6ebdfa05bd505bba5b08709ab46b532722f5d1c33b5fee1fc8f3c97d0c0d011db25f9f3b0baf7ab783bb5f55c32abd9f1201760e43c2c
+  languageName: node
+  linkType: hard
+
+"json-schema-merge-allof@npm:^0.8.1":
+  version: 0.8.1
+  resolution: "json-schema-merge-allof@npm:0.8.1"
+  dependencies:
+    compute-lcm: ^1.1.2
+    json-schema-compare: ^0.2.2
+    lodash: ^4.17.20
+  checksum: 82700f6ac77351959138d6b153d77375a8c29cf48d907241b85c8292dd77aabd8cb816400f2b0d17062c4ccc8893832ec4f664ab9c814927ef502e7a595ea873
+  languageName: node
+  linkType: hard
+
+"json-schema-traverse@npm:^0.4.1":
+  version: 0.4.1
+  resolution: "json-schema-traverse@npm:0.4.1"
+  checksum: 7486074d3ba247769fda17d5181b345c9fb7d12e0da98b22d1d71a5db9698d8b4bd900a3ec1a4ffdd60846fc2556274a5c894d0c48795f14cb03aeae7b55260b
+  languageName: node
+  linkType: hard
+
+"json-schema-traverse@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "json-schema-traverse@npm:1.0.0"
+  checksum: 02f2f466cdb0362558b2f1fd5e15cce82ef55d60cd7f8fa828cf35ba74330f8d767fcae5c5c2adb7851fa811766c694b9405810879bc4e1ddd78a7c0e03658ad
+  languageName: node
+  linkType: hard
+
+"json-stable-stringify-without-jsonify@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "json-stable-stringify-without-jsonify@npm:1.0.1"
+  checksum: cff44156ddce9c67c44386ad5cddf91925fe06b1d217f2da9c4910d01f358c6e3989c4d5a02683c7a5667f9727ff05831f7aa8ae66c8ff691c556f0884d49215
+  languageName: node
+  linkType: hard
+
+"json5@npm:^2.1.2, json5@npm:^2.2.3":
+  version: 2.2.3
+  resolution: "json5@npm:2.2.3"
+  bin:
+    json5: lib/cli.js
+  checksum: 2a7436a93393830bce797d4626275152e37e877b265e94ca69c99e3d20c2b9dab021279146a39cdb700e71b2dd32a4cebd1514cd57cee102b1af906ce5040349
+  languageName: node
+  linkType: hard
+
+"jsonfile@npm:^6.0.1":
+  version: 6.1.0
+  resolution: "jsonfile@npm:6.1.0"
+  dependencies:
+    graceful-fs: ^4.1.6
+    universalify: ^2.0.0
+  dependenciesMeta:
+    graceful-fs:
+      optional: true
+  checksum: 7af3b8e1ac8fe7f1eccc6263c6ca14e1966fcbc74b618d3c78a0a2075579487547b94f72b7a1114e844a1e15bb00d440e5d1720bfc4612d790a6f285d5ea8354
+  languageName: node
+  linkType: hard
+
+"jsonpointer@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "jsonpointer@npm:5.0.1"
+  checksum: 0b40f712900ad0c846681ea2db23b6684b9d5eedf55807b4708c656f5894b63507d0e28ae10aa1bddbea551241035afe62b6df0800fc94c2e2806a7f3adecd7c
+  languageName: node
+  linkType: hard
+
+"keyv@npm:^4.5.3":
+  version: 4.5.4
+  resolution: "keyv@npm:4.5.4"
+  dependencies:
+    json-buffer: 3.0.1
+  checksum: 74a24395b1c34bd44ad5cb2b49140d087553e170625240b86755a6604cd65aa16efdbdeae5cdb17ba1284a0fbb25ad06263755dbc71b8d8b06f74232ce3cdd72
+  languageName: node
+  linkType: hard
+
+"kind-of@npm:^6.0.2":
+  version: 6.0.3
+  resolution: "kind-of@npm:6.0.3"
+  checksum: 3ab01e7b1d440b22fe4c31f23d8d38b4d9b91d9f291df683476576493d5dfd2e03848a8b05813dd0c3f0e835bc63f433007ddeceb71f05cb25c45ae1b19c6d3b
+  languageName: node
+  linkType: hard
+
+"kleur@npm:^3.0.3":
+  version: 3.0.3
+  resolution: "kleur@npm:3.0.3"
+  checksum: df82cd1e172f957bae9c536286265a5cdbd5eeca487cb0a3b2a7b41ef959fc61f8e7c0e9aeea9c114ccf2c166b6a8dd45a46fd619c1c569d210ecd2765ad5169
+  languageName: node
+  linkType: hard
+
+"leven@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "leven@npm:3.1.0"
+  checksum: 638401d534585261b6003db9d99afd244dfe82d75ddb6db5c0df412842d5ab30b2ef18de471aaec70fe69a46f17b4ae3c7f01d8a4e6580ef7adb9f4273ad1e55
+  languageName: node
+  linkType: hard
+
+"levn@npm:^0.4.1":
+  version: 0.4.1
+  resolution: "levn@npm:0.4.1"
+  dependencies:
+    prelude-ls: ^1.2.1
+    type-check: ~0.4.0
+  checksum: 12c5021c859bd0f5248561bf139121f0358285ec545ebf48bb3d346820d5c61a4309535c7f387ed7d84361cf821e124ce346c6b7cef8ee09a67c1473b46d0fc4
+  languageName: node
+  linkType: hard
+
+"lib0@npm:^0.2.85, lib0@npm:^0.2.98":
+  version: 0.2.99
+  resolution: "lib0@npm:0.2.99"
+  dependencies:
+    isomorphic.js: ^0.2.4
+  bin:
+    0ecdsa-generate-keypair: bin/0ecdsa-generate-keypair.js
+    0gentesthtml: bin/gentesthtml.js
+    0serve: bin/0serve.js
+  checksum: 240e91bd3098daf310a320f0f662b1532787329a070b7522a1f784358f915eedcd4b57e3c12749f257a4104939f6eb2af3f90311adadc1a01bfc05ca7de71da7
+  languageName: node
+  linkType: hard
+
+"license-webpack-plugin@npm:^2.3.14":
+  version: 2.3.21
+  resolution: "license-webpack-plugin@npm:2.3.21"
+  dependencies:
+    "@types/webpack-sources": ^0.1.5
+    webpack-sources: ^1.2.0
+  peerDependenciesMeta:
+    webpack:
+      optional: true
+  checksum: 6208bd2060d200fbffbcc89702c929d50c5a4a3f2158b046cf813b3f7f728bbbe4611b9fea2d67843bb5e7d64ad9122cc368a19ac73f5c4ad41765e6283bdc0c
+  languageName: node
+  linkType: hard
+
+"lines-and-columns@npm:^1.1.6":
+  version: 1.2.4
+  resolution: "lines-and-columns@npm:1.2.4"
+  checksum: 0c37f9f7fa212b38912b7145e1cd16a5f3cd34d782441c3e6ca653485d326f58b3caccda66efce1c5812bde4961bbde3374fae4b0d11bf1226152337f3894aa5
+  languageName: node
+  linkType: hard
+
+"load-json-file@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "load-json-file@npm:4.0.0"
+  dependencies:
+    graceful-fs: ^4.1.2
+    parse-json: ^4.0.0
+    pify: ^3.0.0
+    strip-bom: ^3.0.0
+  checksum: 8f5d6d93ba64a9620445ee9bde4d98b1eac32cf6c8c2d20d44abfa41a6945e7969456ab5f1ca2fb06ee32e206c9769a20eec7002fe290de462e8c884b6b8b356
+  languageName: node
+  linkType: hard
+
+"loader-runner@npm:^4.2.0":
+  version: 4.3.0
+  resolution: "loader-runner@npm:4.3.0"
+  checksum: a90e00dee9a16be118ea43fec3192d0b491fe03a32ed48a4132eb61d498f5536a03a1315531c19d284392a8726a4ecad71d82044c28d7f22ef62e029bf761569
+  languageName: node
+  linkType: hard
+
+"loader-utils@npm:^2.0.0":
+  version: 2.0.4
+  resolution: "loader-utils@npm:2.0.4"
+  dependencies:
+    big.js: ^5.2.2
+    emojis-list: ^3.0.0
+    json5: ^2.1.2
+  checksum: a5281f5fff1eaa310ad5e1164095689443630f3411e927f95031ab4fb83b4a98f388185bb1fe949e8ab8d4247004336a625e9255c22122b815bb9a4c5d8fc3b7
+  languageName: node
+  linkType: hard
+
+"locate-path@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "locate-path@npm:5.0.0"
+  dependencies:
+    p-locate: ^4.1.0
+  checksum: 83e51725e67517287d73e1ded92b28602e3ae5580b301fe54bfb76c0c723e3f285b19252e375712316774cf52006cb236aed5704692c32db0d5d089b69696e30
+  languageName: node
+  linkType: hard
+
+"locate-path@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "locate-path@npm:6.0.0"
+  dependencies:
+    p-locate: ^5.0.0
+  checksum: 72eb661788a0368c099a184c59d2fee760b3831c9c1c33955e8a19ae4a21b4116e53fa736dc086cdeb9fce9f7cc508f2f92d2d3aae516f133e16a2bb59a39f5a
+  languageName: node
+  linkType: hard
+
+"lodash-es@npm:^4.17.21":
+  version: 4.17.21
+  resolution: "lodash-es@npm:4.17.21"
+  checksum: 05cbffad6e2adbb331a4e16fbd826e7faee403a1a04873b82b42c0f22090f280839f85b95393f487c1303c8a3d2a010048bf06151a6cbe03eee4d388fb0a12d2
+  languageName: node
+  linkType: hard
+
+"lodash.debounce@npm:^4.0.8":
+  version: 4.0.8
+  resolution: "lodash.debounce@npm:4.0.8"
+  checksum: a3f527d22c548f43ae31c861ada88b2637eb48ac6aa3eb56e82d44917971b8aa96fbb37aa60efea674dc4ee8c42074f90f7b1f772e9db375435f6c83a19b3bc6
+  languageName: node
+  linkType: hard
+
+"lodash.memoize@npm:^4.1.2":
+  version: 4.1.2
+  resolution: "lodash.memoize@npm:4.1.2"
+  checksum: 9ff3942feeccffa4f1fafa88d32f0d24fdc62fd15ded5a74a5f950ff5f0c6f61916157246744c620173dddf38d37095a92327d5fd3861e2063e736a5c207d089
+  languageName: node
+  linkType: hard
+
+"lodash.merge@npm:^4.6.2":
+  version: 4.6.2
+  resolution: "lodash.merge@npm:4.6.2"
+  checksum: ad580b4bdbb7ca1f7abf7e1bce63a9a0b98e370cf40194b03380a46b4ed799c9573029599caebc1b14e3f24b111aef72b96674a56cfa105e0f5ac70546cdc005
+  languageName: node
+  linkType: hard
+
+"lodash@npm:^4.17.20, lodash@npm:^4.17.21, lodash@npm:^4.17.4, lodash@npm:^4.7.0":
+  version: 4.17.21
+  resolution: "lodash@npm:4.17.21"
+  checksum: eb835a2e51d381e561e508ce932ea50a8e5a68f4ebdd771ea240d3048244a8d13658acbd502cd4829768c56f2e16bdd4340b9ea141297d472517b83868e677f7
+  languageName: node
+  linkType: hard
+
+"lru-cache@npm:^10.0.1, lru-cache@npm:^10.2.0":
+  version: 10.4.3
+  resolution: "lru-cache@npm:10.4.3"
+  checksum: 6476138d2125387a6d20f100608c2583d415a4f64a0fecf30c9e2dda976614f09cad4baa0842447bd37dd459a7bd27f57d9d8f8ce558805abd487c583f3d774a
+  languageName: node
+  linkType: hard
+
+"lru-cache@npm:^5.1.1":
+  version: 5.1.1
+  resolution: "lru-cache@npm:5.1.1"
+  dependencies:
+    yallist: ^3.0.2
+  checksum: c154ae1cbb0c2206d1501a0e94df349653c92c8cbb25236d7e85190bcaf4567a03ac6eb43166fabfa36fd35623694da7233e88d9601fbf411a9a481d85dbd2cb
+  languageName: node
+  linkType: hard
+
+"make-dir@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "make-dir@npm:4.0.0"
+  dependencies:
+    semver: ^7.5.3
+  checksum: bf0731a2dd3aab4db6f3de1585cea0b746bb73eb5a02e3d8d72757e376e64e6ada190b1eddcde5b2f24a81b688a9897efd5018737d05e02e2a671dda9cff8a8a
+  languageName: node
+  linkType: hard
+
+"make-error@npm:^1.3.6":
+  version: 1.3.6
+  resolution: "make-error@npm:1.3.6"
+  checksum: b86e5e0e25f7f777b77fabd8e2cbf15737972869d852a22b7e73c17623928fccb826d8e46b9951501d3f20e51ad74ba8c59ed584f610526a48f8ccf88aaec402
+  languageName: node
+  linkType: hard
+
+"make-fetch-happen@npm:^14.0.3":
+  version: 14.0.3
+  resolution: "make-fetch-happen@npm:14.0.3"
+  dependencies:
+    "@npmcli/agent": ^3.0.0
+    cacache: ^19.0.1
+    http-cache-semantics: ^4.1.1
+    minipass: ^7.0.2
+    minipass-fetch: ^4.0.0
+    minipass-flush: ^1.0.5
+    minipass-pipeline: ^1.2.4
+    negotiator: ^1.0.0
+    proc-log: ^5.0.0
+    promise-retry: ^2.0.1
+    ssri: ^12.0.0
+  checksum: 6fb2fee6da3d98f1953b03d315826b5c5a4ea1f908481afc113782d8027e19f080c85ae998454de4e5f27a681d3ec58d57278f0868d4e0b736f51d396b661691
+  languageName: node
+  linkType: hard
+
+"makeerror@npm:1.0.12":
+  version: 1.0.12
+  resolution: "makeerror@npm:1.0.12"
+  dependencies:
+    tmpl: 1.0.5
+  checksum: b38a025a12c8146d6eeea5a7f2bf27d51d8ad6064da8ca9405fcf7bf9b54acd43e3b30ddd7abb9b1bfa4ddb266019133313482570ddb207de568f71ecfcf6060
+  languageName: node
+  linkType: hard
+
+"math-intrinsics@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "math-intrinsics@npm:1.0.0"
+  checksum: ad9edf8b5bec32c78d25163a9343dbe960331c8b4815b099181de7be4681e5abff9642a4b2fbeb3e882d7616567ffc45a5bae59dc8fec417cf5c76d47b92b197
+  languageName: node
+  linkType: hard
+
+"memorystream@npm:^0.3.1":
+  version: 0.3.1
+  resolution: "memorystream@npm:0.3.1"
+  checksum: f18b42440d24d09516d01466c06adf797df7873f0d40aa7db02e5fb9ed83074e5e65412d0720901d7069363465f82dc4f8bcb44f0cde271567a61426ce6ca2e9
+  languageName: node
+  linkType: hard
+
+"merge-stream@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "merge-stream@npm:2.0.0"
+  checksum: 6fa4dcc8d86629705cea944a4b88ef4cb0e07656ebf223fa287443256414283dd25d91c1cd84c77987f2aec5927af1a9db6085757cb43d90eb170ebf4b47f4f4
+  languageName: node
+  linkType: hard
+
+"merge2@npm:^1.3.0, merge2@npm:^1.4.1":
+  version: 1.4.1
+  resolution: "merge2@npm:1.4.1"
+  checksum: 7268db63ed5169466540b6fb947aec313200bcf6d40c5ab722c22e242f651994619bcd85601602972d3c85bd2cc45a358a4c61937e9f11a061919a1da569b0c2
+  languageName: node
+  linkType: hard
+
+"micromatch@npm:^4.0.0, micromatch@npm:^4.0.4":
+  version: 4.0.8
+  resolution: "micromatch@npm:4.0.8"
+  dependencies:
+    braces: ^3.0.3
+    picomatch: ^2.3.1
+  checksum: 79920eb634e6f400b464a954fcfa589c4e7c7143209488e44baf627f9affc8b1e306f41f4f0deedde97e69cb725920879462d3e750ab3bd3c1aed675bb3a8966
+  languageName: node
+  linkType: hard
+
+"mime-db@npm:1.52.0":
+  version: 1.52.0
+  resolution: "mime-db@npm:1.52.0"
+  checksum: 0d99a03585f8b39d68182803b12ac601d9c01abfa28ec56204fa330bc9f3d1c5e14beb049bafadb3dbdf646dfb94b87e24d4ec7b31b7279ef906a8ea9b6a513f
+  languageName: node
+  linkType: hard
+
+"mime-types@npm:^2.1.12, mime-types@npm:^2.1.27":
+  version: 2.1.35
+  resolution: "mime-types@npm:2.1.35"
+  dependencies:
+    mime-db: 1.52.0
+  checksum: 89a5b7f1def9f3af5dad6496c5ed50191ae4331cc5389d7c521c8ad28d5fdad2d06fd81baf38fed813dc4e46bb55c8145bb0ff406330818c9cf712fb2e9b3836
+  languageName: node
+  linkType: hard
+
+"mimic-fn@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "mimic-fn@npm:2.1.0"
+  checksum: d2421a3444848ce7f84bd49115ddacff29c15745db73f54041edc906c14b131a38d05298dae3081667627a59b2eb1ca4b436ff2e1b80f69679522410418b478a
+  languageName: node
+  linkType: hard
+
+"mini-css-extract-plugin@npm:^2.7.0":
+  version: 2.9.2
+  resolution: "mini-css-extract-plugin@npm:2.9.2"
+  dependencies:
+    schema-utils: ^4.0.0
+    tapable: ^2.2.1
+  peerDependencies:
+    webpack: ^5.0.0
+  checksum: 67a1f75359371a7776108999d472ae0942ccd904401e364e3a2c710d4b6fec61c4f53288594fcac35891f009e6df8825a00dfd3bfe4bcec0f862081d1f7cad50
+  languageName: node
+  linkType: hard
+
+"mini-svg-data-uri@npm:^1.4.4":
+  version: 1.4.4
+  resolution: "mini-svg-data-uri@npm:1.4.4"
+  bin:
+    mini-svg-data-uri: cli.js
+  checksum: 997f1fbd8d59a70f03761e18626d335197a3479cb9d1ff75678e4b64b864d32a0b8fc18115eabde035e5299b8b4a354a78e57dd6ac10f9d604162a6170898d09
+  languageName: node
+  linkType: hard
+
+"minimatch@npm:9.0.3":
+  version: 9.0.3
+  resolution: "minimatch@npm:9.0.3"
+  dependencies:
+    brace-expansion: ^2.0.1
+  checksum: 253487976bf485b612f16bf57463520a14f512662e592e95c571afdab1442a6a6864b6c88f248ce6fc4ff0b6de04ac7aa6c8bb51e868e99d1d65eb0658a708b5
+  languageName: node
+  linkType: hard
+
+"minimatch@npm:^3.0.4, minimatch@npm:^3.0.5, minimatch@npm:^3.1.1, minimatch@npm:^3.1.2":
+  version: 3.1.2
+  resolution: "minimatch@npm:3.1.2"
+  dependencies:
+    brace-expansion: ^1.1.7
+  checksum: c154e566406683e7bcb746e000b84d74465b3a832c45d59912b9b55cd50dee66e5c4b1e5566dba26154040e51672f9aa450a9aef0c97cfc7336b78b7afb9540a
+  languageName: node
+  linkType: hard
+
+"minimatch@npm:^5.0.1":
+  version: 5.1.6
+  resolution: "minimatch@npm:5.1.6"
+  dependencies:
+    brace-expansion: ^2.0.1
+  checksum: 7564208ef81d7065a370f788d337cd80a689e981042cb9a1d0e6580b6c6a8c9279eba80010516e258835a988363f99f54a6f711a315089b8b42694f5da9d0d77
+  languageName: node
+  linkType: hard
+
+"minimatch@npm:^9.0.4":
+  version: 9.0.5
+  resolution: "minimatch@npm:9.0.5"
+  dependencies:
+    brace-expansion: ^2.0.1
+  checksum: 2c035575eda1e50623c731ec6c14f65a85296268f749b9337005210bb2b34e2705f8ef1a358b188f69892286ab99dc42c8fb98a57bde55c8d81b3023c19cea28
+  languageName: node
+  linkType: hard
+
+"minimist@npm:~1.2.0":
+  version: 1.2.8
+  resolution: "minimist@npm:1.2.8"
+  checksum: 75a6d645fb122dad29c06a7597bddea977258957ed88d7a6df59b5cd3fe4a527e253e9bbf2e783e4b73657f9098b96a5fe96ab8a113655d4109108577ecf85b0
+  languageName: node
+  linkType: hard
+
+"minipass-collect@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "minipass-collect@npm:2.0.1"
+  dependencies:
+    minipass: ^7.0.3
+  checksum: b251bceea62090f67a6cced7a446a36f4cd61ee2d5cea9aee7fff79ba8030e416327a1c5aa2908dc22629d06214b46d88fdab8c51ac76bacbf5703851b5ad342
+  languageName: node
+  linkType: hard
+
+"minipass-fetch@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "minipass-fetch@npm:4.0.0"
+  dependencies:
+    encoding: ^0.1.13
+    minipass: ^7.0.3
+    minipass-sized: ^1.0.3
+    minizlib: ^3.0.1
+  dependenciesMeta:
+    encoding:
+      optional: true
+  checksum: 7d59a31011ab9e4d1af6562dd4c4440e425b2baf4c5edbdd2e22fb25a88629e1cdceca39953ff209da504a46021df520f18fd9a519f36efae4750ff724ddadea
+  languageName: node
+  linkType: hard
+
+"minipass-flush@npm:^1.0.5":
+  version: 1.0.5
+  resolution: "minipass-flush@npm:1.0.5"
+  dependencies:
+    minipass: ^3.0.0
+  checksum: 56269a0b22bad756a08a94b1ffc36b7c9c5de0735a4dd1ab2b06c066d795cfd1f0ac44a0fcae13eece5589b908ecddc867f04c745c7009be0b566421ea0944cf
+  languageName: node
+  linkType: hard
+
+"minipass-pipeline@npm:^1.2.4":
+  version: 1.2.4
+  resolution: "minipass-pipeline@npm:1.2.4"
+  dependencies:
+    minipass: ^3.0.0
+  checksum: b14240dac0d29823c3d5911c286069e36d0b81173d7bdf07a7e4a91ecdef92cdff4baaf31ea3746f1c61e0957f652e641223970870e2353593f382112257971b
+  languageName: node
+  linkType: hard
+
+"minipass-sized@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "minipass-sized@npm:1.0.3"
+  dependencies:
+    minipass: ^3.0.0
+  checksum: 79076749fcacf21b5d16dd596d32c3b6bf4d6e62abb43868fac21674078505c8b15eaca4e47ed844985a4514854f917d78f588fcd029693709417d8f98b2bd60
+  languageName: node
+  linkType: hard
+
+"minipass@npm:^3.0.0":
+  version: 3.3.6
+  resolution: "minipass@npm:3.3.6"
+  dependencies:
+    yallist: ^4.0.0
+  checksum: a30d083c8054cee83cdcdc97f97e4641a3f58ae743970457b1489ce38ee1167b3aaf7d815cd39ec7a99b9c40397fd4f686e83750e73e652b21cb516f6d845e48
+  languageName: node
+  linkType: hard
+
+"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3, minipass@npm:^7.0.4, minipass@npm:^7.1.2":
+  version: 7.1.2
+  resolution: "minipass@npm:7.1.2"
+  checksum: 2bfd325b95c555f2b4d2814d49325691c7bee937d753814861b0b49d5edcda55cbbf22b6b6a60bb91eddac8668771f03c5ff647dcd9d0f798e9548b9cdc46ee3
+  languageName: node
+  linkType: hard
+
+"minizlib@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "minizlib@npm:3.0.1"
+  dependencies:
+    minipass: ^7.0.4
+    rimraf: ^5.0.5
+  checksum: da0a53899252380475240c587e52c824f8998d9720982ba5c4693c68e89230718884a209858c156c6e08d51aad35700a3589987e540593c36f6713fe30cd7338
+  languageName: node
+  linkType: hard
+
+"mkdirp@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "mkdirp@npm:3.0.1"
+  bin:
+    mkdirp: dist/cjs/src/bin.js
+  checksum: 972deb188e8fb55547f1e58d66bd6b4a3623bf0c7137802582602d73e6480c1c2268dcbafbfb1be466e00cc7e56ac514d7fd9334b7cf33e3e2ab547c16f83a8d
+  languageName: node
+  linkType: hard
+
+"ms@npm:^2.1.3":
+  version: 2.1.3
+  resolution: "ms@npm:2.1.3"
+  checksum: aa92de608021b242401676e35cfa5aa42dd70cbdc082b916da7fb925c542173e36bce97ea3e804923fe92c0ad991434e4a38327e15a1b5b5f945d66df615ae6d
+  languageName: node
+  linkType: hard
+
+"nanoid@npm:^3.3.7":
+  version: 3.3.8
+  resolution: "nanoid@npm:3.3.8"
+  bin:
+    nanoid: bin/nanoid.cjs
+  checksum: dfe0adbc0c77e9655b550c333075f51bb28cfc7568afbf3237249904f9c86c9aaaed1f113f0fddddba75673ee31c758c30c43d4414f014a52a7a626efc5958c9
+  languageName: node
+  linkType: hard
+
+"natural-compare@npm:^1.4.0":
+  version: 1.4.0
+  resolution: "natural-compare@npm:1.4.0"
+  checksum: 23ad088b08f898fc9b53011d7bb78ec48e79de7627e01ab5518e806033861bef68d5b0cd0e2205c2f36690ac9571ff6bcb05eb777ced2eeda8d4ac5b44592c3d
+  languageName: node
+  linkType: hard
+
+"negotiator@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "negotiator@npm:1.0.0"
+  checksum: 20ebfe79b2d2e7cf9cbc8239a72662b584f71164096e6e8896c8325055497c96f6b80cd22c258e8a2f2aa382a787795ec3ee8b37b422a302c7d4381b0d5ecfbb
+  languageName: node
+  linkType: hard
+
+"neo-async@npm:^2.6.2":
+  version: 2.6.2
+  resolution: "neo-async@npm:2.6.2"
+  checksum: deac9f8d00eda7b2e5cd1b2549e26e10a0faa70adaa6fdadca701cc55f49ee9018e427f424bac0c790b7c7e2d3068db97f3093f1093975f2acb8f8818b936ed9
+  languageName: node
+  linkType: hard
+
+"nice-try@npm:^1.0.4":
+  version: 1.0.5
+  resolution: "nice-try@npm:1.0.5"
+  checksum: 0b4af3b5bb5d86c289f7a026303d192a7eb4417231fe47245c460baeabae7277bcd8fd9c728fb6bd62c30b3e15cd6620373e2cf33353b095d8b403d3e8a15aff
+  languageName: node
+  linkType: hard
+
+"node-gyp@npm:latest":
+  version: 11.0.0
+  resolution: "node-gyp@npm:11.0.0"
+  dependencies:
+    env-paths: ^2.2.0
+    exponential-backoff: ^3.1.1
+    glob: ^10.3.10
+    graceful-fs: ^4.2.6
+    make-fetch-happen: ^14.0.3
+    nopt: ^8.0.0
+    proc-log: ^5.0.0
+    semver: ^7.3.5
+    tar: ^7.4.3
+    which: ^5.0.0
+  bin:
+    node-gyp: bin/node-gyp.js
+  checksum: d7d5055ccc88177f721c7cd4f8f9440c29a0eb40e7b79dba89ef882ec957975dfc1dcb8225e79ab32481a02016eb13bbc051a913ea88d482d3cbdf2131156af4
+  languageName: node
+  linkType: hard
+
+"node-int64@npm:^0.4.0":
+  version: 0.4.0
+  resolution: "node-int64@npm:0.4.0"
+  checksum: d0b30b1ee6d961851c60d5eaa745d30b5c95d94bc0e74b81e5292f7c42a49e3af87f1eb9e89f59456f80645d679202537de751b7d72e9e40ceea40c5e449057e
+  languageName: node
+  linkType: hard
+
+"node-releases@npm:^2.0.19":
+  version: 2.0.19
+  resolution: "node-releases@npm:2.0.19"
+  checksum: 917dbced519f48c6289a44830a0ca6dc944c3ee9243c468ebd8515a41c97c8b2c256edb7f3f750416bc37952cc9608684e6483c7b6c6f39f6bd8d86c52cfe658
+  languageName: node
+  linkType: hard
+
+"nopt@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "nopt@npm:8.0.0"
+  dependencies:
+    abbrev: ^2.0.0
+  bin:
+    nopt: bin/nopt.js
+  checksum: 2cfc65e7ee38af2e04aea98f054753b0230011c0eeca4ecf131bd7d25984cbbf6f214586e0ae5dfcc2e830bc0bffa5a7fb28ea8d0b306ffd4ae8ea2d814c1ab3
+  languageName: node
+  linkType: hard
+
+"normalize-package-data@npm:^2.3.2":
+  version: 2.5.0
+  resolution: "normalize-package-data@npm:2.5.0"
+  dependencies:
+    hosted-git-info: ^2.1.4
+    resolve: ^1.10.0
+    semver: 2 || 3 || 4 || 5
+    validate-npm-package-license: ^3.0.1
+  checksum: 7999112efc35a6259bc22db460540cae06564aa65d0271e3bdfa86876d08b0e578b7b5b0028ee61b23f1cae9fc0e7847e4edc0948d3068a39a2a82853efc8499
+  languageName: node
+  linkType: hard
+
+"normalize-path@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "normalize-path@npm:3.0.0"
+  checksum: 88eeb4da891e10b1318c4b2476b6e2ecbeb5ff97d946815ffea7794c31a89017c70d7f34b3c2ebf23ef4e9fc9fb99f7dffe36da22011b5b5c6ffa34f4873ec20
+  languageName: node
+  linkType: hard
+
+"npm-run-all@npm:^4.1.5":
+  version: 4.1.5
+  resolution: "npm-run-all@npm:4.1.5"
+  dependencies:
+    ansi-styles: ^3.2.1
+    chalk: ^2.4.1
+    cross-spawn: ^6.0.5
+    memorystream: ^0.3.1
+    minimatch: ^3.0.4
+    pidtree: ^0.3.0
+    read-pkg: ^3.0.0
+    shell-quote: ^1.6.1
+    string.prototype.padend: ^3.0.0
+  bin:
+    npm-run-all: bin/npm-run-all/index.js
+    run-p: bin/run-p/index.js
+    run-s: bin/run-s/index.js
+  checksum: 373b72c6a36564da13c1642c1fd9bb4dcc756bce7a3648f883772f02661095319820834ff813762d2fee403e9b40c1cd27c8685807c107440f10eb19c006d4a0
+  languageName: node
+  linkType: hard
+
+"npm-run-path@npm:^4.0.1":
+  version: 4.0.1
+  resolution: "npm-run-path@npm:4.0.1"
+  dependencies:
+    path-key: ^3.0.0
+  checksum: 5374c0cea4b0bbfdfae62da7bbdf1e1558d338335f4cacf2515c282ff358ff27b2ecb91ffa5330a8b14390ac66a1e146e10700440c1ab868208430f56b5f4d23
+  languageName: node
+  linkType: hard
+
+"nwsapi@npm:^2.2.2":
+  version: 2.2.16
+  resolution: "nwsapi@npm:2.2.16"
+  checksum: 467b36a74b7b8647d53fd61d05ca7d6c73a4a5d1b94ea84f770c03150b00ef46d38076cf8e708936246ae450c42a1f21e28e153023719784dc4d1a19b1737d47
+  languageName: node
+  linkType: hard
+
+"object-inspect@npm:^1.13.3":
+  version: 1.13.3
+  resolution: "object-inspect@npm:1.13.3"
+  checksum: 8c962102117241e18ea403b84d2521f78291b774b03a29ee80a9863621d88265ffd11d0d7e435c4c2cea0dc2a2fbf8bbc92255737a05536590f2df2e8756f297
+  languageName: node
+  linkType: hard
+
+"object-keys@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "object-keys@npm:1.1.1"
+  checksum: b363c5e7644b1e1b04aa507e88dcb8e3a2f52b6ffd0ea801e4c7a62d5aa559affe21c55a07fd4b1fd55fc03a33c610d73426664b20032405d7b92a1414c34d6a
+  languageName: node
+  linkType: hard
+
+"object.assign@npm:^4.1.5":
+  version: 4.1.7
+  resolution: "object.assign@npm:4.1.7"
+  dependencies:
+    call-bind: ^1.0.8
+    call-bound: ^1.0.3
+    define-properties: ^1.2.1
+    es-object-atoms: ^1.0.0
+    has-symbols: ^1.1.0
+    object-keys: ^1.1.1
+  checksum: 60e07d2651cf4f5528c485f1aa4dbded9b384c47d80e8187cefd11320abb1aebebf78df5483451dfa549059f8281c21f7b4bf7d19e9e5e97d8d617df0df298de
+  languageName: node
+  linkType: hard
+
+"once@npm:^1.3.0":
+  version: 1.4.0
+  resolution: "once@npm:1.4.0"
+  dependencies:
+    wrappy: 1
+  checksum: cd0a88501333edd640d95f0d2700fbde6bff20b3d4d9bdc521bdd31af0656b5706570d6c6afe532045a20bb8dc0849f8332d6f2a416e0ba6d3d3b98806c7db68
+  languageName: node
+  linkType: hard
+
+"onetime@npm:^5.1.2":
+  version: 5.1.2
+  resolution: "onetime@npm:5.1.2"
+  dependencies:
+    mimic-fn: ^2.1.0
+  checksum: 2478859ef817fc5d4e9c2f9e5728512ddd1dbc9fb7829ad263765bb6d3b91ce699d6e2332eef6b7dff183c2f490bd3349f1666427eaba4469fba0ac38dfd0d34
+  languageName: node
+  linkType: hard
+
+"optionator@npm:^0.9.3":
+  version: 0.9.4
+  resolution: "optionator@npm:0.9.4"
+  dependencies:
+    deep-is: ^0.1.3
+    fast-levenshtein: ^2.0.6
+    levn: ^0.4.1
+    prelude-ls: ^1.2.1
+    type-check: ^0.4.0
+    word-wrap: ^1.2.5
+  checksum: ecbd010e3dc73e05d239976422d9ef54a82a13f37c11ca5911dff41c98a6c7f0f163b27f922c37e7f8340af9d36febd3b6e9cef508f3339d4c393d7276d716bb
+  languageName: node
+  linkType: hard
+
+"p-limit@npm:^2.2.0":
+  version: 2.3.0
+  resolution: "p-limit@npm:2.3.0"
+  dependencies:
+    p-try: ^2.0.0
+  checksum: 84ff17f1a38126c3314e91ecfe56aecbf36430940e2873dadaa773ffe072dc23b7af8e46d4b6485d302a11673fe94c6b67ca2cfbb60c989848b02100d0594ac1
+  languageName: node
+  linkType: hard
+
+"p-limit@npm:^3.0.2, p-limit@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "p-limit@npm:3.1.0"
+  dependencies:
+    yocto-queue: ^0.1.0
+  checksum: 7c3690c4dbf62ef625671e20b7bdf1cbc9534e83352a2780f165b0d3ceba21907e77ad63401708145ca4e25bfc51636588d89a8c0aeb715e6c37d1c066430360
+  languageName: node
+  linkType: hard
+
+"p-locate@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "p-locate@npm:4.1.0"
+  dependencies:
+    p-limit: ^2.2.0
+  checksum: 513bd14a455f5da4ebfcb819ef706c54adb09097703de6aeaa5d26fe5ea16df92b48d1ac45e01e3944ce1e6aa2a66f7f8894742b8c9d6e276e16cd2049a2b870
+  languageName: node
+  linkType: hard
+
+"p-locate@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "p-locate@npm:5.0.0"
+  dependencies:
+    p-limit: ^3.0.2
+  checksum: 1623088f36cf1cbca58e9b61c4e62bf0c60a07af5ae1ca99a720837356b5b6c5ba3eb1b2127e47a06865fee59dd0453cad7cc844cda9d5a62ac1a5a51b7c86d3
+  languageName: node
+  linkType: hard
+
+"p-map@npm:^7.0.2":
+  version: 7.0.3
+  resolution: "p-map@npm:7.0.3"
+  checksum: 8c92d533acf82f0d12f7e196edccff773f384098bbb048acdd55a08778ce4fc8889d8f1bde72969487bd96f9c63212698d79744c20bedfce36c5b00b46d369f8
+  languageName: node
+  linkType: hard
+
+"p-try@npm:^2.0.0":
+  version: 2.2.0
+  resolution: "p-try@npm:2.2.0"
+  checksum: f8a8e9a7693659383f06aec604ad5ead237c7a261c18048a6e1b5b85a5f8a067e469aa24f5bc009b991ea3b058a87f5065ef4176793a200d4917349881216cae
+  languageName: node
+  linkType: hard
+
+"package-json-from-dist@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "package-json-from-dist@npm:1.0.1"
+  checksum: 58ee9538f2f762988433da00e26acc788036914d57c71c246bf0be1b60cdbd77dd60b6a3e1a30465f0b248aeb80079e0b34cb6050b1dfa18c06953bb1cbc7602
+  languageName: node
+  linkType: hard
+
+"parent-module@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "parent-module@npm:1.0.1"
+  dependencies:
+    callsites: ^3.0.0
+  checksum: 6ba8b255145cae9470cf5551eb74be2d22281587af787a2626683a6c20fbb464978784661478dd2a3f1dad74d1e802d403e1b03c1a31fab310259eec8ac560ff
+  languageName: node
+  linkType: hard
+
+"parse-json@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "parse-json@npm:4.0.0"
+  dependencies:
+    error-ex: ^1.3.1
+    json-parse-better-errors: ^1.0.1
+  checksum: 0fe227d410a61090c247e34fa210552b834613c006c2c64d9a05cfe9e89cf8b4246d1246b1a99524b53b313e9ac024438d0680f67e33eaed7e6f38db64cfe7b5
+  languageName: node
+  linkType: hard
+
+"parse-json@npm:^5.2.0":
+  version: 5.2.0
+  resolution: "parse-json@npm:5.2.0"
+  dependencies:
+    "@babel/code-frame": ^7.0.0
+    error-ex: ^1.3.1
+    json-parse-even-better-errors: ^2.3.0
+    lines-and-columns: ^1.1.6
+  checksum: 62085b17d64da57f40f6afc2ac1f4d95def18c4323577e1eced571db75d9ab59b297d1d10582920f84b15985cbfc6b6d450ccbf317644cfa176f3ed982ad87e2
+  languageName: node
+  linkType: hard
+
+"parse-srcset@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "parse-srcset@npm:1.0.2"
+  checksum: 3a0380380c6082021fcce982f0b89fb8a493ce9dfd7d308e5e6d855201e80db8b90438649b31fdd82a3d6089a8ca17dccddaa2b730a718389af4c037b8539ebf
+  languageName: node
+  linkType: hard
+
+"parse5@npm:^7.0.0, parse5@npm:^7.1.1":
+  version: 7.2.1
+  resolution: "parse5@npm:7.2.1"
+  dependencies:
+    entities: ^4.5.0
+  checksum: 11253cf8aa2e7fc41c004c64cba6f2c255f809663365db65bd7ad0e8cf7b89e436a563c20059346371cc543a6c1b567032088883ca6a2cbc88276c666b68236d
+  languageName: node
+  linkType: hard
+
+"path-browserify@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "path-browserify@npm:1.0.1"
+  checksum: c6d7fa376423fe35b95b2d67990060c3ee304fc815ff0a2dc1c6c3cfaff2bd0d572ee67e18f19d0ea3bbe32e8add2a05021132ac40509416459fffee35200699
+  languageName: node
+  linkType: hard
+
+"path-exists@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "path-exists@npm:4.0.0"
+  checksum: 505807199dfb7c50737b057dd8d351b82c033029ab94cb10a657609e00c1bc53b951cfdbccab8de04c5584d5eff31128ce6afd3db79281874a5ef2adbba55ed1
+  languageName: node
+  linkType: hard
+
+"path-is-absolute@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "path-is-absolute@npm:1.0.1"
+  checksum: 060840f92cf8effa293bcc1bea81281bd7d363731d214cbe5c227df207c34cd727430f70c6037b5159c8a870b9157cba65e775446b0ab06fd5ecc7e54615a3b8
+  languageName: node
+  linkType: hard
+
+"path-key@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "path-key@npm:2.0.1"
+  checksum: f7ab0ad42fe3fb8c7f11d0c4f849871e28fbd8e1add65c370e422512fc5887097b9cf34d09c1747d45c942a8c1e26468d6356e2df3f740bf177ab8ca7301ebfd
+  languageName: node
+  linkType: hard
+
+"path-key@npm:^3.0.0, path-key@npm:^3.1.0":
+  version: 3.1.1
+  resolution: "path-key@npm:3.1.1"
+  checksum: 55cd7a9dd4b343412a8386a743f9c746ef196e57c823d90ca3ab917f90ab9f13dd0ded27252ba49dbdfcab2b091d998bc446f6220cd3cea65db407502a740020
+  languageName: node
+  linkType: hard
+
+"path-parse@npm:^1.0.7":
+  version: 1.0.7
+  resolution: "path-parse@npm:1.0.7"
+  checksum: 49abf3d81115642938a8700ec580da6e830dde670be21893c62f4e10bd7dd4c3742ddc603fe24f898cba7eb0c6bc1777f8d9ac14185d34540c6d4d80cd9cae8a
+  languageName: node
+  linkType: hard
+
+"path-scurry@npm:^1.11.1":
+  version: 1.11.1
+  resolution: "path-scurry@npm:1.11.1"
+  dependencies:
+    lru-cache: ^10.2.0
+    minipass: ^5.0.0 || ^6.0.2 || ^7.0.0
+  checksum: 890d5abcd593a7912dcce7cf7c6bf7a0b5648e3dee6caf0712c126ca0a65c7f3d7b9d769072a4d1baf370f61ce493ab5b038d59988688e0c5f3f646ee3c69023
+  languageName: node
+  linkType: hard
+
+"path-type@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "path-type@npm:3.0.0"
+  dependencies:
+    pify: ^3.0.0
+  checksum: 735b35e256bad181f38fa021033b1c33cfbe62ead42bb2222b56c210e42938eecb272ae1949f3b6db4ac39597a61b44edd8384623ec4d79bfdc9a9c0f12537a6
+  languageName: node
+  linkType: hard
+
+"path-type@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "path-type@npm:4.0.0"
+  checksum: 5b1e2daa247062061325b8fdbfd1fb56dde0a448fb1455453276ea18c60685bdad23a445dc148cf87bc216be1573357509b7d4060494a6fd768c7efad833ee45
+  languageName: node
+  linkType: hard
+
+"picocolors@npm:^1.0.0, picocolors@npm:^1.1.0, picocolors@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "picocolors@npm:1.1.1"
+  checksum: e1cf46bf84886c79055fdfa9dcb3e4711ad259949e3565154b004b260cd356c5d54b31a1437ce9782624bf766272fe6b0154f5f0c744fb7af5d454d2b60db045
+  languageName: node
+  linkType: hard
+
+"picomatch@npm:^2.0.4, picomatch@npm:^2.2.3, picomatch@npm:^2.3.1":
+  version: 2.3.1
+  resolution: "picomatch@npm:2.3.1"
+  checksum: 050c865ce81119c4822c45d3c84f1ced46f93a0126febae20737bd05ca20589c564d6e9226977df859ed5e03dc73f02584a2b0faad36e896936238238b0446cf
+  languageName: node
+  linkType: hard
+
+"pidtree@npm:^0.3.0":
+  version: 0.3.1
+  resolution: "pidtree@npm:0.3.1"
+  bin:
+    pidtree: bin/pidtree.js
+  checksum: eb49025099f1af89a4696f7673351421f13420f3397b963c901fe23a1c9c2ff50f4750321970d4472c0ffbb065e4a6c3c27f75e226cc62284b19e21d32ce7012
+  languageName: node
+  linkType: hard
+
+"pify@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "pify@npm:3.0.0"
+  checksum: 6cdcbc3567d5c412450c53261a3f10991665d660961e06605decf4544a61a97a54fefe70a68d5c37080ff9d6f4cf51444c90198d1ba9f9309a6c0d6e9f5c4fde
+  languageName: node
+  linkType: hard
+
+"pirates@npm:^4.0.4":
+  version: 4.0.6
+  resolution: "pirates@npm:4.0.6"
+  checksum: 46a65fefaf19c6f57460388a5af9ab81e3d7fd0e7bc44ca59d753cb5c4d0df97c6c6e583674869762101836d68675f027d60f841c105d72734df9dfca97cbcc6
+  languageName: node
+  linkType: hard
+
+"pkg-dir@npm:^4.2.0":
+  version: 4.2.0
+  resolution: "pkg-dir@npm:4.2.0"
+  dependencies:
+    find-up: ^4.0.0
+  checksum: 9863e3f35132bf99ae1636d31ff1e1e3501251d480336edb1c211133c8d58906bed80f154a1d723652df1fda91e01c7442c2eeaf9dc83157c7ae89087e43c8d6
+  languageName: node
+  linkType: hard
+
+"possible-typed-array-names@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "possible-typed-array-names@npm:1.0.0"
+  checksum: b32d403ece71e042385cc7856385cecf1cd8e144fa74d2f1de40d1e16035dba097bc189715925e79b67bdd1472796ff168d3a90d296356c9c94d272d5b95f3ae
+  languageName: node
+  linkType: hard
+
+"postcss-modules-extract-imports@npm:^3.1.0":
+  version: 3.1.0
+  resolution: "postcss-modules-extract-imports@npm:3.1.0"
+  peerDependencies:
+    postcss: ^8.1.0
+  checksum: b9192e0f4fb3d19431558be6f8af7ca45fc92baaad9b2778d1732a5880cd25c3df2074ce5484ae491e224f0d21345ffc2d419bd51c25b019af76d7a7af88c17f
+  languageName: node
+  linkType: hard
+
+"postcss-modules-local-by-default@npm:^4.0.5":
+  version: 4.2.0
+  resolution: "postcss-modules-local-by-default@npm:4.2.0"
+  dependencies:
+    icss-utils: ^5.0.0
+    postcss-selector-parser: ^7.0.0
+    postcss-value-parser: ^4.1.0
+  peerDependencies:
+    postcss: ^8.1.0
+  checksum: 720d145453f82ad5f1c1d0ff7386d64722f0812808e4132e573c1a49909745e109fcce3792a0b0cb18770dbeb3d9741867e81c698dc8353a18bc664b7d6d9533
+  languageName: node
+  linkType: hard
+
+"postcss-modules-scope@npm:^3.2.0":
+  version: 3.2.1
+  resolution: "postcss-modules-scope@npm:3.2.1"
+  dependencies:
+    postcss-selector-parser: ^7.0.0
+  peerDependencies:
+    postcss: ^8.1.0
+  checksum: 085f65863bb7d8bf08209a979ceb22b2b07bb466574e0e698d34aaad832d614957bb05f2418348a14e4035f65e23b2be2951369d26ea429dd5762c6a020f0f7c
+  languageName: node
+  linkType: hard
+
+"postcss-modules-values@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "postcss-modules-values@npm:4.0.0"
+  dependencies:
+    icss-utils: ^5.0.0
+  peerDependencies:
+    postcss: ^8.1.0
+  checksum: f7f2cdf14a575b60e919ad5ea52fed48da46fe80db2733318d71d523fc87db66c835814940d7d05b5746b0426e44661c707f09bdb83592c16aea06e859409db6
+  languageName: node
+  linkType: hard
+
+"postcss-selector-parser@npm:^7.0.0":
+  version: 7.0.0
+  resolution: "postcss-selector-parser@npm:7.0.0"
+  dependencies:
+    cssesc: ^3.0.0
+    util-deprecate: ^1.0.2
+  checksum: f906b7449fcbe9fa6ae739b6fc324ee3c6201aaf5224f26da27de64ccba68d878d734dd182a467881e463f7ede08972d0129b0cc4d6b671d78c6492cddcef154
+  languageName: node
+  linkType: hard
+
+"postcss-value-parser@npm:^4.1.0, postcss-value-parser@npm:^4.2.0":
+  version: 4.2.0
+  resolution: "postcss-value-parser@npm:4.2.0"
+  checksum: 819ffab0c9d51cf0acbabf8996dffbfafbafa57afc0e4c98db88b67f2094cb44488758f06e5da95d7036f19556a4a732525e84289a425f4f6fd8e412a9d7442f
+  languageName: node
+  linkType: hard
+
+"postcss@npm:^8.3.11, postcss@npm:^8.4.33":
+  version: 8.4.49
+  resolution: "postcss@npm:8.4.49"
+  dependencies:
+    nanoid: ^3.3.7
+    picocolors: ^1.1.1
+    source-map-js: ^1.2.1
+  checksum: eb5d6cbdca24f50399aafa5d2bea489e4caee4c563ea1edd5a2485bc5f84e9ceef3febf170272bc83a99c31d23a316ad179213e853f34c2a7a8ffa534559d63a
+  languageName: node
+  linkType: hard
+
+"prelude-ls@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "prelude-ls@npm:1.2.1"
+  checksum: cd192ec0d0a8e4c6da3bb80e4f62afe336df3f76271ac6deb0e6a36187133b6073a19e9727a1ff108cd8b9982e4768850d413baa71214dd80c7979617dca827a
+  languageName: node
+  linkType: hard
+
+"prettier-linter-helpers@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "prettier-linter-helpers@npm:1.0.0"
+  dependencies:
+    fast-diff: ^1.1.2
+  checksum: 00ce8011cf6430158d27f9c92cfea0a7699405633f7f1d4a45f07e21bf78e99895911cbcdc3853db3a824201a7c745bd49bfea8abd5fb9883e765a90f74f8392
+  languageName: node
+  linkType: hard
+
+"prettier@npm:^3.2.4":
+  version: 3.4.2
+  resolution: "prettier@npm:3.4.2"
+  bin:
+    prettier: bin/prettier.cjs
+  checksum: 061c84513db62d3944c8dc8df36584dad82883ce4e49efcdbedd8703dce5b173c33fd9d2a4e1725d642a3b713c932b55418342eaa347479bc4a9cca114a04cd0
+  languageName: node
+  linkType: hard
+
+"pretty-format@npm:^29.0.0, pretty-format@npm:^29.7.0":
+  version: 29.7.0
+  resolution: "pretty-format@npm:29.7.0"
+  dependencies:
+    "@jest/schemas": ^29.6.3
+    ansi-styles: ^5.0.0
+    react-is: ^18.0.0
+  checksum: 032c1602383e71e9c0c02a01bbd25d6759d60e9c7cf21937dde8357aa753da348fcec5def5d1002c9678a8524d5fe099ad98861286550ef44de8808cc61e43b6
+  languageName: node
+  linkType: hard
+
+"proc-log@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "proc-log@npm:5.0.0"
+  checksum: c78b26ecef6d5cce4a7489a1e9923d7b4b1679028c8654aef0463b27f4a90b0946cd598f55799da602895c52feb085ec76381d007ab8dcceebd40b89c2f9dfe0
+  languageName: node
+  linkType: hard
+
+"process@npm:^0.11.10":
+  version: 0.11.10
+  resolution: "process@npm:0.11.10"
+  checksum: bfcce49814f7d172a6e6a14d5fa3ac92cc3d0c3b9feb1279774708a719e19acd673995226351a082a9ae99978254e320ccda4240ddc474ba31a76c79491ca7c3
+  languageName: node
+  linkType: hard
+
+"promise-retry@npm:^2.0.1":
+  version: 2.0.1
+  resolution: "promise-retry@npm:2.0.1"
+  dependencies:
+    err-code: ^2.0.2
+    retry: ^0.12.0
+  checksum: f96a3f6d90b92b568a26f71e966cbbc0f63ab85ea6ff6c81284dc869b41510e6cdef99b6b65f9030f0db422bf7c96652a3fff9f2e8fb4a0f069d8f4430359429
+  languageName: node
+  linkType: hard
+
+"prompts@npm:^2.0.1":
+  version: 2.4.2
+  resolution: "prompts@npm:2.4.2"
+  dependencies:
+    kleur: ^3.0.3
+    sisteransi: ^1.0.5
+  checksum: d8fd1fe63820be2412c13bfc5d0a01909acc1f0367e32396962e737cb2fc52d004f3302475d5ce7d18a1e8a79985f93ff04ee03007d091029c3f9104bffc007d
+  languageName: node
+  linkType: hard
+
+"psl@npm:^1.1.33":
+  version: 1.15.0
+  resolution: "psl@npm:1.15.0"
+  dependencies:
+    punycode: ^2.3.1
+  checksum: 6f777d82eecfe1c2406dadbc15e77467b186fec13202ec887a45d0209a2c6fca530af94a462a477c3c4a767ad892ec9ede7c482d98f61f653dd838b50e89dc15
+  languageName: node
+  linkType: hard
+
+"punycode@npm:^2.1.0, punycode@npm:^2.1.1, punycode@npm:^2.3.1":
+  version: 2.3.1
+  resolution: "punycode@npm:2.3.1"
+  checksum: bb0a0ceedca4c3c57a9b981b90601579058903c62be23c5e8e843d2c2d4148a3ecf029d5133486fb0e1822b098ba8bba09e89d6b21742d02fa26bda6441a6fb2
+  languageName: node
+  linkType: hard
+
+"pure-rand@npm:^6.0.0":
+  version: 6.1.0
+  resolution: "pure-rand@npm:6.1.0"
+  checksum: 8d53bc02bed99eca0b65b505090152ee7e9bd67dd74f8ff32ba1c883b87234067c5bf68d2614759fb217d82594d7a92919e6df80f97885e7b12b42af4bd3316a
+  languageName: node
+  linkType: hard
+
+"querystringify@npm:^2.1.1":
+  version: 2.2.0
+  resolution: "querystringify@npm:2.2.0"
+  checksum: 5641ea231bad7ef6d64d9998faca95611ed4b11c2591a8cae741e178a974f6a8e0ebde008475259abe1621cb15e692404e6b6626e927f7b849d5c09392604b15
+  languageName: node
+  linkType: hard
+
+"queue-microtask@npm:^1.2.2":
+  version: 1.2.3
+  resolution: "queue-microtask@npm:1.2.3"
+  checksum: b676f8c040cdc5b12723ad2f91414d267605b26419d5c821ff03befa817ddd10e238d22b25d604920340fd73efd8ba795465a0377c4adf45a4a41e4234e42dc4
+  languageName: node
+  linkType: hard
+
+"randombytes@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "randombytes@npm:2.1.0"
+  dependencies:
+    safe-buffer: ^5.1.0
+  checksum: d779499376bd4cbb435ef3ab9a957006c8682f343f14089ed5f27764e4645114196e75b7f6abf1cbd84fd247c0cb0651698444df8c9bf30e62120fbbc52269d6
+  languageName: node
+  linkType: hard
+
+"react-is@npm:^18.0.0, react-is@npm:^18.2.0":
+  version: 18.3.1
+  resolution: "react-is@npm:18.3.1"
+  checksum: e20fe84c86ff172fc8d898251b7cc2c43645d108bf96d0b8edf39b98f9a2cae97b40520ee7ed8ee0085ccc94736c4886294456033304151c3f94978cec03df21
+  languageName: node
+  linkType: hard
+
+"read-pkg@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "read-pkg@npm:3.0.0"
+  dependencies:
+    load-json-file: ^4.0.0
+    normalize-package-data: ^2.3.2
+    path-type: ^3.0.0
+  checksum: 398903ebae6c7e9965419a1062924436cc0b6f516c42c4679a90290d2f87448ed8f977e7aa2dbba4aa1ac09248628c43e493ac25b2bc76640e946035200e34c6
+  languageName: node
+  linkType: hard
+
+"rechoir@npm:^0.8.0":
+  version: 0.8.0
+  resolution: "rechoir@npm:0.8.0"
+  dependencies:
+    resolve: ^1.20.0
+  checksum: ad3caed8afdefbc33fbc30e6d22b86c35b3d51c2005546f4e79bcc03c074df804b3640ad18945e6bef9ed12caedc035655ec1082f64a5e94c849ff939dc0a788
+  languageName: node
+  linkType: hard
+
+"reflect.getprototypeof@npm:^1.0.6":
+  version: 1.0.9
+  resolution: "reflect.getprototypeof@npm:1.0.9"
+  dependencies:
+    call-bind: ^1.0.8
+    define-properties: ^1.2.1
+    dunder-proto: ^1.0.1
+    es-abstract: ^1.23.6
+    es-errors: ^1.3.0
+    get-intrinsic: ^1.2.6
+    gopd: ^1.2.0
+    which-builtin-type: ^1.2.1
+  checksum: 280cfdb1ba29d838440731ccea877431ec41415783dff7845d5f026c9923a71165a00e56ebd21050cec31e9c39e2e3620d6077ad3025d3782ede8b47d14ef8ab
+  languageName: node
+  linkType: hard
+
+"regenerate-unicode-properties@npm:^10.2.0":
+  version: 10.2.0
+  resolution: "regenerate-unicode-properties@npm:10.2.0"
+  dependencies:
+    regenerate: ^1.4.2
+  checksum: d5c5fc13f8b8d7e16e791637a4bfef741f8d70e267d51845ee7d5404a32fa14c75b181c4efba33e4bff8b0000a2f13e9773593713dfe5b66597df4259275ce63
+  languageName: node
+  linkType: hard
+
+"regenerate@npm:^1.4.2":
+  version: 1.4.2
+  resolution: "regenerate@npm:1.4.2"
+  checksum: 3317a09b2f802da8db09aa276e469b57a6c0dd818347e05b8862959c6193408242f150db5de83c12c3fa99091ad95fb42a6db2c3329bfaa12a0ea4cbbeb30cb0
+  languageName: node
+  linkType: hard
+
+"regenerator-runtime@npm:^0.14.0":
+  version: 0.14.1
+  resolution: "regenerator-runtime@npm:0.14.1"
+  checksum: 9f57c93277b5585d3c83b0cf76be47b473ae8c6d9142a46ce8b0291a04bb2cf902059f0f8445dcabb3fb7378e5fe4bb4ea1e008876343d42e46d3b484534ce38
+  languageName: node
+  linkType: hard
+
+"regenerator-transform@npm:^0.15.2":
+  version: 0.15.2
+  resolution: "regenerator-transform@npm:0.15.2"
+  dependencies:
+    "@babel/runtime": ^7.8.4
+  checksum: 20b6f9377d65954980fe044cfdd160de98df415b4bff38fbade67b3337efaf078308c4fed943067cd759827cc8cfeca9cb28ccda1f08333b85d6a2acbd022c27
+  languageName: node
+  linkType: hard
+
+"regexp.prototype.flags@npm:^1.5.3":
+  version: 1.5.3
+  resolution: "regexp.prototype.flags@npm:1.5.3"
+  dependencies:
+    call-bind: ^1.0.7
+    define-properties: ^1.2.1
+    es-errors: ^1.3.0
+    set-function-name: ^2.0.2
+  checksum: 83ff0705b837f7cb6d664010a11642250f36d3f642263dd0f3bdfe8f150261aa7b26b50ee97f21c1da30ef82a580bb5afedbef5f45639d69edaafbeac9bbb0ed
+  languageName: node
+  linkType: hard
+
+"regexpu-core@npm:^6.2.0":
+  version: 6.2.0
+  resolution: "regexpu-core@npm:6.2.0"
+  dependencies:
+    regenerate: ^1.4.2
+    regenerate-unicode-properties: ^10.2.0
+    regjsgen: ^0.8.0
+    regjsparser: ^0.12.0
+    unicode-match-property-ecmascript: ^2.0.0
+    unicode-match-property-value-ecmascript: ^2.1.0
+  checksum: 67d3c4a3f6c99bc80b5d690074a27e6f675be1c1739f8a9acf028fbc36f1a468472574ea65e331e217995198ba4404d7878f3cb3739a73552dd3c70d3fb7f8e6
+  languageName: node
+  linkType: hard
+
+"regjsgen@npm:^0.8.0":
+  version: 0.8.0
+  resolution: "regjsgen@npm:0.8.0"
+  checksum: a1d925ff14a4b2be774e45775ee6b33b256f89c42d480e6d85152d2133f18bd3d6af662161b226fa57466f7efec367eaf7ccd2a58c0ec2a1306667ba2ad07b0d
+  languageName: node
+  linkType: hard
+
+"regjsparser@npm:^0.12.0":
+  version: 0.12.0
+  resolution: "regjsparser@npm:0.12.0"
+  dependencies:
+    jsesc: ~3.0.2
+  bin:
+    regjsparser: bin/parser
+  checksum: 094b55b0ab3e1fd58f8ce5132a1d44dab08d91f7b0eea4132b0157b303ebb8ded20a9cbd893d25402d2aeddb23fac1f428ab4947b295d6fa51dd1c334a9e76f0
+  languageName: node
+  linkType: hard
+
+"require-directory@npm:^2.1.1":
+  version: 2.1.1
+  resolution: "require-directory@npm:2.1.1"
+  checksum: fb47e70bf0001fdeabdc0429d431863e9475e7e43ea5f94ad86503d918423c1543361cc5166d713eaa7029dd7a3d34775af04764bebff99ef413111a5af18c80
+  languageName: node
+  linkType: hard
+
+"require-from-string@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "require-from-string@npm:2.0.2"
+  checksum: a03ef6895445f33a4015300c426699bc66b2b044ba7b670aa238610381b56d3f07c686251740d575e22f4c87531ba662d06937508f0f3c0f1ddc04db3130560b
+  languageName: node
+  linkType: hard
+
+"requires-port@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "requires-port@npm:1.0.0"
+  checksum: eee0e303adffb69be55d1a214e415cf42b7441ae858c76dfc5353148644f6fd6e698926fc4643f510d5c126d12a705e7c8ed7e38061113bdf37547ab356797ff
+  languageName: node
+  linkType: hard
+
+"resolve-cwd@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "resolve-cwd@npm:3.0.0"
+  dependencies:
+    resolve-from: ^5.0.0
+  checksum: 546e0816012d65778e580ad62b29e975a642989108d9a3c5beabfb2304192fa3c9f9146fbdfe213563c6ff51975ae41bac1d3c6e047dd9572c94863a057b4d81
+  languageName: node
+  linkType: hard
+
+"resolve-from@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "resolve-from@npm:4.0.0"
+  checksum: f4ba0b8494846a5066328ad33ef8ac173801a51739eb4d63408c847da9a2e1c1de1e6cbbf72699211f3d13f8fc1325648b169bd15eb7da35688e30a5fb0e4a7f
+  languageName: node
+  linkType: hard
+
+"resolve-from@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "resolve-from@npm:5.0.0"
+  checksum: 4ceeb9113e1b1372d0cd969f3468fa042daa1dd9527b1b6bb88acb6ab55d8b9cd65dbf18819f9f9ddf0db804990901dcdaade80a215e7b2c23daae38e64f5bdf
+  languageName: node
+  linkType: hard
+
+"resolve.exports@npm:^2.0.0":
+  version: 2.0.3
+  resolution: "resolve.exports@npm:2.0.3"
+  checksum: abfb9f98278dcd0c19b8a49bb486abfafa23df4636d49128ea270dc982053c3ef230a530aecda1fae1322873fdfa6c97674fc539651ddfdb375ac58e0b8ef6df
+  languageName: node
+  linkType: hard
+
+"resolve@npm:^1.10.0, resolve@npm:^1.14.2, resolve@npm:^1.20.0":
+  version: 1.22.9
+  resolution: "resolve@npm:1.22.9"
+  dependencies:
+    is-core-module: ^2.16.0
+    path-parse: ^1.0.7
+    supports-preserve-symlinks-flag: ^1.0.0
+  bin:
+    resolve: bin/resolve
+  checksum: dd7da6c4ccc60bb4884f636b987102bb1cae6c486f7172361719a7f52769660c9a83a2d3520bef71d91f3da27e4fb8a40404c63ee4372a15863f3208bef5af67
+  languageName: node
+  linkType: hard
+
+"resolve@patch:resolve@^1.10.0#~builtin<compat/resolve>, resolve@patch:resolve@^1.14.2#~builtin<compat/resolve>, resolve@patch:resolve@^1.20.0#~builtin<compat/resolve>":
+  version: 1.22.9
+  resolution: "resolve@patch:resolve@npm%3A1.22.9#~builtin<compat/resolve>::version=1.22.9&hash=c3c19d"
+  dependencies:
+    is-core-module: ^2.16.0
+    path-parse: ^1.0.7
+    supports-preserve-symlinks-flag: ^1.0.0
+  bin:
+    resolve: bin/resolve
+  checksum: 8db5c0f16ab65f58c036cb5be0964605c97c29b9fdf1e20f298ec027e2a4fd96ad0413aa14f6e761629956dc552cd478c2f9b6c5a07e37e4c85209090162501e
+  languageName: node
+  linkType: hard
+
+"retry@npm:^0.12.0":
+  version: 0.12.0
+  resolution: "retry@npm:0.12.0"
+  checksum: 623bd7d2e5119467ba66202d733ec3c2e2e26568074923bc0585b6b99db14f357e79bdedb63cab56cec47491c4a0da7e6021a7465ca6dc4f481d3898fdd3158c
+  languageName: node
+  linkType: hard
+
+"reusify@npm:^1.0.4":
+  version: 1.0.4
+  resolution: "reusify@npm:1.0.4"
+  checksum: c3076ebcc22a6bc252cb0b9c77561795256c22b757f40c0d8110b1300723f15ec0fc8685e8d4ea6d7666f36c79ccc793b1939c748bf36f18f542744a4e379fcc
+  languageName: node
+  linkType: hard
+
+"rimraf@npm:^3.0.2":
+  version: 3.0.2
+  resolution: "rimraf@npm:3.0.2"
+  dependencies:
+    glob: ^7.1.3
+  bin:
+    rimraf: bin.js
+  checksum: 87f4164e396f0171b0a3386cc1877a817f572148ee13a7e113b238e48e8a9f2f31d009a92ec38a591ff1567d9662c6b67fd8818a2dbbaed74bc26a87a2a4a9a0
+  languageName: node
+  linkType: hard
+
+"rimraf@npm:^5.0.5":
+  version: 5.0.10
+  resolution: "rimraf@npm:5.0.10"
+  dependencies:
+    glob: ^10.3.7
+  bin:
+    rimraf: dist/esm/bin.mjs
+  checksum: 50e27388dd2b3fa6677385fc1e2966e9157c89c86853b96d02e6915663a96b7ff4d590e14f6f70e90f9b554093aa5dbc05ac3012876be558c06a65437337bc05
+  languageName: node
+  linkType: hard
+
+"run-parallel@npm:^1.1.9":
+  version: 1.2.0
+  resolution: "run-parallel@npm:1.2.0"
+  dependencies:
+    queue-microtask: ^1.2.2
+  checksum: cb4f97ad25a75ebc11a8ef4e33bb962f8af8516bb2001082ceabd8902e15b98f4b84b4f8a9b222e5d57fc3bd1379c483886ed4619367a7680dad65316993021d
+  languageName: node
+  linkType: hard
+
+"safe-array-concat@npm:^1.1.3":
+  version: 1.1.3
+  resolution: "safe-array-concat@npm:1.1.3"
+  dependencies:
+    call-bind: ^1.0.8
+    call-bound: ^1.0.2
+    get-intrinsic: ^1.2.6
+    has-symbols: ^1.1.0
+    isarray: ^2.0.5
+  checksum: 00f6a68140e67e813f3ad5e73e6dedcf3e42a9fa01f04d44b0d3f7b1f4b257af876832a9bfc82ac76f307e8a6cc652e3cf95876048a26cbec451847cf6ae3707
+  languageName: node
+  linkType: hard
+
+"safe-buffer@npm:^5.1.0":
+  version: 5.2.1
+  resolution: "safe-buffer@npm:5.2.1"
+  checksum: b99c4b41fdd67a6aaf280fcd05e9ffb0813654894223afb78a31f14a19ad220bba8aba1cb14eddce1fcfb037155fe6de4e861784eb434f7d11ed58d1e70dd491
+  languageName: node
+  linkType: hard
+
+"safe-regex-test@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "safe-regex-test@npm:1.1.0"
+  dependencies:
+    call-bound: ^1.0.2
+    es-errors: ^1.3.0
+    is-regex: ^1.2.1
+  checksum: 3c809abeb81977c9ed6c869c83aca6873ea0f3ab0f806b8edbba5582d51713f8a6e9757d24d2b4b088f563801475ea946c8e77e7713e8c65cdd02305b6caedab
+  languageName: node
+  linkType: hard
+
+"safer-buffer@npm:>= 2.1.2 < 3.0.0":
+  version: 2.1.2
+  resolution: "safer-buffer@npm:2.1.2"
+  checksum: cab8f25ae6f1434abee8d80023d7e72b598cf1327164ddab31003c51215526801e40b66c5e65d658a0af1e9d6478cadcb4c745f4bd6751f97d8644786c0978b0
+  languageName: node
+  linkType: hard
+
+"sanitize-html@npm:^2.3":
+  version: 2.14.0
+  resolution: "sanitize-html@npm:2.14.0"
+  dependencies:
+    deepmerge: ^4.2.2
+    escape-string-regexp: ^4.0.0
+    htmlparser2: ^8.0.0
+    is-plain-object: ^5.0.0
+    parse-srcset: ^1.0.2
+    postcss: ^8.3.11
+  checksum: e8eb9ac1bd4d5d41cfbe647c506bdecaebb19932dc9acd044e6322a31ebdf2abc43213384d518f855d19b54782e136f1aa14b0e1ac79ffc9bdea9d47d2d5a812
+  languageName: node
+  linkType: hard
+
+"saxes@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "saxes@npm:6.0.0"
+  dependencies:
+    xmlchars: ^2.2.0
+  checksum: d3fa3e2aaf6c65ed52ee993aff1891fc47d5e47d515164b5449cbf5da2cbdc396137e55590472e64c5c436c14ae64a8a03c29b9e7389fc6f14035cf4e982ef3b
+  languageName: node
+  linkType: hard
+
+"schema-utils@npm:^2.7.0":
+  version: 2.7.1
+  resolution: "schema-utils@npm:2.7.1"
+  dependencies:
+    "@types/json-schema": ^7.0.5
+    ajv: ^6.12.4
+    ajv-keywords: ^3.5.2
+  checksum: 32c62fc9e28edd101e1bd83453a4216eb9bd875cc4d3775e4452b541908fa8f61a7bbac8ffde57484f01d7096279d3ba0337078e85a918ecbeb72872fb09fb2b
+  languageName: node
+  linkType: hard
+
+"schema-utils@npm:^3.0.0, schema-utils@npm:^3.2.0":
+  version: 3.3.0
+  resolution: "schema-utils@npm:3.3.0"
+  dependencies:
+    "@types/json-schema": ^7.0.8
+    ajv: ^6.12.5
+    ajv-keywords: ^3.5.2
+  checksum: ea56971926fac2487f0757da939a871388891bc87c6a82220d125d587b388f1704788f3706e7f63a7b70e49fc2db974c41343528caea60444afd5ce0fe4b85c0
+  languageName: node
+  linkType: hard
+
+"schema-utils@npm:^4.0.0, schema-utils@npm:^4.3.0":
+  version: 4.3.0
+  resolution: "schema-utils@npm:4.3.0"
+  dependencies:
+    "@types/json-schema": ^7.0.9
+    ajv: ^8.9.0
+    ajv-formats: ^2.1.1
+    ajv-keywords: ^5.1.0
+  checksum: 3dbd9056727c871818eaf3cabeeb5c9e173ae2b17bbf2a9c7a2e49c220fa1a580e44df651c876aea3b4926cecf080730a39e28202cb63f2b68d99872b49cd37a
+  languageName: node
+  linkType: hard
+
+"semver@npm:2 || 3 || 4 || 5, semver@npm:^5.4.1, semver@npm:^5.5.0":
+  version: 5.7.2
+  resolution: "semver@npm:5.7.2"
+  bin:
+    semver: bin/semver
+  checksum: fb4ab5e0dd1c22ce0c937ea390b4a822147a9c53dbd2a9a0132f12fe382902beef4fbf12cf51bb955248d8d15874ce8cd89532569756384f994309825f10b686
+  languageName: node
+  linkType: hard
+
+"semver@npm:^6.3.0, semver@npm:^6.3.1":
+  version: 6.3.1
+  resolution: "semver@npm:6.3.1"
+  bin:
+    semver: bin/semver.js
+  checksum: ae47d06de28836adb9d3e25f22a92943477371292d9b665fb023fae278d345d508ca1958232af086d85e0155aee22e313e100971898bbb8d5d89b8b1d4054ca2
+  languageName: node
+  linkType: hard
+
+"semver@npm:^7.3.4, semver@npm:^7.3.5, semver@npm:^7.5.3, semver@npm:^7.5.4, semver@npm:^7.6.3":
+  version: 7.6.3
+  resolution: "semver@npm:7.6.3"
+  bin:
+    semver: bin/semver.js
+  checksum: 4110ec5d015c9438f322257b1c51fe30276e5f766a3f64c09edd1d7ea7118ecbc3f379f3b69032bacf13116dc7abc4ad8ce0d7e2bd642e26b0d271b56b61a7d8
+  languageName: node
+  linkType: hard
+
+"serialize-javascript@npm:^6.0.2":
+  version: 6.0.2
+  resolution: "serialize-javascript@npm:6.0.2"
+  dependencies:
+    randombytes: ^2.1.0
+  checksum: c4839c6206c1d143c0f80763997a361310305751171dd95e4b57efee69b8f6edd8960a0b7fbfc45042aadff98b206d55428aee0dc276efe54f100899c7fa8ab7
+  languageName: node
+  linkType: hard
+
+"set-function-length@npm:^1.2.2":
+  version: 1.2.2
+  resolution: "set-function-length@npm:1.2.2"
+  dependencies:
+    define-data-property: ^1.1.4
+    es-errors: ^1.3.0
+    function-bind: ^1.1.2
+    get-intrinsic: ^1.2.4
+    gopd: ^1.0.1
+    has-property-descriptors: ^1.0.2
+  checksum: a8248bdacdf84cb0fab4637774d9fb3c7a8e6089866d04c817583ff48e14149c87044ce683d7f50759a8c50fb87c7a7e173535b06169c87ef76f5fb276dfff72
+  languageName: node
+  linkType: hard
+
+"set-function-name@npm:^2.0.2":
+  version: 2.0.2
+  resolution: "set-function-name@npm:2.0.2"
+  dependencies:
+    define-data-property: ^1.1.4
+    es-errors: ^1.3.0
+    functions-have-names: ^1.2.3
+    has-property-descriptors: ^1.0.2
+  checksum: d6229a71527fd0404399fc6227e0ff0652800362510822a291925c9d7b48a1ca1a468b11b281471c34cd5a2da0db4f5d7ff315a61d26655e77f6e971e6d0c80f
+  languageName: node
+  linkType: hard
+
+"shallow-clone@npm:^3.0.0":
+  version: 3.0.1
+  resolution: "shallow-clone@npm:3.0.1"
+  dependencies:
+    kind-of: ^6.0.2
+  checksum: 39b3dd9630a774aba288a680e7d2901f5c0eae7b8387fc5c8ea559918b29b3da144b7bdb990d7ccd9e11be05508ac9e459ce51d01fd65e583282f6ffafcba2e7
+  languageName: node
+  linkType: hard
+
+"shebang-command@npm:^1.2.0":
+  version: 1.2.0
+  resolution: "shebang-command@npm:1.2.0"
+  dependencies:
+    shebang-regex: ^1.0.0
+  checksum: 9eed1750301e622961ba5d588af2212505e96770ec376a37ab678f965795e995ade7ed44910f5d3d3cb5e10165a1847f52d3348c64e146b8be922f7707958908
+  languageName: node
+  linkType: hard
+
+"shebang-command@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "shebang-command@npm:2.0.0"
+  dependencies:
+    shebang-regex: ^3.0.0
+  checksum: 6b52fe87271c12968f6a054e60f6bde5f0f3d2db483a1e5c3e12d657c488a15474121a1d55cd958f6df026a54374ec38a4a963988c213b7570e1d51575cea7fa
+  languageName: node
+  linkType: hard
+
+"shebang-regex@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "shebang-regex@npm:1.0.0"
+  checksum: 404c5a752cd40f94591dfd9346da40a735a05139dac890ffc229afba610854d8799aaa52f87f7e0c94c5007f2c6af55bdcaeb584b56691926c5eaf41dc8f1372
+  languageName: node
+  linkType: hard
+
+"shebang-regex@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "shebang-regex@npm:3.0.0"
+  checksum: 1a2bcae50de99034fcd92ad4212d8e01eedf52c7ec7830eedcf886622804fe36884278f2be8be0ea5fde3fd1c23911643a4e0f726c8685b61871c8908af01222
+  languageName: node
+  linkType: hard
+
+"shell-quote@npm:^1.6.1":
+  version: 1.8.2
+  resolution: "shell-quote@npm:1.8.2"
+  checksum: 1e97b62ced1c4c5135015978ebf273bed1f425a68cf84163e83fbb0f34b3ff9471e656720dab2b7cbb4ae0f58998e686d17d166c28dfb3662acd009e8bd7faed
+  languageName: node
+  linkType: hard
+
+"side-channel-list@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "side-channel-list@npm:1.0.0"
+  dependencies:
+    es-errors: ^1.3.0
+    object-inspect: ^1.13.3
+  checksum: 603b928997abd21c5a5f02ae6b9cc36b72e3176ad6827fab0417ead74580cc4fb4d5c7d0a8a2ff4ead34d0f9e35701ed7a41853dac8a6d1a664fcce1a044f86f
+  languageName: node
+  linkType: hard
+
+"side-channel-map@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "side-channel-map@npm:1.0.1"
+  dependencies:
+    call-bound: ^1.0.2
+    es-errors: ^1.3.0
+    get-intrinsic: ^1.2.5
+    object-inspect: ^1.13.3
+  checksum: 42501371cdf71f4ccbbc9c9e2eb00aaaab80a4c1c429d5e8da713fd4d39ef3b8d4a4b37ed4f275798a65260a551a7131fd87fe67e922dba4ac18586d6aab8b06
+  languageName: node
+  linkType: hard
+
+"side-channel-weakmap@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "side-channel-weakmap@npm:1.0.2"
+  dependencies:
+    call-bound: ^1.0.2
+    es-errors: ^1.3.0
+    get-intrinsic: ^1.2.5
+    object-inspect: ^1.13.3
+    side-channel-map: ^1.0.1
+  checksum: a815c89bc78c5723c714ea1a77c938377ea710af20d4fb886d362b0d1f8ac73a17816a5f6640f354017d7e292a43da9c5e876c22145bac00b76cfb3468001736
+  languageName: node
+  linkType: hard
+
+"side-channel@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "side-channel@npm:1.1.0"
+  dependencies:
+    es-errors: ^1.3.0
+    object-inspect: ^1.13.3
+    side-channel-list: ^1.0.0
+    side-channel-map: ^1.0.1
+    side-channel-weakmap: ^1.0.2
+  checksum: bf73d6d6682034603eb8e99c63b50155017ed78a522d27c2acec0388a792c3ede3238b878b953a08157093b85d05797217d270b7666ba1f111345fbe933380ff
+  languageName: node
+  linkType: hard
+
+"signal-exit@npm:^3.0.3, signal-exit@npm:^3.0.7":
+  version: 3.0.7
+  resolution: "signal-exit@npm:3.0.7"
+  checksum: a2f098f247adc367dffc27845853e9959b9e88b01cb301658cfe4194352d8d2bb32e18467c786a7fe15f1d44b233ea35633d076d5e737870b7139949d1ab6318
+  languageName: node
+  linkType: hard
+
+"signal-exit@npm:^4.0.1":
+  version: 4.1.0
+  resolution: "signal-exit@npm:4.1.0"
+  checksum: 64c757b498cb8629ffa5f75485340594d2f8189e9b08700e69199069c8e3070fb3e255f7ab873c05dc0b3cec412aea7402e10a5990cb6a050bd33ba062a6c549
+  languageName: node
+  linkType: hard
+
+"sisteransi@npm:^1.0.5":
+  version: 1.0.5
+  resolution: "sisteransi@npm:1.0.5"
+  checksum: aba6438f46d2bfcef94cf112c835ab395172c75f67453fe05c340c770d3c402363018ae1ab4172a1026a90c47eaccf3af7b6ff6fa749a680c2929bd7fa2b37a4
+  languageName: node
+  linkType: hard
+
+"slash@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "slash@npm:3.0.0"
+  checksum: 94a93fff615f25a999ad4b83c9d5e257a7280c90a32a7cb8b4a87996e4babf322e469c42b7f649fd5796edd8687652f3fb452a86dc97a816f01113183393f11c
+  languageName: node
+  linkType: hard
+
+"smart-buffer@npm:^4.2.0":
+  version: 4.2.0
+  resolution: "smart-buffer@npm:4.2.0"
+  checksum: b5167a7142c1da704c0e3af85c402002b597081dd9575031a90b4f229ca5678e9a36e8a374f1814c8156a725d17008ae3bde63b92f9cfd132526379e580bec8b
+  languageName: node
+  linkType: hard
+
+"socks-proxy-agent@npm:^8.0.3":
+  version: 8.0.5
+  resolution: "socks-proxy-agent@npm:8.0.5"
+  dependencies:
+    agent-base: ^7.1.2
+    debug: ^4.3.4
+    socks: ^2.8.3
+  checksum: b4fbcdb7ad2d6eec445926e255a1fb95c975db0020543fbac8dfa6c47aecc6b3b619b7fb9c60a3f82c9b2969912a5e7e174a056ae4d98cb5322f3524d6036e1d
+  languageName: node
+  linkType: hard
+
+"socks@npm:^2.8.3":
+  version: 2.8.3
+  resolution: "socks@npm:2.8.3"
+  dependencies:
+    ip-address: ^9.0.5
+    smart-buffer: ^4.2.0
+  checksum: 7a6b7f6eedf7482b9e4597d9a20e09505824208006ea8f2c49b71657427f3c137ca2ae662089baa73e1971c62322d535d9d0cf1c9235cf6f55e315c18203eadd
+  languageName: node
+  linkType: hard
+
+"source-list-map@npm:^2.0.0":
+  version: 2.0.1
+  resolution: "source-list-map@npm:2.0.1"
+  checksum: 806efc6f75e7cd31e4815e7a3aaf75a45c704871ea4075cb2eb49882c6fca28998f44fc5ac91adb6de03b2882ee6fb02f951fdc85e6a22b338c32bfe19557938
+  languageName: node
+  linkType: hard
+
+"source-map-js@npm:^1.0.2, source-map-js@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "source-map-js@npm:1.2.1"
+  checksum: 4eb0cd997cdf228bc253bcaff9340afeb706176e64868ecd20efbe6efea931465f43955612346d6b7318789e5265bdc419bc7669c1cebe3db0eb255f57efa76b
+  languageName: node
+  linkType: hard
+
+"source-map-loader@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "source-map-loader@npm:5.0.0"
+  dependencies:
+    iconv-lite: ^0.6.3
+    source-map-js: ^1.0.2
+  peerDependencies:
+    webpack: ^5.72.1
+  checksum: 66d6fbaa87a14197647515f274b9a685a84d0ddb95c3d9801bfb1ce28fc24000954c73548fe09c52c0bad660eb10d963b0c60d5c5943ccf2c8292a8d957f2acb
+  languageName: node
+  linkType: hard
+
+"source-map-loader@npm:~1.0.2":
+  version: 1.0.2
+  resolution: "source-map-loader@npm:1.0.2"
+  dependencies:
+    data-urls: ^2.0.0
+    iconv-lite: ^0.6.2
+    loader-utils: ^2.0.0
+    schema-utils: ^2.7.0
+    source-map: ^0.6.1
+  peerDependencies:
+    webpack: ^4.0.0 || ^5.0.0
+  checksum: 0360b536e904f8fea452d0e122b9199661765229dc62a4b8093cc9d14e985f2ddd146355ede6d11acdd0b9bf4639b364e2526afcf9d3218ed45af63aa5eb053f
+  languageName: node
+  linkType: hard
+
+"source-map-support@npm:0.5.13":
+  version: 0.5.13
+  resolution: "source-map-support@npm:0.5.13"
+  dependencies:
+    buffer-from: ^1.0.0
+    source-map: ^0.6.0
+  checksum: 933550047b6c1a2328599a21d8b7666507427c0f5ef5eaadd56b5da0fd9505e239053c66fe181bf1df469a3b7af9d775778eee283cbb7ae16b902ddc09e93a97
+  languageName: node
+  linkType: hard
+
+"source-map-support@npm:~0.5.20":
+  version: 0.5.21
+  resolution: "source-map-support@npm:0.5.21"
+  dependencies:
+    buffer-from: ^1.0.0
+    source-map: ^0.6.0
+  checksum: 43e98d700d79af1d36f859bdb7318e601dfc918c7ba2e98456118ebc4c4872b327773e5a1df09b0524e9e5063bb18f0934538eace60cca2710d1fa687645d137
+  languageName: node
+  linkType: hard
+
+"source-map@npm:^0.6.0, source-map@npm:^0.6.1, source-map@npm:~0.6.1":
+  version: 0.6.1
+  resolution: "source-map@npm:0.6.1"
+  checksum: 59ce8640cf3f3124f64ac289012c2b8bd377c238e316fb323ea22fbfe83da07d81e000071d7242cad7a23cd91c7de98e4df8830ec3f133cb6133a5f6e9f67bc2
+  languageName: node
+  linkType: hard
+
+"source-map@npm:^0.7.4":
+  version: 0.7.4
+  resolution: "source-map@npm:0.7.4"
+  checksum: 01cc5a74b1f0e1d626a58d36ad6898ea820567e87f18dfc9d24a9843a351aaa2ec09b87422589906d6ff1deed29693e176194dc88bcae7c9a852dc74b311dbf5
+  languageName: node
+  linkType: hard
+
+"spdx-correct@npm:^3.0.0":
+  version: 3.2.0
+  resolution: "spdx-correct@npm:3.2.0"
+  dependencies:
+    spdx-expression-parse: ^3.0.0
+    spdx-license-ids: ^3.0.0
+  checksum: e9ae98d22f69c88e7aff5b8778dc01c361ef635580e82d29e5c60a6533cc8f4d820803e67d7432581af0cc4fb49973125076ee3b90df191d153e223c004193b2
+  languageName: node
+  linkType: hard
+
+"spdx-exceptions@npm:^2.1.0":
+  version: 2.5.0
+  resolution: "spdx-exceptions@npm:2.5.0"
+  checksum: bb127d6e2532de65b912f7c99fc66097cdea7d64c10d3ec9b5e96524dbbd7d20e01cba818a6ddb2ae75e62bb0c63d5e277a7e555a85cbc8ab40044984fa4ae15
+  languageName: node
+  linkType: hard
+
+"spdx-expression-parse@npm:^3.0.0":
+  version: 3.0.1
+  resolution: "spdx-expression-parse@npm:3.0.1"
+  dependencies:
+    spdx-exceptions: ^2.1.0
+    spdx-license-ids: ^3.0.0
+  checksum: a1c6e104a2cbada7a593eaa9f430bd5e148ef5290d4c0409899855ce8b1c39652bcc88a725259491a82601159d6dc790bedefc9016c7472f7de8de7361f8ccde
+  languageName: node
+  linkType: hard
+
+"spdx-license-ids@npm:^3.0.0":
+  version: 3.0.20
+  resolution: "spdx-license-ids@npm:3.0.20"
+  checksum: 0c57750bedbcff48f3d0e266fbbdaf0aab54217e182f669542ffe0b5a902dce69e8cdfa126a131e1ddd39a9bef4662e357b2b41315d7240b4a28c0a7e782bb40
+  languageName: node
+  linkType: hard
+
+"sprintf-js@npm:^1.1.3":
+  version: 1.1.3
+  resolution: "sprintf-js@npm:1.1.3"
+  checksum: a3fdac7b49643875b70864a9d9b469d87a40dfeaf5d34d9d0c5b1cda5fd7d065531fcb43c76357d62254c57184a7b151954156563a4d6a747015cfb41021cad0
+  languageName: node
+  linkType: hard
+
+"sprintf-js@npm:~1.0.2":
+  version: 1.0.3
+  resolution: "sprintf-js@npm:1.0.3"
+  checksum: 19d79aec211f09b99ec3099b5b2ae2f6e9cdefe50bc91ac4c69144b6d3928a640bb6ae5b3def70c2e85a2c3d9f5ec2719921e3a59d3ca3ef4b2fd1a4656a0df3
+  languageName: node
+  linkType: hard
+
+"ssri@npm:^12.0.0":
+  version: 12.0.0
+  resolution: "ssri@npm:12.0.0"
+  dependencies:
+    minipass: ^7.0.3
+  checksum: ef4b6b0ae47b4a69896f5f1c4375f953b9435388c053c36d27998bc3d73e046969ccde61ab659e679142971a0b08e50478a1228f62edb994105b280f17900c98
+  languageName: node
+  linkType: hard
+
+"stack-utils@npm:^2.0.3":
+  version: 2.0.6
+  resolution: "stack-utils@npm:2.0.6"
+  dependencies:
+    escape-string-regexp: ^2.0.0
+  checksum: 052bf4d25bbf5f78e06c1d5e67de2e088b06871fa04107ca8d3f0e9d9263326e2942c8bedee3545795fc77d787d443a538345eef74db2f8e35db3558c6f91ff7
+  languageName: node
+  linkType: hard
+
+"stitch@workspace:.":
+  version: 0.0.0-use.local
+  resolution: "stitch@workspace:."
+  dependencies:
+    "@babel/core": ^7.23.7
+    "@babel/preset-env": ^7.23.8
+    "@jupyter-widgets/base": ^1.1.10 || ^2 || ^3 || ^4 || ^5 || ^6
+    "@jupyter-widgets/base-manager": ^1.0.7
+    "@jupyterlab/builder": ^4.0.11
+    "@lumino/application": ^2.3.0
+    "@lumino/widgets": ^2.3.1
+    "@types/jest": ^29.5.11
+    "@types/webpack-env": ^1.18.4
+    "@typescript-eslint/eslint-plugin": ^6.19.1
+    "@typescript-eslint/parser": ^6.19.1
+    acorn: ^8.11.3
+    css-loader: ^6.9.1
+    eslint: ^8.56.0
+    eslint-config-prettier: ^9.1.0
+    eslint-plugin-prettier: ^5.1.3
+    fs-extra: ^11.2.0
+    identity-obj-proxy: ^3.0.0
+    jest: ^29.7.0
+    jest-environment-jsdom: ^29.7.0
+    mkdirp: ^3.0.1
+    npm-run-all: ^4.1.5
+    prettier: ^3.2.4
+    rimraf: ^5.0.5
+    source-map-loader: ^5.0.0
+    style-loader: ^3.3.4
+    ts-jest: ^29.1.2
+    ts-loader: ^9.5.1
+    typescript: ~5.3.3
+    webpack: ^5.90.0
+    webpack-cli: ^5.1.4
+  languageName: unknown
+  linkType: soft
+
+"string-length@npm:^4.0.1":
+  version: 4.0.2
+  resolution: "string-length@npm:4.0.2"
+  dependencies:
+    char-regex: ^1.0.2
+    strip-ansi: ^6.0.0
+  checksum: ce85533ef5113fcb7e522bcf9e62cb33871aa99b3729cec5595f4447f660b0cefd542ca6df4150c97a677d58b0cb727a3fe09ac1de94071d05526c73579bf505
+  languageName: node
+  linkType: hard
+
+"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^4.1.0, string-width@npm:^4.2.0, string-width@npm:^4.2.3":
+  version: 4.2.3
+  resolution: "string-width@npm:4.2.3"
+  dependencies:
+    emoji-regex: ^8.0.0
+    is-fullwidth-code-point: ^3.0.0
+    strip-ansi: ^6.0.1
+  checksum: e52c10dc3fbfcd6c3a15f159f54a90024241d0f149cf8aed2982a2d801d2e64df0bf1dc351cf8e95c3319323f9f220c16e740b06faecd53e2462df1d2b5443fb
+  languageName: node
+  linkType: hard
+
+"string-width@npm:^5.0.1, string-width@npm:^5.1.2":
+  version: 5.1.2
+  resolution: "string-width@npm:5.1.2"
+  dependencies:
+    eastasianwidth: ^0.2.0
+    emoji-regex: ^9.2.2
+    strip-ansi: ^7.0.1
+  checksum: 7369deaa29f21dda9a438686154b62c2c5f661f8dda60449088f9f980196f7908fc39fdd1803e3e01541970287cf5deae336798337e9319a7055af89dafa7193
+  languageName: node
+  linkType: hard
+
+"string.prototype.padend@npm:^3.0.0":
+  version: 3.1.6
+  resolution: "string.prototype.padend@npm:3.1.6"
+  dependencies:
+    call-bind: ^1.0.7
+    define-properties: ^1.2.1
+    es-abstract: ^1.23.2
+    es-object-atoms: ^1.0.0
+  checksum: d9fc23c21bdfb6850756002ef09cebc420882003f29eafbd8322df77a90726bc2a64892d01f94f1fc9fc6f809414fbcbd8615610bb3cddd33512c12b6b3643a2
+  languageName: node
+  linkType: hard
+
+"string.prototype.trim@npm:^1.2.10":
+  version: 1.2.10
+  resolution: "string.prototype.trim@npm:1.2.10"
+  dependencies:
+    call-bind: ^1.0.8
+    call-bound: ^1.0.2
+    define-data-property: ^1.1.4
+    define-properties: ^1.2.1
+    es-abstract: ^1.23.5
+    es-object-atoms: ^1.0.0
+    has-property-descriptors: ^1.0.2
+  checksum: 87659cd8561237b6c69f5376328fda934693aedde17bb7a2c57008e9d9ff992d0c253a391c7d8d50114e0e49ff7daf86a362f7961cf92f7564cd01342ca2e385
+  languageName: node
+  linkType: hard
+
+"string.prototype.trimend@npm:^1.0.9":
+  version: 1.0.9
+  resolution: "string.prototype.trimend@npm:1.0.9"
+  dependencies:
+    call-bind: ^1.0.8
+    call-bound: ^1.0.2
+    define-properties: ^1.2.1
+    es-object-atoms: ^1.0.0
+  checksum: cb86f639f41d791a43627784be2175daa9ca3259c7cb83e7a207a729909b74f2ea0ec5d85de5761e6835e5f443e9420c6ff3f63a845378e4a61dd793177bc287
+  languageName: node
+  linkType: hard
+
+"string.prototype.trimstart@npm:^1.0.8":
+  version: 1.0.8
+  resolution: "string.prototype.trimstart@npm:1.0.8"
+  dependencies:
+    call-bind: ^1.0.7
+    define-properties: ^1.2.1
+    es-object-atoms: ^1.0.0
+  checksum: df1007a7f580a49d692375d996521dc14fd103acda7f3034b3c558a60b82beeed3a64fa91e494e164581793a8ab0ae2f59578a49896a7af6583c1f20472bce96
+  languageName: node
+  linkType: hard
+
+"strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1":
+  version: 6.0.1
+  resolution: "strip-ansi@npm:6.0.1"
+  dependencies:
+    ansi-regex: ^5.0.1
+  checksum: f3cd25890aef3ba6e1a74e20896c21a46f482e93df4a06567cebf2b57edabb15133f1f94e57434e0a958d61186087b1008e89c94875d019910a213181a14fc8c
+  languageName: node
+  linkType: hard
+
+"strip-ansi@npm:^7.0.1":
+  version: 7.1.0
+  resolution: "strip-ansi@npm:7.1.0"
+  dependencies:
+    ansi-regex: ^6.0.1
+  checksum: 859c73fcf27869c22a4e4d8c6acfe690064659e84bef9458aa6d13719d09ca88dcfd40cbf31fd0be63518ea1a643fe070b4827d353e09533a5b0b9fd4553d64d
+  languageName: node
+  linkType: hard
+
+"strip-bom@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "strip-bom@npm:3.0.0"
+  checksum: 8d50ff27b7ebe5ecc78f1fe1e00fcdff7af014e73cf724b46fb81ef889eeb1015fc5184b64e81a2efe002180f3ba431bdd77e300da5c6685d702780fbf0c8d5b
+  languageName: node
+  linkType: hard
+
+"strip-bom@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "strip-bom@npm:4.0.0"
+  checksum: 9dbcfbaf503c57c06af15fe2c8176fb1bf3af5ff65003851a102749f875a6dbe0ab3b30115eccf6e805e9d756830d3e40ec508b62b3f1ddf3761a20ebe29d3f3
+  languageName: node
+  linkType: hard
+
+"strip-final-newline@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "strip-final-newline@npm:2.0.0"
+  checksum: 69412b5e25731e1938184b5d489c32e340605bb611d6140344abc3421b7f3c6f9984b21dff296dfcf056681b82caa3bb4cc996a965ce37bcfad663e92eae9c64
+  languageName: node
+  linkType: hard
+
+"strip-json-comments@npm:^3.1.1":
+  version: 3.1.1
+  resolution: "strip-json-comments@npm:3.1.1"
+  checksum: 492f73e27268f9b1c122733f28ecb0e7e8d8a531a6662efbd08e22cccb3f9475e90a1b82cab06a392f6afae6d2de636f977e231296400d0ec5304ba70f166443
+  languageName: node
+  linkType: hard
+
+"style-loader@npm:^3.3.4, style-loader@npm:~3.3.1":
+  version: 3.3.4
+  resolution: "style-loader@npm:3.3.4"
+  peerDependencies:
+    webpack: ^5.0.0
+  checksum: caac3f2fe2c3c89e49b7a2a9329e1cfa515ecf5f36b9c4885f9b218019fda207a9029939b2c35821dec177a264a007e7c391ccdd3ff7401881ce6287b9c8f38b
+  languageName: node
+  linkType: hard
+
+"supports-color@npm:^5.3.0":
+  version: 5.5.0
+  resolution: "supports-color@npm:5.5.0"
+  dependencies:
+    has-flag: ^3.0.0
+  checksum: 95f6f4ba5afdf92f495b5a912d4abee8dcba766ae719b975c56c084f5004845f6f5a5f7769f52d53f40e21952a6d87411bafe34af4a01e65f9926002e38e1dac
+  languageName: node
+  linkType: hard
+
+"supports-color@npm:^7.1.0, supports-color@npm:^7.2.0":
+  version: 7.2.0
+  resolution: "supports-color@npm:7.2.0"
+  dependencies:
+    has-flag: ^4.0.0
+  checksum: 3dda818de06ebbe5b9653e07842d9479f3555ebc77e9a0280caf5a14fb877ffee9ed57007c3b78f5a6324b8dbeec648d9e97a24e2ed9fdb81ddc69ea07100f4a
+  languageName: node
+  linkType: hard
+
+"supports-color@npm:^8.0.0":
+  version: 8.1.1
+  resolution: "supports-color@npm:8.1.1"
+  dependencies:
+    has-flag: ^4.0.0
+  checksum: c052193a7e43c6cdc741eb7f378df605636e01ad434badf7324f17fb60c69a880d8d8fcdcb562cf94c2350e57b937d7425ab5b8326c67c2adc48f7c87c1db406
+  languageName: node
+  linkType: hard
+
+"supports-preserve-symlinks-flag@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "supports-preserve-symlinks-flag@npm:1.0.0"
+  checksum: 53b1e247e68e05db7b3808b99b892bd36fb096e6fba213a06da7fab22045e97597db425c724f2bbd6c99a3c295e1e73f3e4de78592289f38431049e1277ca0ae
+  languageName: node
+  linkType: hard
+
+"symbol-tree@npm:^3.2.4":
+  version: 3.2.4
+  resolution: "symbol-tree@npm:3.2.4"
+  checksum: 6e8fc7e1486b8b54bea91199d9535bb72f10842e40c79e882fc94fb7b14b89866adf2fd79efa5ebb5b658bc07fb459ccce5ac0e99ef3d72f474e74aaf284029d
+  languageName: node
+  linkType: hard
+
+"synckit@npm:^0.9.1":
+  version: 0.9.2
+  resolution: "synckit@npm:0.9.2"
+  dependencies:
+    "@pkgr/core": ^0.1.0
+    tslib: ^2.6.2
+  checksum: 3a30e828efbdcf3b50fccab4da6e90ea7ca24d8c5c2ad3ffe98e07d7c492df121e0f75227c6e510f96f976aae76f1fa4710cb7b1d69db881caf66ef9de89360e
+  languageName: node
+  linkType: hard
+
+"tapable@npm:^2.1.1, tapable@npm:^2.2.0, tapable@npm:^2.2.1":
+  version: 2.2.1
+  resolution: "tapable@npm:2.2.1"
+  checksum: 3b7a1b4d86fa940aad46d9e73d1e8739335efd4c48322cb37d073eb6f80f5281889bf0320c6d8ffcfa1a0dd5bfdbd0f9d037e252ef972aca595330538aac4d51
+  languageName: node
+  linkType: hard
+
+"tar@npm:^7.4.3":
+  version: 7.4.3
+  resolution: "tar@npm:7.4.3"
+  dependencies:
+    "@isaacs/fs-minipass": ^4.0.0
+    chownr: ^3.0.0
+    minipass: ^7.1.2
+    minizlib: ^3.0.1
+    mkdirp: ^3.0.1
+    yallist: ^5.0.0
+  checksum: 8485350c0688331c94493031f417df069b778aadb25598abdad51862e007c39d1dd5310702c7be4a6784731a174799d8885d2fde0484269aea205b724d7b2ffa
+  languageName: node
+  linkType: hard
+
+"terser-webpack-plugin@npm:^5.3.10, terser-webpack-plugin@npm:^5.3.7":
+  version: 5.3.11
+  resolution: "terser-webpack-plugin@npm:5.3.11"
+  dependencies:
+    "@jridgewell/trace-mapping": ^0.3.25
+    jest-worker: ^27.4.5
+    schema-utils: ^4.3.0
+    serialize-javascript: ^6.0.2
+    terser: ^5.31.1
+  peerDependencies:
+    webpack: ^5.1.0
+  peerDependenciesMeta:
+    "@swc/core":
+      optional: true
+    esbuild:
+      optional: true
+    uglify-js:
+      optional: true
+  checksum: c84c005d4041ad2e2eed0c9059b52a50ffd27f1e2afca7d34864a2b4b2bb1295405bc7578eeb25bae732e358339954d8cb6fbf6d83df52e8aa9333e8bf409ebe
+  languageName: node
+  linkType: hard
+
+"terser@npm:^5.31.1":
+  version: 5.37.0
+  resolution: "terser@npm:5.37.0"
+  dependencies:
+    "@jridgewell/source-map": ^0.3.3
+    acorn: ^8.8.2
+    commander: ^2.20.0
+    source-map-support: ~0.5.20
+  bin:
+    terser: bin/terser
+  checksum: 70c06a8ce1288ff4370a7e481beb6fc8b22fc4995371479f49df1552aa9cf8e794ace66e1da6e87057eda1745644311213f5043bda9a06cf55421eff68b3ac06
+  languageName: node
+  linkType: hard
+
+"test-exclude@npm:^6.0.0":
+  version: 6.0.0
+  resolution: "test-exclude@npm:6.0.0"
+  dependencies:
+    "@istanbuljs/schema": ^0.1.2
+    glob: ^7.1.4
+    minimatch: ^3.0.4
+  checksum: 3b34a3d77165a2cb82b34014b3aba93b1c4637a5011807557dc2f3da826c59975a5ccad765721c4648b39817e3472789f9b0fa98fc854c5c1c7a1e632aacdc28
+  languageName: node
+  linkType: hard
+
+"text-table@npm:^0.2.0":
+  version: 0.2.0
+  resolution: "text-table@npm:0.2.0"
+  checksum: b6937a38c80c7f84d9c11dd75e49d5c44f71d95e810a3250bd1f1797fc7117c57698204adf676b71497acc205d769d65c16ae8fa10afad832ae1322630aef10a
+  languageName: node
+  linkType: hard
+
+"tmpl@npm:1.0.5":
+  version: 1.0.5
+  resolution: "tmpl@npm:1.0.5"
+  checksum: cd922d9b853c00fe414c5a774817be65b058d54a2d01ebb415840960406c669a0fc632f66df885e24cb022ec812739199ccbdb8d1164c3e513f85bfca5ab2873
+  languageName: node
+  linkType: hard
+
+"to-regex-range@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "to-regex-range@npm:5.0.1"
+  dependencies:
+    is-number: ^7.0.0
+  checksum: f76fa01b3d5be85db6a2a143e24df9f60dd047d151062d0ba3df62953f2f697b16fe5dad9b0ac6191c7efc7b1d9dcaa4b768174b7b29da89d4428e64bc0a20ed
+  languageName: node
+  linkType: hard
+
+"tough-cookie@npm:^4.1.2":
+  version: 4.1.4
+  resolution: "tough-cookie@npm:4.1.4"
+  dependencies:
+    psl: ^1.1.33
+    punycode: ^2.1.1
+    universalify: ^0.2.0
+    url-parse: ^1.5.3
+  checksum: 5815059f014c31179a303c673f753f7899a6fce94ac93712c88ea5f3c26e0c042b5f0c7a599a00f8e0feeca4615dba75c3dffc54f3c1a489978aa8205e09307c
+  languageName: node
+  linkType: hard
+
+"tr46@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "tr46@npm:2.1.0"
+  dependencies:
+    punycode: ^2.1.1
+  checksum: ffe6049b9dca3ae329b059aada7f515b0f0064c611b39b51ff6b53897e954650f6f63d9319c6c008d36ead477c7b55e5f64c9dc60588ddc91ff720d64eb710b3
+  languageName: node
+  linkType: hard
+
+"tr46@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "tr46@npm:3.0.0"
+  dependencies:
+    punycode: ^2.1.1
+  checksum: 44c3cc6767fb800490e6e9fd64fd49041aa4e49e1f6a012b34a75de739cc9ed3a6405296072c1df8b6389ae139c5e7c6496f659cfe13a04a4bff3a1422981270
+  languageName: node
+  linkType: hard
+
+"ts-api-utils@npm:^1.0.1":
+  version: 1.4.3
+  resolution: "ts-api-utils@npm:1.4.3"
+  peerDependencies:
+    typescript: ">=4.2.0"
+  checksum: ea00dee382d19066b2a3d8929f1089888b05fec797e32e7a7004938eda1dccf2e77274ee2afcd4166f53fab9b8d7ee90ebb225a3183f9ba8817d636f688a148d
+  languageName: node
+  linkType: hard
+
+"ts-jest@npm:^29.1.2":
+  version: 29.2.5
+  resolution: "ts-jest@npm:29.2.5"
+  dependencies:
+    bs-logger: ^0.2.6
+    ejs: ^3.1.10
+    fast-json-stable-stringify: ^2.1.0
+    jest-util: ^29.0.0
+    json5: ^2.2.3
+    lodash.memoize: ^4.1.2
+    make-error: ^1.3.6
+    semver: ^7.6.3
+    yargs-parser: ^21.1.1
+  peerDependencies:
+    "@babel/core": ">=7.0.0-beta.0 <8"
+    "@jest/transform": ^29.0.0
+    "@jest/types": ^29.0.0
+    babel-jest: ^29.0.0
+    jest: ^29.0.0
+    typescript: ">=4.3 <6"
+  peerDependenciesMeta:
+    "@babel/core":
+      optional: true
+    "@jest/transform":
+      optional: true
+    "@jest/types":
+      optional: true
+    babel-jest:
+      optional: true
+    esbuild:
+      optional: true
+  bin:
+    ts-jest: cli.js
+  checksum: d60d1e1d80936f6002b1bb27f7e062408bc733141b9d666565503f023c340a3196d506c836a4316c5793af81a5f910ab49bb9c13f66e2dc66de4e0f03851dbca
+  languageName: node
+  linkType: hard
+
+"ts-loader@npm:^9.5.1":
+  version: 9.5.1
+  resolution: "ts-loader@npm:9.5.1"
+  dependencies:
+    chalk: ^4.1.0
+    enhanced-resolve: ^5.0.0
+    micromatch: ^4.0.0
+    semver: ^7.3.4
+    source-map: ^0.7.4
+  peerDependencies:
+    typescript: "*"
+    webpack: ^5.0.0
+  checksum: 7cf396e656d905388ea2a9b5e82f16d3c955fda8d3df2fbf219f4bee16ff50a3c995c44ae3e584634e9443f056cec70bb3151add3917ffb4588ecd7394bac0ec
+  languageName: node
+  linkType: hard
+
+"tslib@npm:^2.6.2":
+  version: 2.8.1
+  resolution: "tslib@npm:2.8.1"
+  checksum: e4aba30e632b8c8902b47587fd13345e2827fa639e7c3121074d5ee0880723282411a8838f830b55100cbe4517672f84a2472667d355b81e8af165a55dc6203a
+  languageName: node
+  linkType: hard
+
+"type-check@npm:^0.4.0, type-check@npm:~0.4.0":
+  version: 0.4.0
+  resolution: "type-check@npm:0.4.0"
+  dependencies:
+    prelude-ls: ^1.2.1
+  checksum: ec688ebfc9c45d0c30412e41ca9c0cdbd704580eb3a9ccf07b9b576094d7b86a012baebc95681999dd38f4f444afd28504cb3a89f2ef16b31d4ab61a0739025a
+  languageName: node
+  linkType: hard
+
+"type-detect@npm:4.0.8":
+  version: 4.0.8
+  resolution: "type-detect@npm:4.0.8"
+  checksum: 62b5628bff67c0eb0b66afa371bd73e230399a8d2ad30d852716efcc4656a7516904570cd8631a49a3ce57c10225adf5d0cbdcb47f6b0255fe6557c453925a15
+  languageName: node
+  linkType: hard
+
+"type-fest@npm:^0.20.2":
+  version: 0.20.2
+  resolution: "type-fest@npm:0.20.2"
+  checksum: 4fb3272df21ad1c552486f8a2f8e115c09a521ad7a8db3d56d53718d0c907b62c6e9141ba5f584af3f6830d0872c521357e512381f24f7c44acae583ad517d73
+  languageName: node
+  linkType: hard
+
+"type-fest@npm:^0.21.3":
+  version: 0.21.3
+  resolution: "type-fest@npm:0.21.3"
+  checksum: e6b32a3b3877f04339bae01c193b273c62ba7bfc9e325b8703c4ee1b32dc8fe4ef5dfa54bf78265e069f7667d058e360ae0f37be5af9f153b22382cd55a9afe0
+  languageName: node
+  linkType: hard
+
+"typed-array-buffer@npm:^1.0.2":
+  version: 1.0.3
+  resolution: "typed-array-buffer@npm:1.0.3"
+  dependencies:
+    call-bound: ^1.0.3
+    es-errors: ^1.3.0
+    is-typed-array: ^1.1.14
+  checksum: 3fb91f0735fb413b2bbaaca9fabe7b8fc14a3fa5a5a7546bab8a57e755be0e3788d893195ad9c2b842620592de0e68d4c077d4c2c41f04ec25b8b5bb82fa9a80
+  languageName: node
+  linkType: hard
+
+"typed-array-byte-length@npm:^1.0.1":
+  version: 1.0.3
+  resolution: "typed-array-byte-length@npm:1.0.3"
+  dependencies:
+    call-bind: ^1.0.8
+    for-each: ^0.3.3
+    gopd: ^1.2.0
+    has-proto: ^1.2.0
+    is-typed-array: ^1.1.14
+  checksum: cda9352178ebeab073ad6499b03e938ebc30c4efaea63a26839d89c4b1da9d2640b0d937fc2bd1f049eb0a38def6fbe8a061b601292ae62fe079a410ce56e3a6
+  languageName: node
+  linkType: hard
+
+"typed-array-byte-offset@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "typed-array-byte-offset@npm:1.0.3"
+  dependencies:
+    available-typed-arrays: ^1.0.7
+    call-bind: ^1.0.7
+    for-each: ^0.3.3
+    gopd: ^1.0.1
+    has-proto: ^1.0.3
+    is-typed-array: ^1.1.13
+    reflect.getprototypeof: ^1.0.6
+  checksum: 36728daa80d49a9fa51cd3f0f2b037613f4574666fd4473bd37ac123d7f6f81ea68ff45424c1e2673257964e10bedeb3ebfce73532672913ebbe446999912303
+  languageName: node
+  linkType: hard
+
+"typed-array-length@npm:^1.0.7":
+  version: 1.0.7
+  resolution: "typed-array-length@npm:1.0.7"
+  dependencies:
+    call-bind: ^1.0.7
+    for-each: ^0.3.3
+    gopd: ^1.0.1
+    is-typed-array: ^1.1.13
+    possible-typed-array-names: ^1.0.0
+    reflect.getprototypeof: ^1.0.6
+  checksum: deb1a4ffdb27cd930b02c7030cb3e8e0993084c643208e52696e18ea6dd3953dfc37b939df06ff78170423d353dc8b10d5bae5796f3711c1b3abe52872b3774c
+  languageName: node
+  linkType: hard
+
+"typescript@npm:~5.3.3":
+  version: 5.3.3
+  resolution: "typescript@npm:5.3.3"
+  bin:
+    tsc: bin/tsc
+    tsserver: bin/tsserver
+  checksum: 2007ccb6e51bbbf6fde0a78099efe04dc1c3dfbdff04ca3b6a8bc717991862b39fd6126c0c3ebf2d2d98ac5e960bcaa873826bb2bb241f14277034148f41f6a2
+  languageName: node
+  linkType: hard
+
+"typescript@patch:typescript@~5.3.3#~builtin<compat/typescript>":
+  version: 5.3.3
+  resolution: "typescript@patch:typescript@npm%3A5.3.3#~builtin<compat/typescript>::version=5.3.3&hash=85af82"
+  bin:
+    tsc: bin/tsc
+    tsserver: bin/tsserver
+  checksum: f61375590b3162599f0f0d5b8737877ac0a7bc52761dbb585d67e7b8753a3a4c42d9a554c4cc929f591ffcf3a2b0602f65ae3ce74714fd5652623a816862b610
+  languageName: node
+  linkType: hard
+
+"unbox-primitive@npm:^1.0.2":
+  version: 1.1.0
+  resolution: "unbox-primitive@npm:1.1.0"
+  dependencies:
+    call-bound: ^1.0.3
+    has-bigints: ^1.0.2
+    has-symbols: ^1.1.0
+    which-boxed-primitive: ^1.1.1
+  checksum: 729f13b84a5bfa3fead1d8139cee5c38514e63a8d6a437819a473e241ba87eeb593646568621c7fc7f133db300ef18d65d1a5a60dc9c7beb9000364d93c581df
+  languageName: node
+  linkType: hard
+
+"underscore@npm:>=1.8.3":
+  version: 1.13.7
+  resolution: "underscore@npm:1.13.7"
+  checksum: 174b011af29e4fbe2c70eb2baa8bfab0d0336cf2f5654f364484967bc6264a86224d0134b9176e4235c8cceae00d11839f0fd4824268de04b11c78aca1241684
+  languageName: node
+  linkType: hard
+
+"undici-types@npm:~6.20.0":
+  version: 6.20.0
+  resolution: "undici-types@npm:6.20.0"
+  checksum: b7bc50f012dc6afbcce56c9fd62d7e86b20a62ff21f12b7b5cbf1973b9578d90f22a9c7fe50e638e96905d33893bf2f9f16d98929c4673c2480de05c6c96ea8b
+  languageName: node
+  linkType: hard
+
+"unicode-canonical-property-names-ecmascript@npm:^2.0.0":
+  version: 2.0.1
+  resolution: "unicode-canonical-property-names-ecmascript@npm:2.0.1"
+  checksum: 3c3dabdb1d22aef4904399f9e810d0b71c0b12b3815169d96fac97e56d5642840c6071cf709adcace2252bc6bb80242396c2ec74b37224eb015c5f7aca40bad7
+  languageName: node
+  linkType: hard
+
+"unicode-match-property-ecmascript@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "unicode-match-property-ecmascript@npm:2.0.0"
+  dependencies:
+    unicode-canonical-property-names-ecmascript: ^2.0.0
+    unicode-property-aliases-ecmascript: ^2.0.0
+  checksum: 1f34a7434a23df4885b5890ac36c5b2161a809887000be560f56ad4b11126d433c0c1c39baf1016bdabed4ec54829a6190ee37aa24919aa116dc1a5a8a62965a
+  languageName: node
+  linkType: hard
+
+"unicode-match-property-value-ecmascript@npm:^2.1.0":
+  version: 2.2.0
+  resolution: "unicode-match-property-value-ecmascript@npm:2.2.0"
+  checksum: 9e3151e1d0bc6be35c4cef105e317c04090364173e8462005b5cde08a1e7c858b6586486cfebac39dc2c6c8c9ee24afb245de6d527604866edfa454fe2a35fae
+  languageName: node
+  linkType: hard
+
+"unicode-property-aliases-ecmascript@npm:^2.0.0":
+  version: 2.1.0
+  resolution: "unicode-property-aliases-ecmascript@npm:2.1.0"
+  checksum: 243524431893649b62cc674d877bd64ef292d6071dd2fd01ab4d5ad26efbc104ffcd064f93f8a06b7e4ec54c172bf03f6417921a0d8c3a9994161fe1f88f815b
+  languageName: node
+  linkType: hard
+
+"unique-filename@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "unique-filename@npm:4.0.0"
+  dependencies:
+    unique-slug: ^5.0.0
+  checksum: 6a62094fcac286b9ec39edbd1f8f64ff92383baa430af303dfed1ffda5e47a08a6b316408554abfddd9730c78b6106bef4ca4d02c1231a735ddd56ced77573df
+  languageName: node
+  linkType: hard
+
+"unique-slug@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "unique-slug@npm:5.0.0"
+  dependencies:
+    imurmurhash: ^0.1.4
+  checksum: 222d0322bc7bbf6e45c08967863212398313ef73423f4125e075f893a02405a5ffdbaaf150f7dd1e99f8861348a486dd079186d27c5f2c60e465b7dcbb1d3e5b
+  languageName: node
+  linkType: hard
+
+"universalify@npm:^0.2.0":
+  version: 0.2.0
+  resolution: "universalify@npm:0.2.0"
+  checksum: e86134cb12919d177c2353196a4cc09981524ee87abf621f7bc8d249dbbbebaec5e7d1314b96061497981350df786e4c5128dbf442eba104d6e765bc260678b5
+  languageName: node
+  linkType: hard
+
+"universalify@npm:^2.0.0":
+  version: 2.0.1
+  resolution: "universalify@npm:2.0.1"
+  checksum: ecd8469fe0db28e7de9e5289d32bd1b6ba8f7183db34f3bfc4ca53c49891c2d6aa05f3fb3936a81285a905cc509fb641a0c3fc131ec786167eff41236ae32e60
+  languageName: node
+  linkType: hard
+
+"update-browserslist-db@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "update-browserslist-db@npm:1.1.1"
+  dependencies:
+    escalade: ^3.2.0
+    picocolors: ^1.1.0
+  peerDependencies:
+    browserslist: ">= 4.21.0"
+  bin:
+    update-browserslist-db: cli.js
+  checksum: 2ea11bd2562122162c3e438d83a1f9125238c0844b6d16d366e3276d0c0acac6036822dc7df65fc5a89c699cdf9f174acf439c39bedf3f9a2f3983976e4b4c3e
+  languageName: node
+  linkType: hard
+
+"uri-js@npm:^4.2.2":
+  version: 4.4.1
+  resolution: "uri-js@npm:4.4.1"
+  dependencies:
+    punycode: ^2.1.0
+  checksum: 7167432de6817fe8e9e0c9684f1d2de2bb688c94388f7569f7dbdb1587c9f4ca2a77962f134ec90be0cc4d004c939ff0d05acc9f34a0db39a3c797dada262633
+  languageName: node
+  linkType: hard
+
+"url-parse@npm:^1.5.3, url-parse@npm:~1.5.4":
+  version: 1.5.10
+  resolution: "url-parse@npm:1.5.10"
+  dependencies:
+    querystringify: ^2.1.1
+    requires-port: ^1.0.0
+  checksum: fbdba6b1d83336aca2216bbdc38ba658d9cfb8fc7f665eb8b17852de638ff7d1a162c198a8e4ed66001ddbf6c9888d41e4798912c62b4fd777a31657989f7bdf
+  languageName: node
+  linkType: hard
+
+"util-deprecate@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "util-deprecate@npm:1.0.2"
+  checksum: 474acf1146cb2701fe3b074892217553dfcf9a031280919ba1b8d651a068c9b15d863b7303cb15bd00a862b498e6cf4ad7b4a08fb134edd5a6f7641681cb54a2
+  languageName: node
+  linkType: hard
+
+"v8-to-istanbul@npm:^9.0.1":
+  version: 9.3.0
+  resolution: "v8-to-istanbul@npm:9.3.0"
+  dependencies:
+    "@jridgewell/trace-mapping": ^0.3.12
+    "@types/istanbul-lib-coverage": ^2.0.1
+    convert-source-map: ^2.0.0
+  checksum: ded42cd535d92b7fd09a71c4c67fb067487ef5551cc227bfbf2a1f159a842e4e4acddaef20b955789b8d3b455b9779d036853f4a27ce15007f6364a4d30317ae
+  languageName: node
+  linkType: hard
+
+"validate-npm-package-license@npm:^3.0.1":
+  version: 3.0.4
+  resolution: "validate-npm-package-license@npm:3.0.4"
+  dependencies:
+    spdx-correct: ^3.0.0
+    spdx-expression-parse: ^3.0.0
+  checksum: 35703ac889d419cf2aceef63daeadbe4e77227c39ab6287eeb6c1b36a746b364f50ba22e88591f5d017bc54685d8137bc2d328d0a896e4d3fd22093c0f32a9ad
+  languageName: node
+  linkType: hard
+
+"validate.io-array@npm:^1.0.3":
+  version: 1.0.6
+  resolution: "validate.io-array@npm:1.0.6"
+  checksum: 54eca83ebc702e3e46499f9d9e77287a95ae25c4e727cd2fafee29c7333b3a36cca0c5d8f090b9406262786de80750fba85e7e7ef41e20bf8cc67d5570de449b
+  languageName: node
+  linkType: hard
+
+"validate.io-function@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "validate.io-function@npm:1.0.2"
+  checksum: e4cce2479a20cb7c42e8630c777fb107059c27bc32925f769e3a73ca5fd62b4892d897b3c80227e14d5fcd1c5b7d05544e0579d63e59f14034c0052cda7f7c44
+  languageName: node
+  linkType: hard
+
+"validate.io-integer-array@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "validate.io-integer-array@npm:1.0.0"
+  dependencies:
+    validate.io-array: ^1.0.3
+    validate.io-integer: ^1.0.4
+  checksum: 5f6d7fab8df7d2bf546a05e830201768464605539c75a2c2417b632b4411a00df84b462f81eac75e1be95303e7e0ac92f244c137424739f4e15cd21c2eb52c7f
+  languageName: node
+  linkType: hard
+
+"validate.io-integer@npm:^1.0.4":
+  version: 1.0.5
+  resolution: "validate.io-integer@npm:1.0.5"
+  dependencies:
+    validate.io-number: ^1.0.3
+  checksum: 88b3f8bb5a5277a95305d64abbfc437079220ce4f57a148cc6113e7ccec03dd86b10a69d413982602aa90a62b8d516148a78716f550dcd3aff863ac1c2a7a5e6
+  languageName: node
+  linkType: hard
+
+"validate.io-number@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "validate.io-number@npm:1.0.3"
+  checksum: 42418aeb6c969efa745475154fe576809b02eccd0961aad0421b090d6e7a12d23a3e28b0d5dddd2c6347c1a6bdccb82bba5048c716131cd20207244d50e07282
+  languageName: node
+  linkType: hard
+
+"w3c-xmlserializer@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "w3c-xmlserializer@npm:4.0.0"
+  dependencies:
+    xml-name-validator: ^4.0.0
+  checksum: eba070e78deb408ae8defa4d36b429f084b2b47a4741c4a9be3f27a0a3d1845e277e3072b04391a138f7e43776842627d1334e448ff13ff90ad9fb1214ee7091
+  languageName: node
+  linkType: hard
+
+"walker@npm:^1.0.8":
+  version: 1.0.8
+  resolution: "walker@npm:1.0.8"
+  dependencies:
+    makeerror: 1.0.12
+  checksum: ad7a257ea1e662e57ef2e018f97b3c02a7240ad5093c392186ce0bcf1f1a60bbadd520d073b9beb921ed99f64f065efb63dfc8eec689a80e569f93c1c5d5e16c
+  languageName: node
+  linkType: hard
+
+"watchpack@npm:^2.4.1":
+  version: 2.4.2
+  resolution: "watchpack@npm:2.4.2"
+  dependencies:
+    glob-to-regexp: ^0.4.1
+    graceful-fs: ^4.1.2
+  checksum: 92d9d52ce3d16fd83ed6994d1dd66a4d146998882f4c362d37adfea9ab77748a5b4d1e0c65fa104797928b2d40f635efa8f9b925a6265428a69f1e1852ca3441
+  languageName: node
+  linkType: hard
+
+"webidl-conversions@npm:^6.1.0":
+  version: 6.1.0
+  resolution: "webidl-conversions@npm:6.1.0"
+  checksum: 1f526507aa491f972a0c1409d07f8444e1d28778dfa269a9971f2e157182f3d496dc33296e4ed45b157fdb3bf535bb90c90bf10c50dcf1dd6caacb2a34cc84fb
+  languageName: node
+  linkType: hard
+
+"webidl-conversions@npm:^7.0.0":
+  version: 7.0.0
+  resolution: "webidl-conversions@npm:7.0.0"
+  checksum: f05588567a2a76428515333eff87200fae6c83c3948a7482ebb109562971e77ef6dc49749afa58abb993391227c5697b3ecca52018793e0cb4620a48f10bd21b
+  languageName: node
+  linkType: hard
+
+"webpack-cli@npm:^5.0.1, webpack-cli@npm:^5.1.4":
+  version: 5.1.4
+  resolution: "webpack-cli@npm:5.1.4"
+  dependencies:
+    "@discoveryjs/json-ext": ^0.5.0
+    "@webpack-cli/configtest": ^2.1.1
+    "@webpack-cli/info": ^2.0.2
+    "@webpack-cli/serve": ^2.0.5
+    colorette: ^2.0.14
+    commander: ^10.0.1
+    cross-spawn: ^7.0.3
+    envinfo: ^7.7.3
+    fastest-levenshtein: ^1.0.12
+    import-local: ^3.0.2
+    interpret: ^3.1.1
+    rechoir: ^0.8.0
+    webpack-merge: ^5.7.3
+  peerDependencies:
+    webpack: 5.x.x
+  peerDependenciesMeta:
+    "@webpack-cli/generators":
+      optional: true
+    webpack-bundle-analyzer:
+      optional: true
+    webpack-dev-server:
+      optional: true
+  bin:
+    webpack-cli: bin/cli.js
+  checksum: 3a4ad0d0342a6815c850ee4633cc2a8a5dae04f918e7847f180bf24ab400803cf8a8943707ffbed03eb20fe6ce647f996f60a2aade87b0b4a9954da3da172ce0
+  languageName: node
+  linkType: hard
+
+"webpack-merge@npm:^5.7.3, webpack-merge@npm:^5.8.0":
+  version: 5.10.0
+  resolution: "webpack-merge@npm:5.10.0"
+  dependencies:
+    clone-deep: ^4.0.1
+    flat: ^5.0.2
+    wildcard: ^2.0.0
+  checksum: 1fe8bf5309add7298e1ac72fb3f2090e1dfa80c48c7e79fa48aa60b5961332c7d0d61efa8851acb805e6b91a4584537a347bc106e05e9aec87fa4f7088c62f2f
+  languageName: node
+  linkType: hard
+
+"webpack-sources@npm:^1.2.0":
+  version: 1.4.3
+  resolution: "webpack-sources@npm:1.4.3"
+  dependencies:
+    source-list-map: ^2.0.0
+    source-map: ~0.6.1
+  checksum: 37463dad8d08114930f4bc4882a9602941f07c9f0efa9b6bc78738cd936275b990a596d801ef450d022bb005b109b9f451dd087db2f3c9baf53e8e22cf388f79
+  languageName: node
+  linkType: hard
+
+"webpack-sources@npm:^3.2.3":
+  version: 3.2.3
+  resolution: "webpack-sources@npm:3.2.3"
+  checksum: 989e401b9fe3536529e2a99dac8c1bdc50e3a0a2c8669cbafad31271eadd994bc9405f88a3039cd2e29db5e6d9d0926ceb7a1a4e7409ece021fe79c37d9c4607
+  languageName: node
+  linkType: hard
+
+"webpack@npm:^5.76.1, webpack@npm:^5.90.0":
+  version: 5.97.1
+  resolution: "webpack@npm:5.97.1"
+  dependencies:
+    "@types/eslint-scope": ^3.7.7
+    "@types/estree": ^1.0.6
+    "@webassemblyjs/ast": ^1.14.1
+    "@webassemblyjs/wasm-edit": ^1.14.1
+    "@webassemblyjs/wasm-parser": ^1.14.1
+    acorn: ^8.14.0
+    browserslist: ^4.24.0
+    chrome-trace-event: ^1.0.2
+    enhanced-resolve: ^5.17.1
+    es-module-lexer: ^1.2.1
+    eslint-scope: 5.1.1
+    events: ^3.2.0
+    glob-to-regexp: ^0.4.1
+    graceful-fs: ^4.2.11
+    json-parse-even-better-errors: ^2.3.1
+    loader-runner: ^4.2.0
+    mime-types: ^2.1.27
+    neo-async: ^2.6.2
+    schema-utils: ^3.2.0
+    tapable: ^2.1.1
+    terser-webpack-plugin: ^5.3.10
+    watchpack: ^2.4.1
+    webpack-sources: ^3.2.3
+  peerDependenciesMeta:
+    webpack-cli:
+      optional: true
+  bin:
+    webpack: bin/webpack.js
+  checksum: 649065e2258b495ae41a4088be804b4be2ec07d280aa514ebef43da79caf96fa973d26a08826c3902b5676a098d9b37c589f16be7b4da17b68b08b6c76441196
+  languageName: node
+  linkType: hard
+
+"whatwg-encoding@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "whatwg-encoding@npm:2.0.0"
+  dependencies:
+    iconv-lite: 0.6.3
+  checksum: 7087810c410aa9b689cbd6af8773341a53cdc1f3aae2a882c163bd5522ec8ca4cdfc269aef417a5792f411807d5d77d50df4c24e3abb00bb60192858a40cc675
+  languageName: node
+  linkType: hard
+
+"whatwg-mimetype@npm:^2.3.0":
+  version: 2.3.0
+  resolution: "whatwg-mimetype@npm:2.3.0"
+  checksum: 23eb885940bcbcca4ff841c40a78e9cbb893ec42743993a42bf7aed16085b048b44b06f3402018931687153550f9a32d259dfa524e4f03577ab898b6965e5383
+  languageName: node
+  linkType: hard
+
+"whatwg-mimetype@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "whatwg-mimetype@npm:3.0.0"
+  checksum: ce08bbb36b6aaf64f3a84da89707e3e6a31e5ab1c1a2379fd68df79ba712a4ab090904f0b50e6693b0dafc8e6343a6157e40bf18fdffd26e513cf95ee2a59824
+  languageName: node
+  linkType: hard
+
+"whatwg-url@npm:^11.0.0":
+  version: 11.0.0
+  resolution: "whatwg-url@npm:11.0.0"
+  dependencies:
+    tr46: ^3.0.0
+    webidl-conversions: ^7.0.0
+  checksum: ed4826aaa57e66bb3488a4b25c9cd476c46ba96052747388b5801f137dd740b73fde91ad207d96baf9f17fbcc80fc1a477ad65181b5eb5fa718d27c69501d7af
+  languageName: node
+  linkType: hard
+
+"whatwg-url@npm:^8.0.0":
+  version: 8.7.0
+  resolution: "whatwg-url@npm:8.7.0"
+  dependencies:
+    lodash: ^4.7.0
+    tr46: ^2.1.0
+    webidl-conversions: ^6.1.0
+  checksum: a87abcc6cefcece5311eb642858c8fdb234e51ec74196bfacf8def2edae1bfbffdf6acb251646ed6301f8cee44262642d8769c707256125a91387e33f405dd1e
+  languageName: node
+  linkType: hard
+
+"which-boxed-primitive@npm:^1.1.0, which-boxed-primitive@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "which-boxed-primitive@npm:1.1.1"
+  dependencies:
+    is-bigint: ^1.1.0
+    is-boolean-object: ^1.2.1
+    is-number-object: ^1.1.1
+    is-string: ^1.1.1
+    is-symbol: ^1.1.1
+  checksum: ee41d0260e4fd39551ad77700c7047d3d281ec03d356f5e5c8393fe160ba0db53ef446ff547d05f76ffabfd8ad9df7c9a827e12d4cccdbc8fccf9239ff8ac21e
+  languageName: node
+  linkType: hard
+
+"which-builtin-type@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "which-builtin-type@npm:1.2.1"
+  dependencies:
+    call-bound: ^1.0.2
+    function.prototype.name: ^1.1.6
+    has-tostringtag: ^1.0.2
+    is-async-function: ^2.0.0
+    is-date-object: ^1.1.0
+    is-finalizationregistry: ^1.1.0
+    is-generator-function: ^1.0.10
+    is-regex: ^1.2.1
+    is-weakref: ^1.0.2
+    isarray: ^2.0.5
+    which-boxed-primitive: ^1.1.0
+    which-collection: ^1.0.2
+    which-typed-array: ^1.1.16
+  checksum: 7a3617ba0e7cafb795f74db418df889867d12bce39a477f3ee29c6092aa64d396955bf2a64eae3726d8578440e26777695544057b373c45a8bcf5fbe920bf633
+  languageName: node
+  linkType: hard
+
+"which-collection@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "which-collection@npm:1.0.2"
+  dependencies:
+    is-map: ^2.0.3
+    is-set: ^2.0.3
+    is-weakmap: ^2.0.2
+    is-weakset: ^2.0.3
+  checksum: c51821a331624c8197916598a738fc5aeb9a857f1e00d89f5e4c03dc7c60b4032822b8ec5696d28268bb83326456a8b8216344fb84270d18ff1d7628051879d9
+  languageName: node
+  linkType: hard
+
+"which-typed-array@npm:^1.1.16":
+  version: 1.1.18
+  resolution: "which-typed-array@npm:1.1.18"
+  dependencies:
+    available-typed-arrays: ^1.0.7
+    call-bind: ^1.0.8
+    call-bound: ^1.0.3
+    for-each: ^0.3.3
+    gopd: ^1.2.0
+    has-tostringtag: ^1.0.2
+  checksum: d2feea7f51af66b3a240397aa41c796585033e1069f18e5b6d4cd3878538a1e7780596fd3ea9bf347c43d9e98e13be09b37d9ea3887cef29b11bc291fd47bb52
+  languageName: node
+  linkType: hard
+
+"which@npm:^1.2.9":
+  version: 1.3.1
+  resolution: "which@npm:1.3.1"
+  dependencies:
+    isexe: ^2.0.0
+  bin:
+    which: ./bin/which
+  checksum: f2e185c6242244b8426c9df1510e86629192d93c1a986a7d2a591f2c24869e7ffd03d6dac07ca863b2e4c06f59a4cc9916c585b72ee9fa1aa609d0124df15e04
+  languageName: node
+  linkType: hard
+
+"which@npm:^2.0.1":
+  version: 2.0.2
+  resolution: "which@npm:2.0.2"
+  dependencies:
+    isexe: ^2.0.0
+  bin:
+    node-which: ./bin/node-which
+  checksum: 1a5c563d3c1b52d5f893c8b61afe11abc3bab4afac492e8da5bde69d550de701cf9806235f20a47b5c8fa8a1d6a9135841de2596535e998027a54589000e66d1
+  languageName: node
+  linkType: hard
+
+"which@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "which@npm:5.0.0"
+  dependencies:
+    isexe: ^3.1.1
+  bin:
+    node-which: bin/which.js
+  checksum: 6ec99e89ba32c7e748b8a3144e64bfc74aa63e2b2eacbb61a0060ad0b961eb1a632b08fb1de067ed59b002cec3e21de18299216ebf2325ef0f78e0f121e14e90
+  languageName: node
+  linkType: hard
+
+"wildcard@npm:^2.0.0":
+  version: 2.0.1
+  resolution: "wildcard@npm:2.0.1"
+  checksum: e0c60a12a219e4b12065d1199802d81c27b841ed6ad6d9d28240980c73ceec6f856771d575af367cbec2982d9ae7838759168b551776577f155044f5a5ba843c
+  languageName: node
+  linkType: hard
+
+"word-wrap@npm:^1.2.5":
+  version: 1.2.5
+  resolution: "word-wrap@npm:1.2.5"
+  checksum: f93ba3586fc181f94afdaff3a6fef27920b4b6d9eaefed0f428f8e07adea2a7f54a5f2830ce59406c8416f033f86902b91eb824072354645eea687dff3691ccb
+  languageName: node
+  linkType: hard
+
+"worker-loader@npm:^3.0.2":
+  version: 3.0.8
+  resolution: "worker-loader@npm:3.0.8"
+  dependencies:
+    loader-utils: ^2.0.0
+    schema-utils: ^3.0.0
+  peerDependencies:
+    webpack: ^4.0.0 || ^5.0.0
+  checksum: 84f4a7eeb2a1d8b9704425837e017c91eedfae67ac89e0b866a2dcf283323c1dcabe0258196278b7d5fd0041392da895c8a0c59ddf3a94f1b2e003df68ddfec3
+  languageName: node
+  linkType: hard
+
+"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0, wrap-ansi@npm:^7.0.0":
+  version: 7.0.0
+  resolution: "wrap-ansi@npm:7.0.0"
+  dependencies:
+    ansi-styles: ^4.0.0
+    string-width: ^4.1.0
+    strip-ansi: ^6.0.0
+  checksum: a790b846fd4505de962ba728a21aaeda189b8ee1c7568ca5e817d85930e06ef8d1689d49dbf0e881e8ef84436af3a88bc49115c2e2788d841ff1b8b5b51a608b
+  languageName: node
+  linkType: hard
+
+"wrap-ansi@npm:^8.1.0":
+  version: 8.1.0
+  resolution: "wrap-ansi@npm:8.1.0"
+  dependencies:
+    ansi-styles: ^6.1.0
+    string-width: ^5.0.1
+    strip-ansi: ^7.0.1
+  checksum: 371733296dc2d616900ce15a0049dca0ef67597d6394c57347ba334393599e800bab03c41d4d45221b6bc967b8c453ec3ae4749eff3894202d16800fdfe0e238
+  languageName: node
+  linkType: hard
+
+"wrappy@npm:1":
+  version: 1.0.2
+  resolution: "wrappy@npm:1.0.2"
+  checksum: 159da4805f7e84a3d003d8841557196034155008f817172d4e986bd591f74aa82aa7db55929a54222309e01079a65a92a9e6414da5a6aa4b01ee44a511ac3ee5
+  languageName: node
+  linkType: hard
+
+"write-file-atomic@npm:^4.0.2":
+  version: 4.0.2
+  resolution: "write-file-atomic@npm:4.0.2"
+  dependencies:
+    imurmurhash: ^0.1.4
+    signal-exit: ^3.0.7
+  checksum: 5da60bd4eeeb935eec97ead3df6e28e5917a6bd317478e4a85a5285e8480b8ed96032bbcc6ecd07b236142a24f3ca871c924ec4a6575e623ec1b11bf8c1c253c
+  languageName: node
+  linkType: hard
+
+"ws@npm:^8.11.0":
+  version: 8.18.0
+  resolution: "ws@npm:8.18.0"
+  peerDependencies:
+    bufferutil: ^4.0.1
+    utf-8-validate: ">=5.0.2"
+  peerDependenciesMeta:
+    bufferutil:
+      optional: true
+    utf-8-validate:
+      optional: true
+  checksum: 91d4d35bc99ff6df483bdf029b9ea4bfd7af1f16fc91231a96777a63d263e1eabf486e13a2353970efc534f9faa43bdbf9ee76525af22f4752cbc5ebda333975
+  languageName: node
+  linkType: hard
+
+"xml-name-validator@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "xml-name-validator@npm:4.0.0"
+  checksum: af100b79c29804f05fa35aa3683e29a321db9b9685d5e5febda3fa1e40f13f85abc40f45a6b2bf7bee33f68a1dc5e8eaef4cec100a304a9db565e6061d4cb5ad
+  languageName: node
+  linkType: hard
+
+"xmlchars@npm:^2.2.0":
+  version: 2.2.0
+  resolution: "xmlchars@npm:2.2.0"
+  checksum: 8c70ac94070ccca03f47a81fcce3b271bd1f37a591bf5424e787ae313fcb9c212f5f6786e1fa82076a2c632c0141552babcd85698c437506dfa6ae2d58723062
+  languageName: node
+  linkType: hard
+
+"y-protocols@npm:^1.0.5":
+  version: 1.0.6
+  resolution: "y-protocols@npm:1.0.6"
+  dependencies:
+    lib0: ^0.2.85
+  peerDependencies:
+    yjs: ^13.0.0
+  checksum: 4b57c8811befcf2e45c3d47830005f8a33e626c734f78a42fe8a4fa3caad2233ba85a7c8bceefbd52ffc40130d3f3faee664fd0d1c324ff1fa8817a056ccdc1c
+  languageName: node
+  linkType: hard
+
+"y18n@npm:^5.0.5":
+  version: 5.0.8
+  resolution: "y18n@npm:5.0.8"
+  checksum: 54f0fb95621ee60898a38c572c515659e51cc9d9f787fb109cef6fde4befbe1c4602dc999d30110feee37456ad0f1660fa2edcfde6a9a740f86a290999550d30
+  languageName: node
+  linkType: hard
+
+"yallist@npm:^3.0.2":
+  version: 3.1.1
+  resolution: "yallist@npm:3.1.1"
+  checksum: 48f7bb00dc19fc635a13a39fe547f527b10c9290e7b3e836b9a8f1ca04d4d342e85714416b3c2ab74949c9c66f9cebb0473e6bc353b79035356103b47641285d
+  languageName: node
+  linkType: hard
+
+"yallist@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "yallist@npm:4.0.0"
+  checksum: 343617202af32df2a15a3be36a5a8c0c8545208f3d3dfbc6bb7c3e3b7e8c6f8e7485432e4f3b88da3031a6e20afa7c711eded32ddfb122896ac5d914e75848d5
+  languageName: node
+  linkType: hard
+
+"yallist@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "yallist@npm:5.0.0"
+  checksum: eba51182400b9f35b017daa7f419f434424410691bbc5de4f4240cc830fdef906b504424992700dc047f16b4d99100a6f8b8b11175c193f38008e9c96322b6a5
+  languageName: node
+  linkType: hard
+
+"yargs-parser@npm:^21.1.1":
+  version: 21.1.1
+  resolution: "yargs-parser@npm:21.1.1"
+  checksum: ed2d96a616a9e3e1cc7d204c62ecc61f7aaab633dcbfab2c6df50f7f87b393993fe6640d017759fe112d0cb1e0119f2b4150a87305cc873fd90831c6a58ccf1c
+  languageName: node
+  linkType: hard
+
+"yargs@npm:^17.3.1":
+  version: 17.7.2
+  resolution: "yargs@npm:17.7.2"
+  dependencies:
+    cliui: ^8.0.1
+    escalade: ^3.1.1
+    get-caller-file: ^2.0.5
+    require-directory: ^2.1.1
+    string-width: ^4.2.3
+    y18n: ^5.0.5
+    yargs-parser: ^21.1.1
+  checksum: 73b572e863aa4a8cbef323dd911d79d193b772defd5a51aab0aca2d446655216f5002c42c5306033968193bdbf892a7a4c110b0d77954a7fdf563e653967b56a
+  languageName: node
+  linkType: hard
+
+"yjs@npm:^13.5.40":
+  version: 13.6.20
+  resolution: "yjs@npm:13.6.20"
+  dependencies:
+    lib0: ^0.2.98
+  checksum: a87295efe7df58ae8b5cf09b7cdbbcc3cbfba2b7fb72bb424513eb25587eff8dc8304f41e3bcd3926c02c86a0f7ce2185285e4b9d71aca5ff50cefe1ecb6657c
+  languageName: node
+  linkType: hard
+
+"yocto-queue@npm:^0.1.0":
+  version: 0.1.0
+  resolution: "yocto-queue@npm:0.1.0"
+  checksum: f77b3d8d00310def622123df93d4ee654fc6a0096182af8bd60679ddcdfb3474c56c6c7190817c84a2785648cdee9d721c0154eb45698c62176c322fb46fc700
+  languageName: node
+  linkType: hard
diff --git a/setup.py b/setup.py
index 43d49fac0..734cbfc6a 100644
--- a/setup.py
+++ b/setup.py
@@ -28,7 +28,9 @@
     "pydantic",
     "referencing",
     "requests",
+    "psutil",
     "tiktoken>=0.3",
+    "guidance-stitch",
     "llguidance==0.5.1",
 ]
 
@@ -70,6 +72,7 @@
     "types-regex",
     "types-requests",
     "types-jsonschema",
+    "anytree"
 ]
 bench_requires = [
     "pandas",
diff --git a/tests/model_specific/test_visual.py b/tests/model_specific/test_visual.py
new file mode 100644
index 000000000..a513503d7
--- /dev/null
+++ b/tests/model_specific/test_visual.py
@@ -0,0 +1,32 @@
+def test_repeat_base_qwen_widget():
+    from guidance.models import Transformers
+    from guidance import gen
+    from guidance.visual import JupyterWidgetRenderer
+
+    model = "Qwen/Qwen2-1.5B-Instruct"
+    base_lm = Transformers(model)
+    old_renderer = base_lm.engine.renderer
+    base_lm.engine.renderer = JupyterWidgetRenderer(base_lm.engine.trace_handler)
+    del old_renderer
+
+    # This always passes
+    lm = base_lm + """\
+    1 + 1 = add(1, 1) = 2
+    3 + 5 = add(3, 5) = 8
+    11 + 9 = """
+    lm = lm + gen(max_tokens=33, name="result")
+
+    # We're testing this second attempt runs or raises exception.
+    from guidance import guidance
+    @guidance
+    def add(lm, input1, input2):
+        lm += f" = {int(input1) + int(input2)}"
+        return lm
+
+    lm = base_lm + """\
+    1 + 1 = add(1, 1) = 2
+    3 + 5 = add(3, 5) = 8
+    11 + 9"""
+    lm = lm + gen(max_tokens=30, tools=[add])
+
+    assert True
\ No newline at end of file
diff --git a/tests/unit/library/test_block.py b/tests/unit/library/test_block.py
index 3cac69671..495116c1e 100644
--- a/tests/unit/library/test_block.py
+++ b/tests/unit/library/test_block.py
@@ -1,4 +1,5 @@
 from guidance import any_char, block, models
+import pytest
 
 
 def test_text_opener():
@@ -9,11 +10,12 @@ def test_text_opener():
 
 
 def test_text_closer():
-    model = models.Mock("<s>aclose text")
+    # NOTE(nopdive): Behavioral change, no longer need closer for str call.
+    model = models.Mock("<s>a")
     model += "<s>"
     with block(closer="close text"):
         model += any_char()
-    assert str(model) == "<s>aclose text"
+    assert str(model) == "<s>a"
 
 
 def test_grammar_opener():
@@ -23,6 +25,8 @@ def test_grammar_opener():
     assert str(model) == "open texta"
 
 
+# TODO(nopdive): Review this exception later -- how should we be going about grammars in blocks overall.
+@pytest.mark.skip(reason="requires review")
 def test_grammar_closer():
     model = models.Mock(["<s>aclose text", "<s>close text"])
     model += "<s>"
diff --git a/tests/unit/test_model.py b/tests/unit/test_model.py
index 965c48ce2..21f42184b 100644
--- a/tests/unit/test_model.py
+++ b/tests/unit/test_model.py
@@ -1,6 +1,6 @@
 import pytest
 import guidance
-from guidance import gen, models
+from guidance import gen, models, user, system
 
 def test_call_embeddings():
     """This tests calls embedded in strings."""
@@ -22,6 +22,7 @@ def ble(lm):
 
     assert "{{G|" not in str(model + ble())
 
+
 @pytest.mark.xfail(
     reason="llguidance currently emits an additional empty capture group when no explicit stop is provided"
 )
@@ -38,4 +39,16 @@ def test_model_set():
     assert model.log_prob("list_num") is not None
 
     model += gen("list_num", max_tokens=10, list_append=True)
-    assert len(model['list_num']) == 3
\ No newline at end of file
+    assert len(model['list_num']) == 3
+
+
+def test_trace():
+    from guidance import system, user, gen, models
+    m0 = models.Mock()
+
+    with system():
+        m1 = m0 + "You are responsible for autocompleting a sentence."
+    with user():
+        m2 = m1 + "Roses are red and " + gen(name="suffix", regex='[A-Za-z]{2,5}', max_tokens=5)
+
+    assert m2['suffix'] is not None
\ No newline at end of file
diff --git a/tests/unit/test_trace.py b/tests/unit/test_trace.py
new file mode 100644
index 000000000..cda606ea2
--- /dev/null
+++ b/tests/unit/test_trace.py
@@ -0,0 +1,87 @@
+import pytest
+
+from guidance.trace._trace import WeakRefList, TraceHandler, LiteralInput, TextOutput, RoleCloserInput
+from guidance.trace import TraceNode, StatelessGuidanceInput, StatefulGuidanceInput, ImageInput, EmbeddedInput, \
+    RoleOpenerInput, ImageOutput, CaptureOutput
+
+
+def test_weak_ref_list():
+    class EmptyClass:
+        pass
+
+    a = EmptyClass()
+    b = EmptyClass()
+    li = WeakRefList()
+    li.append(a)
+    li.append(b)
+
+    del a
+    with pytest.raises(ReferenceError):
+        _ = li[0]
+
+    # Does not remove dead entries
+    _ = li[1]
+    assert len(li) == 2
+
+    # Remove works as expected
+    li.remove(b)
+    assert len(li) == 1
+
+    # Iter goes over live entries only
+    for el in li:
+        _ = el
+
+
+def test_trace_node():
+    root = TraceNode()
+    child1 = TraceNode()
+    child2 = TraceNode()
+    root.add_child(child1)
+    root.add_child(child2)
+
+    assert root.root() is root
+    assert list(root.ancestors()) == []
+    assert list(root.path()) == [root]
+    assert list(root.traverse()) == [root, child1, child2]
+
+    assert child1.root() is root
+    assert list(child1.ancestors()) == [root]
+    assert list(child1.path()) == [root, child1]
+    assert list(child1.traverse()) == [child1]
+
+
+def test_trace_handler():
+    trace_handler = TraceHandler()
+    root = trace_handler.update_node(0, None, None)
+    child1 = trace_handler.update_node(1, 0, None)
+    inp = LiteralInput(value="")
+    out = TextOutput(value="")
+    pre_child2 = trace_handler.update_node(2, 0, inp)
+    child2 = trace_handler.update_node(2, 0, out)
+
+    assert pre_child2 == child2
+    assert child2.input == inp
+    assert child2.output == out
+    assert child2.root() == root
+    assert child1 not in child2.path()
+
+
+
+@pytest.mark.parametrize(
+    'node',
+    [
+        StatelessGuidanceInput(value=None),
+        StatefulGuidanceInput(value=None),
+        LiteralInput(value=""),
+        ImageInput(value=b""),
+        EmbeddedInput(value=""),
+        RoleOpenerInput(name=""),
+        RoleCloserInput(name=""),
+        TextOutput(value=""),
+        ImageOutput(value=b""),
+        CaptureOutput(name=""),
+    ]
+)
+def test_node_format_smoke(node):
+    node.__repr__()
+    node.__str__()
diff --git a/tests/unit/test_visual.py b/tests/unit/test_visual.py
new file mode 100644
index 000000000..d61d5427d
--- /dev/null
+++ b/tests/unit/test_visual.py
@@ -0,0 +1,64 @@
+import pytest
+from guidance._schema import GenTokenExtra, GenToken
+from guidance.trace import TraceHandler, LiteralInput, TextOutput
+from guidance.visual import TraceMessage, MetricMessage, ExecutionCompletedMessage, \
+    TokensMessage, ResetDisplayMessage, ClientReadyMessage, OutputRequestMessage, \
+    ClientReadyAckMessage, trace_node_to_html, display_trace_tree, trace_node_to_str
+from guidance.visual import serialize_message, deserialize_message
+from guidance.visual._async import async_loop, async_task, run_async_coroutine
+from guidance.visual._environment import Environment
+import asyncio
+
+
+@pytest.mark.parametrize(
+    "message",
+    [
+        TraceMessage(trace_id=0),
+        MetricMessage(name="name", value="value"),
+        ExecutionCompletedMessage(last_trace_id=0),
+        TokensMessage(trace_id=0, text="text", tokens=[
+            GenTokenExtra(token_id=0, prob=0, top_k=[GenToken(token_id=0, prob=0)])
+        ]),
+        ResetDisplayMessage(),
+        ClientReadyMessage(),
+        ClientReadyAckMessage(),
+        OutputRequestMessage(),
+    ]
+)
+def test_serialization(message):
+    ser = serialize_message(message)
+    deser = deserialize_message(ser)
+    assert deser.model_dump() == message.model_dump()
+
+
+def test_async():
+    loop = async_loop()
+    assert loop != asyncio.get_event_loop()
+
+    async def f():
+        return True
+
+    task = run_async_coroutine(async_task(f())).result()
+    assert task.result() is True
+
+
+def test_str_method_smoke():
+    trace_handler = TraceHandler()
+    trace_handler.update_node(1, 0, None)
+    inp = LiteralInput(value="Hi there!")
+    out = TextOutput(value="Hi there!")
+    trace_handler.update_node(2, 0, inp)
+    child_node = trace_handler.update_node(2, 0, out)
+
+    assert trace_node_to_html(child_node) != ""
+    assert trace_node_to_str(child_node) != ""
+    assert display_trace_tree(trace_handler) is None
+
+
+def test_environment():
+    env = Environment()
+    assert not env.is_cloud()
+    assert not env.is_notebook()
+    assert env.is_terminal()
+    assert "ipython-zmq" not in env.detected_envs
+

From 46340aa58b51a0714066a9faeba18c6cb2128f34 Mon Sep 17 00:00:00 2001
From: Harsha Nori <harsha.nori@live.com>
Date: Tue, 7 Jan 2025 12:33:24 -0800
Subject: [PATCH 29/30] Update to version 0.2.0

---
 guidance/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/guidance/__init__.py b/guidance/__init__.py
index 7fec48a57..c8de13295 100644
--- a/guidance/__init__.py
+++ b/guidance/__init__.py
@@ -1,4 +1,4 @@
-__version__ = "0.2.0rc1"
+__version__ = "0.2.0"
 
 import sys
 import types

From 71f1a6876cfddf68e9676a3d6b6bfec31f282f40 Mon Sep 17 00:00:00 2001
From: JC1DA <nlhuynh.2014@phdis.smu.edu.sg>
Date: Mon, 13 Jan 2025 13:51:05 -0800
Subject: [PATCH 30/30] Exclude llama-cpp-python 0.3.6 in testcases (#1096)

Latest llama-cpp-python 0.3.6 breaks some of our testcases.

Relevant issue: https://github.com/ggerganov/llama.cpp/issues/11197
(Different results returned using same prompt with temperature 0)

Temporarily exclude this version until it's fixed

Signed-off-by: Loc Huynh <lohuynh@microsoft.com>
Co-authored-by: Loc Huynh <lohuynh@microsoft.com>
---
 .github/workflows/action_gpu_basic_tests.yml   | 2 +-
 .github/workflows/action_plain_basic_tests.yml | 2 +-
 .github/workflows/ci_tests.yml                 | 4 ++--
 .github/workflows/notebook_tests.yml           | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/action_gpu_basic_tests.yml b/.github/workflows/action_gpu_basic_tests.yml
index 97190ec34..5b5a09bad 100644
--- a/.github/workflows/action_gpu_basic_tests.yml
+++ b/.github/workflows/action_gpu_basic_tests.yml
@@ -62,7 +62,7 @@ jobs:
           pip install accelerate
           echo "=============================="
           pip uninstall -y llama-cpp-python
-          CMAKE_ARGS="-DGGML_CUDA=on" pip install "llama-cpp-python!=0.2.58,!=0.2.75,!=0.2.84"
+          CMAKE_ARGS="-DGGML_CUDA=on" pip install "llama-cpp-python!=0.2.58,!=0.2.75,!=0.2.84,!=0.3.6"
       - name: Check GPU available
         run: |
           python -c "import torch; assert torch.cuda.is_available()"
diff --git a/.github/workflows/action_plain_basic_tests.yml b/.github/workflows/action_plain_basic_tests.yml
index 789a53ab9..0a2d0b6c3 100644
--- a/.github/workflows/action_plain_basic_tests.yml
+++ b/.github/workflows/action_plain_basic_tests.yml
@@ -40,7 +40,7 @@ jobs:
           pip install sentencepiece
           echo "=============================="
           pip uninstall -y llama-cpp-python
-          pip install "llama-cpp-python!=0.2.58,!=0.2.79,!=0.2.84"
+          pip install "llama-cpp-python!=0.2.58,!=0.2.79,!=0.2.84,!=0.3.6"
           echo "=============================="
           pip uninstall -y transformers
           pip install "transformers!=4.43.0,!=4.43.1,!=4.43.2,!=4.43.3" # Issue 965
diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml
index 1911f99fe..54453442d 100644
--- a/.github/workflows/ci_tests.yml
+++ b/.github/workflows/ci_tests.yml
@@ -57,7 +57,7 @@ jobs:
       - name: GPU pip installs
         run: |
           pip install accelerate
-          CMAKE_ARGS="-DGGML_CUDA=on" pip install "llama-cpp-python!=0.2.58,!=0.2.75,!=0.2.84"
+          CMAKE_ARGS="-DGGML_CUDA=on" pip install "llama-cpp-python!=0.2.58,!=0.2.75,!=0.2.84,!=0.3.6"
       - name: Check GPU available
         run: |
           python -c "import torch; assert torch.cuda.is_available()"
@@ -153,7 +153,7 @@ jobs:
           echo "======================"
           nvcc --version
           echo "======================"
-          CMAKE_ARGS="-DGGML_CUDA=on" pip install "llama-cpp-python!=0.2.58,!=0.2.75"
+          CMAKE_ARGS="-DGGML_CUDA=on" pip install "llama-cpp-python!=0.2.58,!=0.2.75,!=0.3.6"
       - name: Check GPU available
         run: |
           python -c "import torch; assert torch.cuda.is_available()"
diff --git a/.github/workflows/notebook_tests.yml b/.github/workflows/notebook_tests.yml
index d2b19e622..fd217d321 100644
--- a/.github/workflows/notebook_tests.yml
+++ b/.github/workflows/notebook_tests.yml
@@ -60,7 +60,7 @@ jobs:
       - name: GPU pip installs
         run: |
           pip install accelerate
-          CMAKE_ARGS="-DGGML_CUDA=on" pip install "llama-cpp-python!=0.2.58,!=0.2.75,!=0.2.84"
+          CMAKE_ARGS="-DGGML_CUDA=on" pip install "llama-cpp-python!=0.2.58,!=0.2.75,!=0.2.84,!=0.3.6"
       - name: Check GPU available
         run: |
           python -c "import torch; assert torch.cuda.is_available()"