fastplotpy 0.3.0a1__py3-none-win_amd64.whl

fastplotpy/assets/native/NotoSans-OFL.txt

@@ -0,0 +1,96 @@
+Copyright 2018 The Noto Project Authors (github.com/googlei18n/noto-fonts)
+
+This Font Software is licensed under the SIL Open Font License,
+Version 1.1.
+
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font
+creation efforts of academic and linguistic communities, and to
+provide a free and open framework in which fonts may be shared and
+improved in partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply to
+any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software
+components as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to,
+deleting, or substituting -- in part or in whole -- any of the
+components of the Original Version, by changing formats or by porting
+the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed,
+modify, redistribute, and sell modified and unmodified copies of the
+Font Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components, in
+Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the
+corresponding Copyright Holder. This restriction only applies to the
+primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created using
+the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+
+

fastplotpy/assets/native/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,24 @@
+# Third-Party Notices
+
+The optional Python-host Rust native library embeds two unmodified font files from the archived
+`notofonts/noto-fonts` repository at commit
+`ffebf8c1ee449e544955a7e813c54f9b73848eac`:
+
+- `NotoSans-Regular.ttf` — SHA-256
+  `b85c38ecea8a7cfb39c24e395a4007474fa5a4fc864f6ee33309eb4948d232d5`
+- `NotoSans-SemiBold.ttf` — SHA-256
+  `87a8b90ece1e89746b544e4e086f85a3710e41485a8078f9be874837dfad45d5`
+
+Copyright 2018 The Noto Project Authors
+(https://github.com/googlei18n/noto-fonts).
+
+The fonts are licensed under the SIL Open Font License 1.1. The complete license
+is distributed next to this notice as `NotoSans-OFL.txt`.
+
+The native library uses these fixed bytes exclusively for Scene3D PNG text rasterization.
+It does not scan or load system font directories at runtime.
+
+The Rust core is source-pinned to fastPlotJs. Its dependency versions are
+recorded in `rust/Cargo.lock`; the Python ABI adds a C-compatible wrapper
+without Node or napi-rs. The original Node addon dependency license inventory
+remains upstream history and does not describe the Python wheel.

fastplotpy/assets/package.json

@@ -0,0 +1 @@
+{"type":"module"}

fastplotpy/axes_validation.py

@@ -0,0 +1,102 @@
+"""Source-shaped cartesian axis option validation before scene construction."""
+
+from __future__ import annotations
+
+from datetime import date, datetime, timezone
+from math import isfinite, log10
+from typing import Mapping
+
+from .subplots import resolveTraceSubplotBindings
+
+
+def _js_text(value):
+    if value is None:
+        return "null"
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)
+
+
+def _normalize(value, axis):
+    scale = axis.get("scale", "linear")
+    if scale == "datetime":
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            if not isfinite(value):
+                raise ValueError("Invalid datetime numeric value")
+            return float(value)
+        if isinstance(value, datetime):
+            return value.timestamp() * 1000
+        if isinstance(value, date):
+            return datetime(value.year, value.month, value.day, tzinfo=timezone.utc).timestamp() * 1000
+        try:
+            return datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp() * 1000
+        except (AttributeError, ValueError, OverflowError) as exc:
+            raise ValueError(f"Invalid datetime string value: {_js_text(value)}") from exc
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        if not isfinite(value):
+            raise ValueError("Invalid numeric value")
+        return float(value)
+    if isinstance(value, str):
+        categories = [item for item in axis.get("categories", []) if isinstance(item, str) and item]
+        if categories:
+            if value not in categories:
+                raise ValueError(f"Unknown categorical axis value: {value}")
+            return float(categories.index(value) + 1)
+    if isinstance(value, datetime):
+        return value.timestamp() * 1000
+    if isinstance(value, date):
+        return datetime(value.year, value.month, value.day, tzinfo=timezone.utc).timestamp() * 1000
+    try:
+        result = float(0 if value is None or value == "" else value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"Invalid numeric string value: {_js_text(value)}") from exc
+    if not isfinite(result):
+        raise ValueError(f"Invalid numeric string value: {_js_text(value)}")
+    return result
+
+
+def validateAxisTickOptions(options):
+    axes = options.get("axes") or {}
+    for dimension in ("xAxes", "yAxes"):
+        for axis_id, axis in (axes.get(dimension) or {}).items():
+            prefix = f"axes.{dimension}.{axis_id}"
+            for field in ("labelPrefix", "labelSuffix"):
+                if field in axis and not isinstance(axis[field], str):
+                    raise ValueError(f"{prefix}.{field} must be a string")
+            if "tickValues" not in axis:
+                continue
+            values = axis["tickValues"]
+            if not isinstance(values, list):
+                raise ValueError(f"{prefix}.tickValues must be an array")
+            if not values:
+                raise ValueError(f"{prefix}.tickValues must contain at least one value")
+            for value in values:
+                normalized = _normalize(value, axis)
+                if axis.get("scale") == "logarithmic":
+                    if normalized <= 0:
+                        raise ValueError("Logarithmic scale requires values > 0")
+                    log10(normalized)
+
+
+def validateRenderableAxisSides(options):
+    if not (options.get("axes") or {}).get("show"):
+        return
+    axes = options["axes"]
+    subplots = resolveTraceSubplotBindings(options)
+    seen = {"x": {}, "y": {}}
+    for binding in subplots:
+        for dimension, plural, default_side in (("x", "xAxes", "bottom"), ("y", "yAxes", "left")):
+            axis_id = binding[f"{dimension}AxisId"]
+            axis_map = axes.get(plural) or {}
+            if axis_id not in axis_map and axis_id != dimension:
+                raise ValueError(f"Unknown {dimension}-axis id '{axis_id}' for trace")
+            axis = axis_map.get(axis_id) or {}
+            if axis.get("show") is False:
+                continue
+            side = axis.get("side") or default_side
+            key = (binding["subplotId"], side)
+            seen[dimension].setdefault(key, set()).add(axis_id)
+    for dimension in ("x", "y"):
+        for (_, side), axis_ids in seen[dimension].items():
+            if len(axis_ids) > 1:
+                raise ValueError(f"Multiple visible {dimension}-axes on side '{side}' are not supported")

