@dynatrace/strato-components 3.10.4 → 3.11.0

package/charts/sankey-chart/vendor/d3-sankey/sankey.js

@@ -0,0 +1,460 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sankey_exports = {};
+__export(sankey_exports, {
+  default: () => Sankey
+});
+module.exports = __toCommonJS(sankey_exports);
+var import_d3_array = require("d3-array");
+var import_align = require("./align.js");
+var import_constant = __toESM(require("./constant.js"));
+function ascendingSourceBreadth(a, b) {
+  return a.source.y0 - b.source.y0 || a.index - b.index;
+}
+function ascendingTargetBreadth(a, b) {
+  return a.target.y0 - b.target.y0 || a.index - b.index;
+}
+function nodeValue(d) {
+  return d.value;
+}
+function linkValue(d) {
+  return d.value;
+}
+function findNode(nodeById, id) {
+  const node = nodeById.get(id);
+  if (!node) {
+    throw new Error("missing: " + id);
+  }
+  return node;
+}
+function computeLinkBreadths({ nodes }) {
+  for (const node of nodes) {
+    let y0 = node.y0;
+    let y1 = y0;
+    for (const link of node.sourceLinks) {
+      link.y0 = y0 + link.width / 2;
+      y0 += link.width;
+    }
+    for (const link of node.targetLinks) {
+      link.y1 = y1 + link.width / 2;
+      y1 += link.width;
+    }
+  }
+}
+function Sankey() {
+  let bx0 = 0, by0 = 0, bx1 = 1, by1 = 1;
+  let dx = 24;
+  let dy = 8, py = 8;
+  let idAccessor = (d) => d.index;
+  let alignFn = import_align.justify;
+  let sortFn;
+  let linkSortFn;
+  let nodesAccessor = (g) => g.nodes;
+  let linksAccessor = (g) => g.links;
+  let iterations = 6;
+  function computeNodeLinks(graph) {
+    for (const [i, node] of graph.nodes.entries()) {
+      node.index = i;
+      node.sourceLinks = [];
+      node.targetLinks = [];
+    }
+    const nodeById = new Map(
+      graph.nodes.map((d) => [idAccessor(d), d])
+    );
+    const unresolvedLinks = graph.links;
+    for (const [i, link] of unresolvedLinks.entries()) {
+      link.index = i;
+      if (typeof link.source !== "object") {
+        link.source = findNode(nodeById, link.source);
+      }
+      if (typeof link.target !== "object") {
+        link.target = findNode(nodeById, link.target);
+      }
+      link.source.sourceLinks.push(link);
+      link.target.targetLinks.push(link);
+    }
+    if (linkSortFn !== null && linkSortFn !== void 0) {
+      for (const { sourceLinks, targetLinks } of graph.nodes) {
+        sourceLinks.sort(linkSortFn);
+        targetLinks.sort(linkSortFn);
+      }
+    }
+  }
+  function computeNodeValues({ nodes }) {
+    for (const node of nodes) {
+      node.value = node.fixedValue === void 0 ? Math.max(
+        (0, import_d3_array.sum)(node.sourceLinks, linkValue),
+        (0, import_d3_array.sum)(node.targetLinks, linkValue)
+      ) : node.fixedValue;
+    }
+  }
+  function computeNodeDepths({ nodes }) {
+    const n = nodes.length;
+    let current = new Set(nodes);
+    let next = /* @__PURE__ */ new Set();
+    let x = 0;
+    let iterations2 = 0;
+    while (current.size) {
+      let maxPinnedDepth = -1;
+      for (const node of current) {
+        node.depth = typeof node["column"] === "number" ? node["column"] : x;
+        if (typeof node["column"] === "number" && node["column"] > maxPinnedDepth) {
+          maxPinnedDepth = node["column"];
+        }
+        for (const { target } of node.sourceLinks) {
+          next.add(target);
+        }
+      }
+      if (++iterations2 > n) {
+        throw new Error("circular link");
+      }
+      x = Math.max(x + 1, maxPinnedDepth + 1);
+      current = next;
+      next = /* @__PURE__ */ new Set();
+    }
+  }
+  function computeNodeHeights({ nodes }) {
+    const n = nodes.length;
+    let current = new Set(nodes);
+    let next = /* @__PURE__ */ new Set();
+    let x = 0;
+    while (current.size) {
+      for (const node of current) {
+        node.height = x;
+        for (const { source } of node.targetLinks) {
+          next.add(source);
+        }
+      }
+      if (++x > n) {
+        throw new Error("circular link");
+      }
+      current = next;
+      next = /* @__PURE__ */ new Set();
+    }
+  }
+  function computeNodeLayers({ nodes }) {
+    const x = ((0, import_d3_array.max)(nodes, (d) => d.depth) ?? 0) + 1;
+    const kx = (bx1 - bx0 - dx) / (x - 1);
+    const columns = new Array(x);
+    for (const node of nodes) {
+      const i = Math.max(0, Math.min(x - 1, Math.floor(alignFn(node, x))));
+      node.layer = i;
+      node.x0 = bx0 + i * kx;
+      node.x1 = node.x0 + dx;
+      if (columns[i]) {
+        columns[i].push(node);
+      } else {
+        columns[i] = [node];
+      }
+    }
+    const compact = columns.filter((c) => c !== void 0);
+    if (sortFn) {
+      for (const column of compact) {
+        column.sort(sortFn);
+      }
+    }
+    return compact;
+  }
+  function initializeNodeBreadths(columns) {
+    const ky = (0, import_d3_array.min)(
+      columns,
+      (c) => (by1 - by0 - (c.length - 1) * py) / (0, import_d3_array.sum)(c, nodeValue)
+    ) ?? 0;
+    for (const nodes of columns) {
+      let y = by0;
+      for (const node of nodes) {
+        node.y0 = y;
+        node.y1 = y + node.value * ky;
+        y = node.y1 + py;
+        for (const link of node.sourceLinks) {
+          link.width = link.value * ky;
+        }
+      }
+      y = (by1 - y + py) / (nodes.length + 1);
+      for (let i = 0; i < nodes.length; ++i) {
+        const node = nodes[i];
+        node.y0 += y * (i + 1);
+        node.y1 += y * (i + 1);
+      }
+      reorderLinks(nodes);
+    }
+  }
+  function computeNodeBreadths(graph) {
+    const columns = computeNodeLayers(graph);
+    py = Math.min(dy, (by1 - by0) / (((0, import_d3_array.max)(columns, (c) => c.length) ?? 1) - 1));
+    initializeNodeBreadths(columns);
+    for (let i = 0; i < iterations; ++i) {
+      const alpha = Math.pow(0.99, i);
+      const beta = Math.max(1 - alpha, (i + 1) / iterations);
+      relaxRightToLeft(columns, alpha, beta);
+      relaxLeftToRight(columns, alpha, beta);
+    }
+  }
+  function relaxLeftToRight(columns, alpha, beta) {
+    for (let i = 1, n = columns.length; i < n; ++i) {
+      const column = columns[i];
+      for (const target of column) {
+        let y = 0;
+        let w = 0;
+        for (const { source, value } of target.targetLinks) {
+          const v = value * (target.layer - source.layer);
+          y += targetTop(source, target) * v;
+          w += v;
+        }
+        if (!(w > 0)) {
+          continue;
+        }
+        const dy2 = (y / w - target.y0) * alpha;
+        target.y0 += dy2;
+        target.y1 += dy2;
+        reorderNodeLinks(target);
+      }
+      if (sortFn === void 0) {
+        column.sort(ascendingBreadth);
+      }
+      resolveCollisions(column, beta);
+    }
+  }
+  function relaxRightToLeft(columns, alpha, beta) {
+    for (let n = columns.length, i = n - 2; i >= 0; --i) {
+      const column = columns[i];
+      for (const source of column) {
+        let y = 0;
+        let w = 0;
+        for (const { target, value } of source.sourceLinks) {
+          const v = value * (target.layer - source.layer);
+          y += sourceTop(source, target) * v;
+          w += v;
+        }
+        if (!(w > 0)) {
+          continue;
+        }
+        const dy2 = (y / w - source.y0) * alpha;
+        source.y0 += dy2;
+        source.y1 += dy2;
+        reorderNodeLinks(source);
+      }
+      if (sortFn === void 0) {
+        column.sort(ascendingBreadth);
+      }
+      resolveCollisions(column, beta);
+    }
+  }
+  function ascendingBreadth(a, b) {
+    return a.y0 - b.y0;
+  }
+  function resolveCollisions(nodes, alpha) {
+    const i = nodes.length >> 1;
+    const subject = nodes[i];
+    resolveCollisionsBottomToTop(nodes, subject.y0 - py, i - 1, alpha);
+    resolveCollisionsTopToBottom(nodes, subject.y1 + py, i + 1, alpha);
+    resolveCollisionsBottomToTop(nodes, by1, nodes.length - 1, alpha);
+    resolveCollisionsTopToBottom(nodes, by0, 0, alpha);
+  }
+  function resolveCollisionsTopToBottom(nodes, y, i, alpha) {
+    for (; i < nodes.length; ++i) {
+      const node = nodes[i];
+      const dy2 = (y - node.y0) * alpha;
+      if (dy2 > 1e-6) {
+        node.y0 += dy2;
+        node.y1 += dy2;
+      }
+      y = node.y1 + py;
+    }
+  }
+  function resolveCollisionsBottomToTop(nodes, y, i, alpha) {
+    for (; i >= 0; --i) {
+      const node = nodes[i];
+      const dy2 = (node.y1 - y) * alpha;
+      if (dy2 > 1e-6) {
+        node.y0 -= dy2;
+        node.y1 -= dy2;
+      }
+      y = node.y0 - py;
+    }
+  }
+  function reorderNodeLinks({ sourceLinks, targetLinks }) {
+    if (linkSortFn === void 0) {
+      for (const {
+        source: { sourceLinks: sl }
+      } of targetLinks) {
+        sl.sort(ascendingTargetBreadth);
+      }
+      for (const {
+        target: { targetLinks: tl }
+      } of sourceLinks) {
+        tl.sort(ascendingSourceBreadth);
+      }
+    }
+  }
+  function reorderLinks(nodes) {
+    if (linkSortFn === void 0) {
+      for (const { sourceLinks, targetLinks } of nodes) {
+        sourceLinks.sort(ascendingTargetBreadth);
+        targetLinks.sort(ascendingSourceBreadth);
+      }
+    }
+  }
+  function targetTop(source, target) {
+    let y = source.y0 - (source.sourceLinks.length - 1) * py / 2;
+    for (const { target: node, width } of source.sourceLinks) {
+      if (node === target) {
+        break;
+      }
+      y += width + py;
+    }
+    for (const { source: node, width } of target.targetLinks) {
+      if (node === source) {
+        break;
+      }
+      y -= width;
+    }
+    return y;
+  }
+  function sourceTop(source, target) {
+    let y = target.y0 - (target.targetLinks.length - 1) * py / 2;
+    for (const { source: node, width } of target.targetLinks) {
+      if (node === source) {
+        break;
+      }
+      y += width + py;
+    }
+    for (const { target: node, width } of source.sourceLinks) {
+      if (node === target) {
+        break;
+      }
+      y -= width;
+    }
+    return y;
+  }
+  function runLayout(data) {
+    const graph = {
+      nodes: nodesAccessor(data),
+      links: linksAccessor(data)
+    };
+    computeNodeLinks(graph);
+    computeNodeValues(graph);
+    computeNodeDepths(graph);
+    computeNodeHeights(graph);
+    computeNodeBreadths(graph);
+    computeLinkBreadths(graph);
+    return graph;
+  }
+  const layout = Object.assign(runLayout, {
+    update(graph) {
+      computeLinkBreadths(graph);
+      return graph;
+    },
+    nodeId(fn) {
+      if (fn === void 0) {
+        return idAccessor;
+      }
+      idAccessor = fn;
+      return layout;
+    },
+    nodeAlign(fn) {
+      if (fn === void 0) {
+        return alignFn;
+      }
+      alignFn = typeof fn === "function" ? fn : (0, import_constant.default)(fn)();
+      return layout;
+    },
+    nodeSort(fn) {
+      if (arguments.length === 0) {
+        return sortFn;
+      }
+      sortFn = fn;
+      return layout;
+    },
+    nodeWidth(w) {
+      if (w === void 0) {
+        return dx;
+      }
+      dx = +w;
+      return layout;
+    },
+    nodePadding(p) {
+      if (p === void 0) {
+        return dy;
+      }
+      dy = py = +p;
+      return layout;
+    },
+    nodes(accessor) {
+      if (accessor === void 0) {
+        return nodesAccessor;
+      }
+      nodesAccessor = typeof accessor === "function" ? accessor : (0, import_constant.default)(accessor);
+      return layout;
+    },
+    links(accessor) {
+      if (accessor === void 0) {
+        return linksAccessor;
+      }
+      linksAccessor = typeof accessor === "function" ? accessor : (0, import_constant.default)(accessor);
+      return layout;
+    },
+    linkSort(fn) {
+      if (arguments.length === 0) {
+        return linkSortFn;
+      }
+      linkSortFn = fn;
+      return layout;
+    },
+    size(s) {
+      if (s === void 0) {
+        return [bx1 - bx0, by1 - by0];
+      }
+      bx0 = by0 = 0;
+      bx1 = +s[0];
+      by1 = +s[1];
+      return layout;
+    },
+    extent(e) {
+      if (e === void 0) {
+        return [
+          [bx0, by0],
+          [bx1, by1]
+        ];
+      }
+      bx0 = +e[0][0];
+      bx1 = +e[1][0];
+      by0 = +e[0][1];
+      by1 = +e[1][1];
+      return layout;
+    },
+    iterations(n) {
+      if (n === void 0) {
+        return iterations;
+      }
+      iterations = +n;
+      return layout;
+    }
+  });
+  return layout;
+}

