@orangelogic/design-system 2.69.0 → 2.70.0

package/library/chunks/LinearGradient.CxfXxvMw.js

@@ -0,0 +1,37 @@
+import { G as x } from "./Gradient.BrDBLm8v.js";
+import { e as $, a as u, f as L, h as j, j as w } from "./am-chart.oZVBmpnn.js";
+class f extends x {
+  /**
+   * @ignore
+   */
+  getFill(y) {
+    const g = this.get("rotation", 0);
+    let i = this.getBounds(y), s = i.left || 0, C = i.right || 0, a = i.top || 0, _ = i.bottom || 0, h = j(g), d = w(g), o = h * (C - s), r = d * (_ - a);
+    o == 0 && (o = 1), r == 0 && (r = 1);
+    let m = Math.max(o, r);
+    const b = this._root._renderer.createLinearGradient(s, a, s + m * h, a + m * d), l = this.get("stops");
+    if (l) {
+      let p = 0;
+      $(l, (e) => {
+        let n = e.offset;
+        u(n) || (n = p / (l.length - 1));
+        let c = e.opacity;
+        u(c) || (c = 1);
+        let t = e.color;
+        if (t) {
+          const G = e.lighten;
+          G && (t = L.lighten(t, G));
+          const N = e.brighten;
+          N && (t = L.brighten(t, N)), b.addColorStop(n, "rgba(" + t.r + "," + t.g + "," + t.b + "," + c + ")");
+        }
+        p++;
+      });
+    }
+    return b;
+  }
+}
+f.className = "LinearGradient";
+f.classNames = x.classNames.concat([f.className]);
+export {
+  f as L
+};

package/library/chunks/MonotoneXTension.CJMEHHj3.js