fastplotpy/camera3d.py

@@ -0,0 +1,104 @@
+"""Programmatic 3D camera operations ported from pinned core/camera3d.ts."""
+from math import asin, cos, hypot, isfinite, pi, sin, tan
+
+
+def _add(left, right):
+    return [a + b for a, b in zip(left, right)]
+
+
+def _subtract(left, right):
+    return [a - b for a, b in zip(left, right)]
+
+
+def _scale(vector, factor):
+    return [value * factor for value in vector]
+
+
+def _dot(left, right):
+    return sum(a * b for a, b in zip(left, right))
+
+
+def _cross(left, right):
+    return [left[1] * right[2] - left[2] * right[1],
+            left[2] * right[0] - left[0] * right[2],
+            left[0] * right[1] - left[1] * right[0]]
+
+
+def _magnitude(vector):
+    return hypot(*vector)
+
+
+def _normalize(vector):
+    length = _magnitude(vector)
+    # The pinned source camera3d.ts rejects vectors at this magnitude.
+    return _scale(vector, 1 / length) if length > 1e-12 else None
+
+
+def _rotate(vector, axis, radians):
+    cosine, sine = cos(radians), sin(radians)
+    return _add(_add(_scale(vector, cosine), _scale(_cross(axis, vector), sine)),
+                _scale(axis, _dot(axis, vector) * (1 - cosine)))
+
+
+def orbitScene3dCamera(state, yawDegrees, pitchDegrees, maxPitchDegrees):
+    if not all(isfinite(value) for value in (yawDegrees, pitchDegrees, maxPitchDegrees)) or not 0 < maxPitchDegrees < 90:
+        return None
+    target = state["target"]
+    eye_offset = _subtract(state["eye"], target)
+    distance = _magnitude(eye_offset)
+    world_up = _normalize(state["up"])
+    if not distance > 1e-12 or world_up is None:
+        return None
+    yawed = _rotate(eye_offset, world_up, yawDegrees * pi / 180)
+    direction = _normalize(yawed)
+    if direction is None:
+        return None
+    current_pitch = asin(max(-1, min(1, _dot(direction, world_up)))) * 180 / pi
+    target_pitch = max(-maxPitchDegrees, min(maxPitchDegrees, current_pitch + pitchDegrees))
+    right = _normalize(_cross(world_up, yawed))
+    if right is None:
+        return None
+    pitched = _rotate(yawed, right, -(target_pitch - current_pitch) * pi / 180)
+    return {**state, "eye": _add(target, pitched)}
+
+
+def dollyScene3dCamera(state, factor, limits):
+    if not isfinite(factor) or factor <= 0:
+        return None
+    if state["projection"] == "orthographic":
+        scale = max(limits["minOrthographicScale"],
+                    min(limits["maxOrthographicScale"], state["orthographicScale"] * factor))
+        return {**state, "orthographicScale": scale}
+    target = state["target"]
+    offset = _subtract(state["eye"], target)
+    distance = _magnitude(offset)
+    if not distance > 1e-12:
+        return None
+    next_distance = max(limits["minDistance"], min(limits["maxDistance"], distance * factor))
+    return {**state, "eye": _add(target, _scale(offset, next_distance / distance))}
+
+
+def panScene3dCamera(state, xRatio, yRatio, aspectRatio):
+    if not all(isfinite(value) for value in (xRatio, yRatio, aspectRatio)) or not aspectRatio > 0:
+        return None
+    eye, target = state["eye"], state["target"]
+    forward = _normalize(_subtract(target, eye))
+    world_up = _normalize(state["up"])
+    if forward is None or world_up is None:
+        return None
+    right = _normalize(_cross(forward, world_up))
+    if right is None:
+        return None
+    view_up = _normalize(_cross(right, forward))
+    if view_up is None:
+        return None
+    distance = _magnitude(_subtract(eye, target))
+    if not distance > 1e-12:
+        return None
+    vertical_span = (state["orthographicScale"] if state["projection"] == "orthographic"
+                     else 2 * distance * tan(state["fieldOfViewDegrees"] * pi / 360))
+    if not isfinite(vertical_span) or not vertical_span > 0:
+        return None
+    translation = _add(_scale(right, -xRatio * vertical_span * aspectRatio),
+                       _scale(view_up, yRatio * vertical_span))
+    return {**state, "eye": _add(eye, translation), "target": _add(target, translation)}