package/charts/sankey-chart/vendor/d3-sankey/types.d.ts

@@ -0,0 +1,60 @@
+export interface SankeyExtraProperties {
+    [key: string]: unknown;
+}
+export interface SankeyNodeMinimal<N extends SankeyExtraProperties, L extends SankeyExtraProperties> {
+    sourceLinks?: Array<SankeyLink<N, L>>;
+    targetLinks?: Array<SankeyLink<N, L>>;
+    value?: number;
+    fixedValue?: number;
+    index?: number;
+    depth?: number;
+    height?: number;
+    x0?: number;
+    x1?: number;
+    y0?: number;
+    y1?: number;
+}
+export type SankeyNode<N extends SankeyExtraProperties, L extends SankeyExtraProperties> = N & SankeyNodeMinimal<N, L>;
+export interface SankeyLinkMinimal<N extends SankeyExtraProperties, L extends SankeyExtraProperties> {
+    source: number | string | SankeyNode<N, L>;
+    target: number | string | SankeyNode<N, L>;
+    value: number;
+    y0?: number;
+    y1?: number;
+    width?: number;
+    index?: number;
+}
+export type SankeyLink<N extends SankeyExtraProperties, L extends SankeyExtraProperties> = L & SankeyLinkMinimal<N, L>;
+export interface SankeyGraph<N extends SankeyExtraProperties, L extends SankeyExtraProperties> {
+    nodes: Array<SankeyNode<N, L>>;
+    links: Array<SankeyLink<N, L>>;
+}
+export interface SankeyLayout<Data, N extends SankeyExtraProperties, L extends SankeyExtraProperties> {
+    (data: Data): SankeyGraph<N, L>;
+    update(graph: SankeyGraph<N, L>): SankeyGraph<N, L>;
+    nodes(): (data: Data) => Array<SankeyNode<N, L>>;
+    nodes(nodes: Array<SankeyNode<N, L>>): this;
+    nodes(nodes: (data: Data) => Array<SankeyNode<N, L>>): this;
+    links(): (data: Data) => Array<SankeyLink<N, L>>;
+    links(links: Array<SankeyLink<N, L>>): this;
+    links(links: (data: Data) => Array<SankeyLink<N, L>>): this;
+    nodeId(): (node: SankeyNode<N, L>) => string | number;
+    nodeId(nodeId: (node: SankeyNode<N, L>) => string | number): this;
+    nodeAlign(): (node: SankeyNode<N, L>, n: number) => number;
+    nodeAlign(nodeAlign: (node: SankeyNode<N, L>, n: number) => number): this;
+    nodeWidth(): number;
+    nodeWidth(width: number): this;
+    nodePadding(): number;
+    nodePadding(padding: number): this;
+    extent(): [[number, number], [number, number]];
+    extent(extent: [[number, number], [number, number]]): this;
+    size(): [number, number];
+    size(size: [number, number]): this;
+    iterations(): number;
+    iterations(iterations: number): this;
+    nodeSort(): ((a: SankeyNode<N, L>, b: SankeyNode<N, L>) => number) | undefined | null;
+    nodeSort(compare: ((a: SankeyNode<N, L>, b: SankeyNode<N, L>) => number) | undefined | null): this;
+    linkSort(): ((a: SankeyLink<N, L>, b: SankeyLink<N, L>) => number) | undefined | null;
+    linkSort(compare: ((a: SankeyLink<N, L>, b: SankeyLink<N, L>) => number) | undefined | null): this;
+}
+//# sourceMappingURL=types.d.ts.map