@@ -0,0 +1,139 @@
+class y {
+  constructor(s, i) {
+    this._line = 0, this._point = 0, this._x0 = 0, this._x1 = 0, this._y0 = 0, this._y1 = 0, this._t0 = 0, this._tension = 0, this._context = s, this._tension = i;
+  }
+  areaStart() {
+    this._line = 0;
+  }
+  areaEnd() {
+    this._line = NaN;
+  }
+  lineStart() {
+    this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN, this._point = 0;
+  }
+  lineEnd() {
+    switch (this._point) {
+      case 2:
+        this._context.lineTo(this._x1, this._y1);
+        break;
+      case 3:
+        r(this, this._t0, x(this, this._t0));
+        break;
+    }
+    (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+  }
+  point(s, i) {
+    [s, i] = [i, s];
+    let n = NaN;
+    if (s = +s, i = +i, !(s === this._x1 && i === this._y1)) {
+      switch (this._point) {
+        case 0:
+          this._point = 1, this._line ? this._context.lineTo(i, s) : this._context.moveTo(i, s);
+          break;
+        case 1:
+          this._point = 2;
+          break;
+        case 2:
+          this._point = 3, r(this, x(this, n = a(this, s, i)), n);
+          break;
+        default:
+          r(this, this._t0, n = a(this, s, i));
+          break;
+      }
+      this._x0 = this._x1, this._x1 = s, this._y0 = this._y1, this._y1 = i, this._t0 = n;
+    }
+  }
+}
+function f(t) {
+  function s(i) {
+    return new y(i, t);
+  }
+  return s.tension = function(i) {
+    return f(+i);
+  }, s;
+}
+function l(t) {
+  return t < 0 ? -1 : 1;
+}
+function a(t, s, i) {
+  let n = t._x1 - t._x0, _ = s - t._x1, e = (t._y1 - t._y0) / (n || _ < 0 && -0), h = (i - t._y1) / (_ || n < 0 && -0), o = (e * _ + h * n) / (n + _);
+  return (l(e) + l(h)) * Math.min(Math.abs(e), Math.abs(h), 0.5 * Math.abs(o)) || 0;
+}
+function x(t, s) {
+  let i = t._x1 - t._x0;
+  return i ? (3 * (t._y1 - t._y0) / i - s) / 2 : s;
+}
+function r(t, s, i) {
+  let n = t._x0, _ = t._y0, e = t._x1, h = t._y1, o = (e - n) / 1.5 * (1 - t._tension);
+  t._context.bezierCurveTo(_ + o * s, n + o, h - o * i, e - o, h, e);
+}
+class T {
+  constructor(s, i) {
+    this._line = 0, this._point = 0, this._x0 = 0, this._x1 = 0, this._y0 = 0, this._y1 = 0, this._t0 = 0, this._tension = 0, this._context = s, this._tension = i;
+  }
+  areaStart() {
+    this._line = 0;
+  }
+  areaEnd() {
+    this._line = NaN;
+  }
+  lineStart() {
+    this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN, this._point = 0;
+  }
+  lineEnd() {
+    switch (this._point) {
+      case 2:
+        this._context.lineTo(this._x1, this._y1);
+        break;
+      case 3:
+        c(this, this._t0, b(this, this._t0));
+        break;
+    }
+    (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+  }
+  point(s, i) {
+    let n = NaN;
+    if (s = +s, i = +i, !(s === this._x1 && i === this._y1)) {
+      switch (this._point) {
+        case 0:
+          this._point = 1, this._line ? this._context.lineTo(s, i) : this._context.moveTo(s, i);
+          break;
+        case 1:
+          this._point = 2;
+          break;
+        case 2:
+          this._point = 3, c(this, b(this, n = p(this, s, i)), n);
+          break;
+        default:
+          c(this, this._t0, n = p(this, s, i));
+          break;
+      }
+      this._x0 = this._x1, this._x1 = s, this._y0 = this._y1, this._y1 = i, this._t0 = n;
+    }
+  }
+}
+function k(t) {
+  function s(i) {
+    return new T(i, t);
+  }
+  return s;
+}
+function u(t) {
+  return t < 0 ? -1 : 1;
+}
+function p(t, s, i) {
+  let n = t._x1 - t._x0, _ = s - t._x1, e = (t._y1 - t._y0) / (n || _ < 0 && -0), h = (i - t._y1) / (_ || n < 0 && -0), o = (e * _ + h * n) / (n + _);
+  return (u(e) + u(h)) * Math.min(Math.abs(e), Math.abs(h), 0.5 * Math.abs(o)) || 0;
+}
+function b(t, s) {
+  let i = t._x1 - t._x0;
+  return i ? (3 * (t._y1 - t._y0) / i - s) / 2 : s;
+}
+function c(t, s, i) {
+  let n = t._x0, _ = t._y0, e = t._x1, h = t._y1, o = (e - n) / 1.5 * (1 - t._tension);
+  t._context.bezierCurveTo(n + o, _ + o * s, e - o, h - o * i, e, h);
+}
+export {
+  k as a,
+  f as c
+};

package/library/chunks/Picture.BNASYM-P.js

@@ -0,0 +1,49 @@
+import { S as d, a as e } from "./am-chart.oZVBmpnn.js";
+class a extends d {
+  constructor() {
+    super(...arguments), this._display = this._root._renderer.makePicture(void 0);
+  }
+  _changed() {
+    if (super._changed(), this.isDirty("width")) {
+      const i = this.get("width");
+      this._display.width = e(i) ? i : void 0;
+    }
+    if (this.isDirty("height")) {
+      const i = this.get("height");
+      this._display.height = e(i) ? i : void 0;
+    }
+    if (this.isDirty("shadowColor")) {
+      this._display.clear();
+      const i = this.get("shadowColor");
+      this._display.shadowColor = i ?? void 0;
+    }
+    this.isDirty("shadowBlur") && (this._display.clear(), this._display.shadowBlur = this.get("shadowBlur")), this.isDirty("shadowOffsetX") && (this._display.clear(), this._display.shadowOffsetX = this.get("shadowOffsetX")), this.isDirty("shadowOffsetY") && (this._display.clear(), this._display.shadowOffsetY = this.get("shadowOffsetY")), this.isDirty("shadowOpacity") && (this._display.clear(), this._display.shadowOpacity = this.get("shadowOpacity")), (this.isDirty("src") || this.isDirty("cors")) && (this._display.clear(), this._load());
+  }
+  _load() {
+    const i = this.get("src");
+    if (i) {
+      const t = new Image();
+      t.crossOrigin = this.get("cors", "anonymous"), t.src = i;
+      const s = this.events;
+      t.decode().then(() => {
+        this._display.image = t, this._updateSize(), !s.isDisposed() && s.isEnabled("loaded") && s.dispatch("loaded", { type: "loaded", target: this });
+      }).catch((h) => {
+        !s.isDisposed() && s.isEnabled("loaderror") && s.dispatch("loaderror", { type: "loaderror", target: this });
+      });
+    }
+  }
+  _updateSize() {
+    super._updateSize();
+    const i = this._display.image;
+    if (i) {
+      let t = this.getPrivate("width", this.get("width")), s = this.getPrivate("height", this.get("height"));
+      const h = i.width && i.height ? i.width / i.height : 0;
+      e(t) && e(s) ? (this._display.width = t, this._display.height = s) : e(t) && h ? s = t / h : e(s) && h ? t = s * h : (t = i.width, s = i.height), e(t) && (this._display.width = t), e(s) && (this._display.height = s), this.markDirtyBounds(), this.markDirty();
+    }
+  }
+}
+a.className = "Picture";
+a.classNames = d.classNames.concat([a.className]);
+export {
+  a as P
+};

package/library/chunks/Polygon.Dr-GV2hn.js

@@ -0,0 +1,70 @@
+import { G as f, e as v, l as m } from "./am-chart.oZVBmpnn.js";
+class P extends f {
+  _beforeChanged() {
+    if (super._beforeChanged(), this.isDirty("coordinates")) {
+      const i = [], n = this.get("coordinates");
+      n && v(n, (e) => {
+        i.push({ x: e[0], y: e[1] });
+      }), this.set("points", i);
+    }
+    if (this.isPrivateDirty("points") && (this._clear = !0), this.isDirty("points")) {
+      this._clear = !0;
+      const i = this.get("points"), n = this._prevSettings.points;
+      if (n) {
+        if (i) {
+          let s = m(i), o = m(n), t = s.length, p = o.length;
+          if (t > p) {
+            let c = m(s);
+            for (let a = 0; a < t; a++) {
+              let y = Math.floor(a / t * p);
+              c[a] = { x: o[y].x, y: o[y].y };
+            }
+            o = c;
+          } else if (p > t) {
+            let c = m(o);
+            for (let a = 0; a < p; a++) {
+              let y = Math.floor(a / p * t);
+              c[a] = { x: s[y].x, y: s[y].y };
+            }
+            s = c;
+          }
+          this.setPrivateRaw("previousPoints", o), this.setPrivateRaw("points", s), this.morphAnimation = this.animatePrivate({ key: "morphProgress", from: 0, to: 1, duration: this.get("animationDuration", 0), easing: this.get("animationEasing") }), this._root.events.once("frameended", () => {
+            this._markDirtyPrivateKey("morphProgress");
+          });
+        }
+      } else
+        this.setPrivateRaw("previousPoints", i), this.setPrivateRaw("points", i);
+      let e = 1 / 0, h = -1 / 0, r = 1 / 0, l = -1 / 0;
+      if (i)
+        for (let s = 1, o = i.length; s < o; s++) {
+          const t = i[s];
+          e = Math.min(e, t.x), h = Math.max(h, t.x), r = Math.min(r, t.y), l = Math.max(l, t.y);
+        }
+      this.setPrivate("minX", e), this.setPrivate("maxX", h), this.setPrivate("minY", r), this.setPrivate("maxY", r);
+    }
+    this.isPrivateDirty("morphProgress") && (this._clear = !0);
+  }
+  _changed() {
+    super._changed(), this._clear && this._draw();
+  }
+  _draw() {
+    const i = this.getPrivate("previousPoints"), n = this.getPrivate("points"), e = this.getPrivate("morphProgress", 1);
+    if (n && i) {
+      const h = n[0], r = i[0];
+      h && this._display.moveTo(r.x + (h.x - r.x) * e, r.y + (h.y - r.y) * e);
+      for (let l = 1, s = n.length; l < s; l++) {
+        const o = n[l], t = i[l];
+        this._display.lineTo(t.x + (o.x - t.x) * e, t.y + (o.y - t.y) * e);
+      }
+      this._display.closePath();
+    }
+  }
+  _updateSize() {
+    this.markDirty(), this._clear = !0;
+  }
+}
+P.className = "Polygon";
+P.classNames = f.classNames.concat([P.className]);
+export {
+  P
+};

package/library/chunks/ProgressPie.4mPA6xqm.js

@@ -0,0 +1,234 @@
+import { B as D, s as E, c as C, g as F, ai as H, G as A, C as u, aj as k, ak as L, a as K, w as W, d as z, b as G, r as T, x as V, H as X } from "./am-chart.oZVBmpnn.js";
+import { T as m } from "./Triangle.BECgi7mc.js";
+import { E as Y } from "./EditableLabel.DPmicdjK.js";
+import { S as M } from "./Slice.Dm56LTKj.js";
+import { C as j } from "./Circle.tOnnO-F-.js";
+class _ extends D {
+  _afterNew() {
+    super._afterNew(), this.addTag("confirm"), E("keyboardevents") && this._disposers.push(C(document, "keydown", (t) => {
+      const e = F(t);
+      this.get("active") && e == "Escape" && this._cancel();
+    })), this._disposers.push(C(document, "click", () => {
+      this._ignoreClick || this._cancel(), this._ignoreClick = !1;
+    })), this.events.on("click", () => {
+      this.get("active") || (this._ignoreClick = !0), this._confirm();
+    });
+  }
+  _cancel() {
+    this.get("active") && (this.events.dispatch("cancelled", {
+      type: "cancelled",
+      target: this
+    }), this.set("active", !1));
+  }
+  _confirm() {
+    this.get("active") && (this.events.dispatch("confirmed", {
+      type: "confirmed",
+      target: this
+    }), this.set("active", !1), this.isFocus() && this.setTimeout(() => {
+      this.set("active", !1), H();
+    }, 10));
+  }
+  _prepareChildren() {
+    super._prepareChildren();
+  }
+}
+_.className = "ConfirmButton";
+_.classNames = D.classNames.concat([_.className]);
+class c extends A {
+  _beforeChanged() {
+    super._beforeChanged(), this.isDirty("points") && (this._clear = !0);
+  }
+  static makeOrthogonal(t) {
+    if (t.length > 1) {
+      const e = [];
+      for (let n = 0; n < t.length - 1; n++) {
+        const a = t[n], i = t[n + 1];
+        e.push(a), a.x !== i.x && a.y !== i.y && e.push({ x: i.x, y: a.y });
+      }
+      e.push(t[t.length - 1]), t = e;
+    }
+    return t;
+  }
+  /**
+   * Handles changes and redraws the orthogonal line with optional rounded corners.
+   */
+  _changed() {
+    if (super._changed(), this._clear) {
+      const t = this._display;
+      let e = this.get("points", []);
+      if (e.length === 0)
+        return;
+      e = c.makeOrthogonal(e), t.moveTo(e[0].x, e[0].y);
+      for (let n = 1; n < e.length; n++) {
+        let a = this.get("cornerRadius", 0);
+        const i = e[n - 1], s = e[n], r = e[n + 1], d = s.y === i.y && s.x !== i.x, p = s.x === i.x && s.y !== i.y, h = r && (d && r.y !== s.y || p && r.x !== s.x);
+        if (a > 0 && r && h) {
+          if (p) {
+            a = Math.min(a, Math.abs(s.x - r.x) / 2, Math.abs(s.y - i.y) / 2);
+            const o = Math.sign(s.y - i.y);
+            t.lineTo(s.x, s.y - a * o);
+            const l = r.x < s.x ? -1 : 1;
+            t.arcTo(s.x, s.y, s.x + a * l, s.y, a);
+          } else if (d) {
+            a = Math.min(a, Math.abs(s.y - r.y) / 2, Math.abs(s.x - i.x) / 2);
+            const o = Math.sign(s.x - i.x);
+            t.lineTo(s.x - a * o, s.y);
+            const l = r.y < s.y ? -1 : 1;
+            t.arcTo(s.x, s.y, s.x, s.y + a * l, a);
+          }
+        } else
+          t.lineTo(s.x, s.y);
+      }
+    }
+  }
+}
+c.className = "OrthogonalLine";
+c.classNames = A.classNames.concat([c.className]);
+class b extends u {
+  constructor() {
+    super(...arguments), this.line = this.children.push(c.new(this._root, { themeTags: ["line"] })), this.hitLine = this.children.push(c.new(this._root, { themeTags: ["hit"] })), this.startArrow = this.children.push(m.new(this._root, {
+      themeTags: ["start", "arrow"]
+    })), this.endArrow = this.children.push(m.new(this._root, {
+      themeTags: ["end", "arrow"]
+    }));
+  }
+  _afterNew() {
+    this.addTag("link"), super._afterNew();
+  }
+  _updateChildren() {
+    if (super._updateChildren(), this.isDirty("points")) {
+      let t = c.makeOrthogonal(this.get("points", []));
+      this.line.set("points", t), this.hitLine.set("points", t);
+      const e = this.startArrow, n = this.endArrow, a = t.length;
+      if (a > 1) {
+        const [i, s] = t;
+        e.setAll({
+          x: i.x,
+          y: i.y,
+          rotation: k(i, s) - 90
+        });
+        const r = t[a - 1], d = t[a - 2];
+        n.setAll({
+          x: r.x,
+          y: r.y,
+          rotation: k(d, r) + 90
+        });
+      } else if (a === 1) {
+        const [i] = t;
+        e.setAll({ x: i.x, y: i.y, rotation: 0 }), n.setAll({ x: i.x, y: i.y, rotation: 0 });
+      }
+    }
+  }
+}
+b.className = "Link";
+b.classNames = u.classNames.concat([b.className]);
+class x extends L {
+  _beforeChanged() {
+    super._beforeChanged(), this.isDirty("gap") && (this._clear = !0);
+  }
+  _draw() {
+    super._draw();
+    const t = this.get("width", 100), e = this.get("height", 100), n = this.get("gap", 0), a = this.get("strokeWidth", 1);
+    if (!n)
+      this._display.moveTo(0, 0), this._display.lineTo(t, 0);
+    else {
+      let r = n + a, d = e / r, p = this.get("angle", 0) * Math.PI / 180;
+      if (p === 0)
+        for (let h = -d; h < d * 2; h++) {
+          const o = Math.round(h * r - r / 2) + 0.5;
+          this._display.moveTo(-t, o), this._display.lineTo(t * 2, o);
+        }
+      else {
+        const h = Math.cos(p), o = Math.sin(p), l = Math.sqrt(t * t + e * e) * 2, S = r / Math.max(Math.abs(h), Math.abs(o)), N = Math.ceil(l / S) * 2;
+        for (let y = -N; y < N; y++) {
+          const f = y * r, B = f * o - l * h, O = f * h + l * o, P = f * o + l * h, R = f * h - l * o;
+          this._display.moveTo(B, O), this._display.lineTo(P, R);
+        }
+      }
+    }
+    this._display.lineStyle(a, this.get("color"), this.get("colorOpacity"));
+    let i = this.get("strokeDasharray");
+    K(i) && (i < 0.5 ? i = [0] : i = [i]), this._display.setLineDash(i);
+    const s = this.get("strokeDashoffset");
+    s && this._display.setLineDashOffset(s), this._display.endStroke();
+  }
+}
+x.className = "LinePattern";
+x.classNames = L.classNames.concat([x.className]);
+class v extends u {
+  constructor() {
+    super(...arguments), this.label = this.children.push(Y.new(this._root, {})), this.buttonsContainer = this.children.push(u.new(this._root, { themeTags: ["buttons"] })), this.upButton = this.buttonsContainer.children.push(m.new(this._root, { themeTags: ["upbutton"] })), this.downButton = this.buttonsContainer.children.push(m.new(this._root, { themeTags: ["downbutton"] }));
+  }
+  _afterNew() {
+    this.addTag("numericstepper"), this.set("layout", this._root.horizontalLayout), this.label.adapters.add("text", (t) => (t && t.replace(/\D/g, ""), t === "" && (t = "0"), t)), this.set("background", W.new(this._root, {
+      fillOpacity: 0,
+      fill: z(16777215)
+    })), this.buttonsContainer.states.create("hidden", {
+      opacity: 0,
+      visible: !0
+    }), this.events.on("pointerover", () => {
+      this.buttonsContainer.set("active", !0);
+    }), this.events.on("pointerout", () => {
+      this.buttonsContainer.set("active", !1);
+    }), this.label.on("text", (t) => {
+      if (t) {
+        const e = parseFloat(t);
+        isNaN(e) || this.set("value", e);
+      }
+    }), this.upButton.events.on("click", () => {
+      this.set("value", this.get("value", 0) + 1);
+    }), this.downButton.events.on("click", () => {
+      this.set("value", Math.max(0, this.get("value", 0) - 1));
+    }), super._afterNew();
+  }
+  _updateChildren() {
+    super._updateChildren();
+    const t = this.get("value", 0), e = this.label;
+    if (this.isDirty("value") && e.set("text", t.toString()), this.isDirty("disabled")) {
+      const n = this.get("disabled", !1);
+      this.set("interactive", !n), this.upButton.set("interactive", !n), this.downButton.set("interactive", !n), n ? (this.label.set("editOn", "none"), this.buttonsContainer.hide(0)) : (this.label.set("editOn", "click"), this.buttonsContainer.show(0));
+    }
+  }
+}
+v.className = "NumericStepper";
+v.classNames = u.classNames.concat([v.className]);
+class w extends u {
+  constructor() {
+    super(...arguments), this.circle = this.children.push(j.new(this._root, {
+      themeTags: ["background"]
+    })), this.label = this.children.push(G.new(this._root, {})), this.slice = this.children.push(M.new(this._root, { isMeasured: !1 })), this.backgroundSlice = this.children.push(M.new(this._root, { themeTags: ["background"] }));
+  }
+  _afterNew() {
+    this.addTag("progresspie"), super._afterNew();
+  }
+  _updateChildren() {
+    if (super._updateChildren(), this.isDirty("width") || this.isDirty("height") || this.isDirty("radius") || this.isDirty("innerRadius")) {
+      const t = this.innerWidth(), e = this.innerHeight(), n = T(this.get("radius", V), Math.min(t, e) / 2), a = T(this.get("innerRadius", X(80)), n);
+      this.slice.setAll({
+        radius: n,
+        innerRadius: a
+      }), this.backgroundSlice.setAll({
+        radius: n,
+        innerRadius: a
+      }), this.circle.set("radius", n);
+    }
+    if (this.isDirty("value")) {
+      const t = this.get("value", 0);
+      this.slice.set("arc", t * 360), this.backgroundSlice.set("arc", 360), this.label.setAll({
+        text: this.getNumberFormatter().format(t * 100, this.get("numberFormat", "#'"))
+      }), this.root.events.once("frameended", () => {
+        this.label.markDirtyKey("text");
+      });
+    }
+  }
+}
+w.className = "ProgressPie";
+w.classNames = u.classNames.concat([w.className]);
+export {
+  _ as C,
+  x as L,
+  v as N,
+  c as O,
+  w as P,
+  b as a
+};

package/library/chunks/RadialLabel.HfsGiN4x.js

@@ -0,0 +1,88 @@
+import { n as c, o as x, b as f, r as R, p as m, q as p, P as D, h as u, j as y } from "./am-chart.oZVBmpnn.js";
+class h extends c {
+  constructor() {
+    super(...arguments), this._display = this._root._renderer.makeRadialText("", this.textStyle);
+  }
+  _afterNew() {
+    super._afterNew();
+  }
+  _beforeChanged() {
+    super._beforeChanged(), this._display.clear(), this.isDirty("textType") && (this._display.textType = this.get("textType"), this.markDirtyBounds()), this.isDirty("radius") && (this._display.radius = this.get("radius"), this.markDirtyBounds()), this.isDirty("startAngle") && (this._display.startAngle = (this.get("startAngle", 0) + 90) * x, this.markDirtyBounds()), this.isDirty("inside") && (this._display.inside = this.get("inside"), this.markDirtyBounds()), this.isDirty("orientation") && (this._display.orientation = this.get("orientation"), this.markDirtyBounds()), this.isDirty("kerning") && (this._display.kerning = this.get("kerning"), this.markDirtyBounds());
+  }
+}
+h.className = "RadialText";
+h.classNames = c.classNames.concat([h.className]);
+class g extends f {
+  constructor() {
+    super(...arguments), this._flipped = !1;
+  }
+  _afterNew() {
+    this._textKeys.push("textType", "kerning"), super._afterNew();
+  }
+  _makeText() {
+    this._text = this.children.push(h.new(this._root, {}));
+  }
+  /**
+   * Returns base radius in pixels.
+   *
+   * @return Base radius
+   */
+  baseRadius() {
+    const t = this.getPrivate("radius", 0), a = this.getPrivate("innerRadius", 0), i = this.get("baseRadius", 0);
+    return a + R(i, t - a);
+  }
+  /**
+   * Returns radius adjustment in pixels.
+   *
+   * @return Radius
+   */
+  radius() {
+    const t = this.get("inside", !1);
+    return this.baseRadius() + this.get("radius", 0) * (t ? -1 : 1);
+  }
+  _updateChildren() {
+    if (super._updateChildren(), this.isDirty("baseRadius") || this.isPrivateDirty("radius") || this.isPrivateDirty("innerRadius") || this.isDirty("labelAngle") || this.isDirty("radius") || this.isDirty("inside") || this.isDirty("orientation") || this.isDirty("textType")) {
+      const t = this.get("textType", "adjusted"), a = this.get("inside", !1), i = this.get("orientation");
+      let s = m(this.get("labelAngle", 0));
+      this._text.set("startAngle", this.get("labelAngle", 0)), this._text.set("inside", a);
+      const r = y(s), n = u(s);
+      let e = this.baseRadius(), l = this.radius();
+      if (this._display.angle = 0, t == "circular")
+        this.setAll({
+          paddingTop: 0,
+          paddingBottom: 0,
+          paddingLeft: 0,
+          paddingRight: 0
+        }), this.setRaw("x", void 0), this.setRaw("y", void 0), this._text.set("orientation", i), this._text.set("radius", l);
+      else {
+        e == 0 && (s = 0, l = 0);
+        let d = l * n, o = l * r;
+        t == "radial" ? (this.setRaw("x", d), this.setRaw("y", o), s < 90 || s > 270 || i != "auto" ? (this._display.angle = s, this._flipped = !1) : (this._display.angle = s + 180, this._flipped = !0), this._dirty.rotation = !1) : t == "adjusted" ? (this.setRaw("centerX", p), this.setRaw("centerY", p), this.setRaw("x", d), this.setRaw("y", o)) : t == "regular" && (this.setRaw("x", d), this.setRaw("y", o));
+      }
+      this.markDirtyPosition(), this.markDirtyBounds();
+    }
+  }
+  _updatePosition() {
+    const t = this.get("textType", "regular"), a = this.get("inside", !1);
+    let i = 0, s = 0, r = this.get("labelAngle", 0), n = this.localBounds(), e = n.right - n.left, l = n.bottom - n.top;
+    if (t == "radial") {
+      if (this._flipped) {
+        let d = this.get("centerX");
+        d instanceof D && (e = e * (1 - d.value * 2)), i = e * u(r), s = e * y(r);
+      }
+    } else !a && t == "adjusted" && (i = e / 2 * u(r), s = l / 2 * y(r));
+    this.setRaw("dx", i), this.setRaw("dy", s), super._updatePosition();
+  }
+  /**
+   * @ignore
+   */
+  get text() {
+    return this._text;
+  }
+}
+g.className = "RadialLabel";
+g.classNames = f.classNames.concat([g.className]);
+export {
+  g as R,
+  h as a
+};