fastplotpy/color_scale.py

@@ -0,0 +1,88 @@
+"""Color scale calculations ported from fastPlotJs core/colorScale.ts."""
+
+from __future__ import annotations
+
+from math import floor, isfinite, log10
+from typing import Mapping
+
+
+def _hex(color):
+    if not isinstance(color, str):
+        return None
+    color = color.strip()
+    if len(color) == 4 and color.startswith("#"):
+        try:
+            return [int(digit * 2, 16) for digit in color[1:]]
+        except ValueError:
+            return None
+    if len(color) == 7 and color.startswith("#"):
+        try:
+            return [int(color[index:index + 2], 16) for index in (1, 3, 5)]
+        except ValueError:
+            return None
+    return None
+
+
+def resolve_stops(raw, low, high, name):
+    if not raw:
+        return [{"offset": 0, "color": low}, {"offset": 1, "color": high}]
+    if len(raw) < 2:
+        raise ValueError(f"{name} must contain at least two stops")
+    stops = []
+    for index, stop in enumerate(raw):
+        if not isinstance(stop, Mapping):
+            raise ValueError(f"{name}[{index}] must be a color stop")
+        offset, color = stop.get("offset"), stop.get("color")
+        if isinstance(offset, bool) or not isinstance(offset, (int, float)) or not isfinite(offset) or not 0 <= offset <= 1:
+            raise ValueError(f"{name}[{index}].offset must be a finite number between 0 and 1")
+        if not isinstance(color, str) or not color.strip():
+            raise ValueError(f"{name}[{index}].color must be a non-empty string")
+        if _hex(color) is None:
+            raise ValueError(f"{name}[{index}].color must use #RGB or #RRGGBB format")
+        stops.append({"offset": offset, "color": color.strip()})
+    if stops[0]["offset"] != 0 or stops[-1]["offset"] != 1:
+        raise ValueError(f"{name} must start at offset 0 and end at offset 1")
+    if any(next_stop["offset"] <= stop["offset"] for stop, next_stop in zip(stops, stops[1:])):
+        raise ValueError(f"{name} offsets must be strictly increasing")
+    return stops
+
+
+def scale_ratio(value, low, high, scale="linear"):
+    if scale == "logarithmic":
+        if min(value, low, high) <= 0:
+            raise ValueError("Logarithmic color scales require values and bounds > 0")
+        if low == high:
+            return 1
+        value, low, high = log10(value), log10(low), log10(high)
+    elif low == high:
+        return 1
+    return max(0, min(1, (value - low) / (high - low)))
+
+
+def interpolate(value, low, high, stops, scale="linear"):
+    ratio = scale_ratio(value, low, high, scale)
+    upper = next((index for index, stop in enumerate(stops) if ratio <= stop["offset"]), -1)
+    if upper <= 0:
+        start, end = stops[0], stops[1]
+    elif upper == -1:
+        start, end = stops[-2], stops[-1]
+    else:
+        start, end = stops[upper - 1], stops[upper]
+    first, last = _hex(start["color"]), _hex(end["color"])
+    if first is None or last is None:
+        return end["color"] if ratio >= end["offset"] else start["color"]
+    fraction = max(0, min(1, (ratio - start["offset"]) / (end["offset"] - start["offset"])))
+    channels = [floor(a + (b - a) * fraction + .5) for a, b in zip(first, last)]
+    return f"rgb({channels[0]}, {channels[1]}, {channels[2]})"
+
+
+def legend_ticks(low, high, count, explicit, scale):
+    values = [value for value in explicit if low <= value <= high]
+    if values:
+        return values
+    if low == high:
+        return [low for _ in range(count)]
+    if scale == "logarithmic":
+        start, end = log10(low), log10(high)
+        return [10 ** (start + index / (count - 1) * (end - start)) for index in range(count)]
+    return [low + index / (count - 1) * (high - low) for index in range(count)]