package/charts/sankey-chart/vendor/d3-sankey/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/charts/single-value/SingleValue.css

@@ -1,4 +1,4 @@
-._1sfgzlg0-3-10-4 {
+._1sfgzlg0-3-11-0 {
   height: inherit;
   width: inherit;
 }

package/charts/single-value/SingleValue.sty.js

@@ -21,4 +21,4 @@ __export(SingleValue_css_exports, {
 });
 module.exports = __toCommonJS(SingleValue_css_exports);
 var import_SingleValue_css_ts_vanilla = require("./SingleValue.css");
-var container = "_1sfgzlg0-3-10-4";
+var container = "_1sfgzlg0-3-11-0";

package/charts/single-value-grid/SingleValueGrid.css

@@ -1,7 +1,7 @@
-._1mx9zjb0-3-10-4 {
+._1mx9zjb0-3-11-0 {
   height: 100%;
   width: 100%;
 }
-._1mx9zjb0-3-10-4 > div {
+._1mx9zjb0-3-11-0 > div {
   overflow: hidden;
 }

package/charts/single-value-grid/SingleValueGrid.sty.js

@@ -21,4 +21,4 @@ __export(SingleValueGrid_css_exports, {
 });
 module.exports = __toCommonJS(SingleValueGrid_css_exports);
 var import_SingleValueGrid_css_ts_vanilla = require("./SingleValueGrid.css");
-var gridRows = "_1mx9zjb0-3-10-4";
+var gridRows = "_1mx9zjb0-3-11-0";

package/charts/single-value-grid/components/GlobalFontSizeVariables.css

@@ -1,4 +1,4 @@
-._eom86z0-3-10-4 {
+._eom86z0-3-11-0 {
   position: relative;
   width: 100%;
   height: 100%;

package/charts/single-value-grid/components/GlobalFontSizeVariables.sty.js

@@ -21,4 +21,4 @@ __export(GlobalFontSizeVariables_css_exports, {
 });
 module.exports = __toCommonJS(GlobalFontSizeVariables_css_exports);
 var import_GlobalFontSizeVariables_css_ts_vanilla = require("./GlobalFontSizeVariables.css");
-var fontSizeWrapper = "_eom86z0-3-10-4";
+var fontSizeWrapper = "_eom86z0-3-11-0";

package/charts/timeseries/components/axes/TimeseriesTimeBottomAxisArea/TimeseriesTimeBottomAxisArea.css

@@ -1,6 +1,6 @@
-._19z0vdp0-3-10-4 {
+._19z0vdp0-3-11-0 {
   position: relative;
 }
-._19z0vdp1-3-10-4 {
+._19z0vdp1-3-11-0 {
   touch-action: none;
 }

package/charts/timeseries/components/axes/TimeseriesTimeBottomAxisArea/TimeseriesTimeBottomAxisArea.sty.js

@@ -22,4 +22,4 @@ __export(TimeseriesTimeBottomAxisArea_css_exports, {
 module.exports = __toCommonJS(TimeseriesTimeBottomAxisArea_css_exports);
 var import_TimeseriesTimeBottomAxisArea_css_ts_vanilla = require("./TimeseriesTimeBottomAxisArea.css");
 var import_createRuntimeFn = require("@vanilla-extract/recipes/createRuntimeFn");
-var timeBottomAxisContainer = (0, import_createRuntimeFn.createRuntimeFn)({ defaultClassName: "_19z0vdp0-3-10-4", variantClassNames: { isTouchableDevice: { true: "_19z0vdp1-3-10-4" } }, defaultVariants: {}, compoundVariants: [] });
+var timeBottomAxisContainer = (0, import_createRuntimeFn.createRuntimeFn)({ defaultClassName: "_19z0vdp0-3-11-0", variantClassNames: { isTouchableDevice: { true: "_19z0vdp1-3-11-0" } }, defaultVariants: {}, compoundVariants: [] });

package/charts/timeseries/components/overlays/TimeseriesChartOverlays.js

@@ -240,7 +240,6 @@ const TimeseriesChartOverlays = () => {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
     import_InteractionsOverlay.InteractionsOverlay,
     {
-      "aria-label": import_constants2.TIMESERIES_INTERACTIONS_ARIA_LABEL,
       style: {
         zIndex: import_constants2.zIndicesTimeseriesAreas.overlays,
         userSelect: selectState?.finished === false ? "none" : "auto"

package/charts/timeseries/components/overlays/TimeseriesOverlays.css

@@ -1,8 +1,8 @@
-._17fdb110-3-10-4 {
+._17fdb110-3-11-0 {
   z-index: 1;
   pointer-events: none;
 }
-._17fdb111-3-10-4 {
+._17fdb111-3-11-0 {
   top: -3.5px;
   left: -3.5px;
   width: calc(100% + 7px);
@@ -10,7 +10,7 @@
   z-index: 1;
   pointer-events: none;
 }
-._17fdb112-3-10-4 {
+._17fdb112-3-11-0 {
   top: -7px;
   left: -7px;
   width: calc(100% + 14px);
@@ -18,7 +18,7 @@
   z-index: 2;
   pointer-events: none;
 }
-._17fdb113-3-10-4 {
+._17fdb113-3-11-0 {
   cursor: crosshair;
   overflow: visible;
   pointer-events: none;

package/charts/timeseries/components/overlays/TimeseriesOverlays.sty.js

@@ -25,7 +25,7 @@ __export(TimeseriesOverlays_css_exports, {
 module.exports = __toCommonJS(TimeseriesOverlays_css_exports);
 var import_ChartGrid_css_ts_vanilla = require("../../../core/components/chart-grid/ChartGrid.css");
 var import_TimeseriesOverlays_css_ts_vanilla = require("./TimeseriesOverlays.css");
-var canvasPlot = "_17fdb110-3-10-4 _13lzg4k0-3-10-4";
-var crosshairLayout = "_17fdb113-3-10-4 _13lzg4k0-3-10-4";
-var datapointCanvasPlot = "_17fdb111-3-10-4 _13lzg4k0-3-10-4";
-var datapointIndicatorLayout = "_17fdb112-3-10-4 _13lzg4k0-3-10-4";
+var canvasPlot = "_17fdb110-3-11-0 _13lzg4k0-3-11-0";
+var crosshairLayout = "_17fdb113-3-11-0 _13lzg4k0-3-11-0";
+var datapointCanvasPlot = "_17fdb111-3-11-0 _13lzg4k0-3-11-0";
+var datapointIndicatorLayout = "_17fdb112-3-11-0 _13lzg4k0-3-11-0";

package/charts/timeseries/components/thresholds/ThresholdIndicators.css

@@ -1,6 +1,6 @@
-._9p8qi20-3-10-4 {
+._9p8qi20-3-11-0 {
   z-index: 2;
 }
-._9p8qi21-3-10-4 {
+._9p8qi21-3-11-0 {
   z-index: 0;
 }

package/charts/timeseries/components/thresholds/ThresholdIndicators.sty.js

@@ -23,5 +23,5 @@ __export(ThresholdIndicators_css_exports, {
 module.exports = __toCommonJS(ThresholdIndicators_css_exports);
 var import_ChartGrid_css_ts_vanilla = require("../../../core/components/chart-grid/ChartGrid.css");
 var import_ThresholdIndicators_css_ts_vanilla = require("./ThresholdIndicators.css");
-var thresholdPlotLine = "_9p8qi20-3-10-4 _13lzg4k0-3-10-4";
-var thresholdPlotRange = "_9p8qi21-3-10-4 _13lzg4k0-3-10-4";
+var thresholdPlotLine = "_9p8qi20-3-11-0 _13lzg4k0-3-11-0";
+var thresholdPlotRange = "_9p8qi21-3-11-0 _13lzg4k0-3-11-0";