fastplotpy/defaults/area-fill.json

@@ -0,0 +1,5 @@
+{
+  "show": false,
+  "opacity": 0.18,
+  "baseline": "axis-min"
+}

fastplotpy/defaults/bar.json

@@ -0,0 +1,22 @@
+{
+  "mode": "grouped",
+  "orientation": "vertical",
+  "barWidthRatio": 0.72,
+  "minBarWidth": 1,
+  "borderWidth": 0,
+  "borderColor": "rgba(15, 23, 42, 0.35)",
+  "cornerRadius": 0,
+  "valueLabels": {
+    "show": false,
+    "color": "#0f172a",
+    "font": "11px Inter, system-ui, sans-serif",
+    "position": "center",
+    "offset": 4,
+    "decimals": 0,
+    "prefix": "",
+    "suffix": "",
+    "minBarWidth": 18,
+    "minBarHeight": 12,
+    "formatter": null
+  }
+}

fastplotpy/defaults/camera3d.json

@@ -0,0 +1,22 @@
+{
+  "orbit": true,
+  "dolly": true,
+  "pan": true,
+  "touch": true,
+  "keyboard": true,
+  "mouseButton": 0,
+  "panModifierKey": "shift",
+  "preventDefault": true,
+  "minDragDistance": 2,
+  "orbitDegreesPerPixel": 0.35,
+  "wheelDollySpeed": 0.0015,
+  "keyboardOrbitDegrees": 5,
+  "keyboardDollyFactor": 0.9,
+  "keyboardPanRatio": 0.05,
+  "minDistance": 0.25,
+  "maxDistance": 1000,
+  "minOrthographicScale": 0.01,
+  "maxOrthographicScale": 1000000,
+  "maxPitchDegrees": 89.5,
+  "maxInteractivePoints": 5000
+}

fastplotpy/defaults/cartesian-references.json

@@ -0,0 +1,10 @@
+{
+  "lineColor": "#dc2626",
+  "lineWidth": 1.5,
+  "linePattern": "dashed",
+  "bandFillColor": "rgba(220, 38, 38, 0.12)",
+  "labelColor": "#991b1b",
+  "labelFont": "11px sans-serif",
+  "labelLineHeight": 14,
+  "labelOffset": 4
+}

fastplotpy/defaults/control.json

@@ -0,0 +1,3 @@
+{
+  "panStepRatio": 0.1
+}

fastplotpy/defaults/crosshair.json

@@ -0,0 +1,19 @@
+{
+  "enabled": false,
+  "mode": "xy",
+  "snap": "none",
+  "color": "#64748b",
+  "lineWidth": 1,
+  "lineDash": [4, 4],
+  "label": {
+    "show": false,
+    "font": "12px sans-serif",
+    "lineHeight": 18,
+    "color": "#ffffff",
+    "backgroundColor": "rgba(15, 23, 42, 0.92)",
+    "borderColor": "rgba(148, 163, 184, 0.8)",
+    "borderWidth": 1,
+    "padding": 6,
+    "offset": 8
+  }
+}

fastplotpy/defaults/error-bars.json

@@ -0,0 +1,7 @@
+{
+  "show": true,
+  "x": true,
+  "y": true,
+  "lineWidth": 1,
+  "capSize": 6
+}

fastplotpy/defaults/heatmap.json

@@ -0,0 +1,70 @@
+{
+  "valueScale": "linear",
+  "lowColor": "#e0f2fe",
+  "highColor": "#0369a1",
+  "colorStops": [],
+  "xCategories": [],
+  "yCategories": [],
+  "cellGap": 0,
+  "cornerRadius": 0,
+  "borderWidth": 0,
+  "borderColor": "rgba(15, 23, 42, 0.22)",
+  "labels": {
+    "show": false,
+    "font": "11px system-ui, sans-serif",
+    "color": "#475569",
+    "lineHeight": 14,
+    "offset": 10
+  },
+  "guides": {
+    "show": false,
+    "color": "rgba(100, 116, 139, 0.32)",
+    "lineWidth": 1
+  },
+  "missingCells": {
+    "show": false,
+    "fillColor": "rgba(148, 163, 184, 0.18)",
+    "borderColor": "rgba(100, 116, 139, 0.35)",
+    "borderWidth": 1
+  },
+  "cellLabels": {
+    "show": false,
+    "font": "11px system-ui, sans-serif",
+    "color": "#0f172a",
+    "autoContrast": true,
+    "lightTextColor": "#f8fafc",
+    "darkTextColor": "#0f172a",
+    "minimumContrastRatio": 4.5,
+    "lineHeight": 14,
+    "padding": 3,
+    "compactDecimals": 1,
+    "ellipsis": "…",
+    "decimals": 0,
+    "prefix": "",
+    "suffix": "",
+    "minCellWidth": 24,
+    "minCellHeight": 18,
+    "formatter": null
+  },
+  "colorScaleLegend": {
+    "show": false,
+    "position": "right",
+    "title": "",
+    "width": 12,
+    "height": 128,
+    "offset": 16,
+    "tickCount": 3,
+    "tickValues": [],
+    "tickSize": 6,
+    "labelGap": 6,
+    "labelPrefix": "",
+    "labelSuffix": "",
+    "decimals": 0,
+    "font": "11px system-ui, sans-serif",
+    "color": "#475569",
+    "lineHeight": 14,
+    "titleGap": 4,
+    "borderColor": "rgba(15, 23, 42, 0.28)",
+    "borderWidth": 1
+  }
+}

fastplotpy/defaults/interaction.json

@@ -0,0 +1,3 @@
+{
+  "dragMode": "zoom"
+}

fastplotpy/defaults/layout.json

@@ -0,0 +1,32 @@
+{
+  "margin": {
+    "l": 0,
+    "r": 0,
+    "t": 0,
+    "b": 0
+  },
+  "axisPaddingPercent": {
+    "start": 0,
+    "end": 0
+  },
+  "axisSide": {
+    "x": "bottom",
+    "y": "left"
+  },
+  "subplots": {
+    "rowGap": 16,
+    "columnGap": 20
+  },
+  "decorations": {
+    "titleFont": "600 18px system-ui, sans-serif",
+    "subtitleFont": "13px system-ui, sans-serif",
+    "titleColor": "#0f172a",
+    "subtitleColor": "#475569",
+    "plotAreaBackgroundColor": null,
+    "topPadding": 8,
+    "titleLineHeight": 22,
+    "subtitleLineHeight": 18,
+    "subtitleGap": 4,
+    "bottomGap": 8
+  }
+}

fastplotpy/defaults/legend.json

@@ -0,0 +1,24 @@
+{
+  "show": false,
+  "position": "top-right",
+  "layout": "column",
+  "groupBy": "none",
+  "interactive": true,
+  "font": "12px system-ui, sans-serif",
+  "textLineHeight": 12,
+  "groupTitleFont": "600 12px system-ui, sans-serif",
+  "groupTitleLineHeight": 12,
+  "textColor": "#0f172a",
+  "groupTitleColor": "#334155",
+  "backgroundColor": "rgba(248, 250, 252, 0.68)",
+  "borderColor": "rgba(148, 163, 184, 0.7)",
+  "borderWidth": 1,
+  "itemLineWidth": 2,
+  "itemLineLength": 18,
+  "itemMarkerSize": 4,
+  "itemGap": 6,
+  "groupGap": 10,
+  "itemTextGap": 8,
+  "padding": 8,
+  "outsideGap": 8
+}